refactor(hex): Datasource schema validation (#25009)

lib/modules/datasource/hex/index.ts

 import { logger } from '../../../logger';
 import { cache } from '../../../util/cache/package/decorator';
-import type { HttpResponse } from '../../../util/http/types';
 import * as hexVersioning from '../../versioning/hex';
 import { Datasource } from '../datasource';
 import type { GetReleasesConfig, ReleaseResult } from '../types';
-import type { HexRelease } from './types';
+import { HexRelease } from './schema';
 
 export class HexDatasource extends Datasource {
   static readonly id = 'hex';
@@ -43,44 +42,15 @@ export class HexDatasource extends Datasource {
       : '';
     const hexUrl = `${registryUrl}api/${organizationUrlPrefix}packages/${hexPackageName}`;
 
-    let response: HttpResponse<HexRelease>;
-    try {
-      response = await this.http.getJson<HexRelease>(hexUrl);
-    } catch (err) {
-      this.handleGenericErrors(err);
-    }
-
-    const hexRelease: HexRelease = response.body;
-
-    if (!hexRelease) {
-      logger.warn({ datasource: 'hex', packageName }, `Invalid response body`);
-      return null;
-    }
-
-    const { releases = [], html_url: homepage, meta } = hexRelease;
-
-    if (releases.length === 0) {
-      logger.debug(`No versions found for ${hexPackageName} (${hexUrl})`); // prettier-ignore
-      return null;
-    }
-
-    const result: ReleaseResult = {
-      releases: releases.map(({ version, inserted_at }) =>
-        inserted_at
-          ? {
-              version,
-              releaseTimestamp: inserted_at,
-            }
-          : { version },
-      ),
-    };
-
-    if (homepage) {
-      result.homepage = homepage;
-    }
+    const { val: result, err } = await this.http
+      .getJsonSafe(hexUrl, HexRelease)
+      .onError((err) => {
+        logger.warn({ datasource: 'hex', packageName, err }, `Error fetching ${hexUrl}`); // prettier-ignore
+      })
+      .unwrap();
 
-    if (meta?.links?.Github) {
-      result.sourceUrl = meta?.links?.Github;
+    if (err) {
+      this.handleGenericErrors(err);
     }
 
     return result;

lib/modules/datasource/hex/schema.ts

+import { z } from 'zod';
+import { LooseArray } from '../../../util/schema-utils';
+import type { Release, ReleaseResult } from '../types';
+
+export const HexRelease = z
+  .object({
+    html_url: z.string().optional(),
+    meta: z
+      .object({
+        links: z.object({
+          Github: z.string(),
+        }),
+      })
+      .nullable()
+      .catch(null),
+    releases: LooseArray(
+      z.object({
+        version: z.string(),
+        inserted_at: z.string().optional(),
+      }),
+    ).refine((releases) => releases.length > 0, 'No releases found'),
+  })
+  .transform((hexResponse): ReleaseResult => {
+    const releases: Release[] = hexResponse.releases.map(
+      ({ version, inserted_at: releaseTimestamp }): Release => {
+        const release: Release = { version };
+
+        if (releaseTimestamp) {
+          release.releaseTimestamp = releaseTimestamp;
+        }
+
+        return release;
+      },
+    );
+
+    const releaseResult: ReleaseResult = { releases };
+
+    if (hexResponse.html_url) {
+      releaseResult.homepage = hexResponse.html_url;
+    }
+
+    if (hexResponse.meta?.links?.Github) {
+      releaseResult.sourceUrl = hexResponse.meta.links.Github;
+    }
+
+    return releaseResult;
+  });

lib/modules/datasource/hex/types.ts

-export interface HexRelease {
-  html_url: string;
-  meta?: { links?: Record<string, string> };
-  releases?: {
-    version: string;
-    inserted_at?: string;
-  }[];
-}