refactor(circleci): Simplify CircleCI extraction

lib/modules/manager/circleci/extract.spec.ts

@@ -14,16 +14,20 @@ describe('modules/manager/circleci/extract', () => {
     });
 
     it('handles registry alias', () => {
-      const res = extractPackageFile(
-        'executors:\n  my-executor:\n    docker:\n      - image: quay.io/myName/myPackage:0.6.2',
-        '',
-        {
-          registryAliases: {
-            'quay.io': 'my-quay-mirror.registry.com',
-            'index.docker.io': 'my-docker-mirror.registry.com',
-          },
+      const src = codeBlock`
+        executors:
+          my-executor:
+            docker:
+              - image: quay.io/myName/myPackage:0.6.2
+      `;
+
+      const res = extractPackageFile(src, '.circleci/config.yml', {
+        registryAliases: {
+          'quay.io': 'my-quay-mirror.registry.com',
+          'index.docker.io': 'my-docker-mirror.registry.com',
         },
-      );
+      });
+
       expect(res).toEqual({
         deps: [
           {
@@ -222,10 +226,10 @@ describe('modules/manager/circleci/extract', () => {
     it('extracts and exclude android images', () => {
       expect(
         extractPackageFile(codeBlock`
-        jobs:
-          build:
-            machine:
-              image: android:202102-01
+          jobs:
+            build:
+              machine:
+                image: android:202102-01
         `),
       ).toBeNull();
     });
@@ -246,10 +250,12 @@ describe('modules/manager/circleci/extract', () => {
 
     it('extracts executors', () => {
       const res = extractPackageFile(codeBlock`
-      executors:
-        my-executor:
-          docker:
-            - image: cimg/ruby:3.0.3-browsers`);
+        executors:
+          my-executor:
+            docker:
+              - image: cimg/ruby:3.0.3-browsers
+      `);
+
       expect(res?.deps).toEqual([
         {
           autoReplaceStringTemplate:
@@ -266,29 +272,30 @@ describe('modules/manager/circleci/extract', () => {
 
     it('extracts orb definitions', () => {
       const res = extractPackageFile(codeBlock`
-      version: 2.1
+        version: 2.1
 
-      orbs:
-        myorb:
-          orbs:
-            python: circleci/[email protected]
+        orbs:
+          myorb:
+            orbs:
+              python: circleci/[email protected]
 
-          executors:
-            python:
-              docker:
-                - image: cimg/python:3.9
+            executors:
+              python:
+                docker:
+                  - image: cimg/python:3.9
 
-          jobs:
-            test_image:
-              docker:
-                - image: cimg/python:3.7
-              steps:
-                - checkout
+            jobs:
+              test_image:
+                docker:
+                  - image: cimg/python:3.7
+                steps:
+                  - checkout
 
-      workflows:
-        Test:
-          jobs:
-            - myorb/test_image`);
+        workflows:
+          Test:
+            jobs:
+              - myorb/test_image
+      `);
 
       expect(res).toEqual({
         deps: [

lib/modules/manager/circleci/extract.ts

@@ -1,5 +1,5 @@
 import { logger } from '../../../logger';
-import { coerceArray } from '../../../util/array';
+import { Result } from '../../../util/result';
 import { parseSingleYaml } from '../../../util/yaml';
 import { OrbDatasource } from '../../datasource/orb';
 import * as npmVersioning from '../../versioning/npm';
@@ -9,15 +9,14 @@ import type {
   PackageDependency,
   PackageFileContent,
 } from '../types';
-import { CircleCiFile, type CircleCiJob, type CircleCiOrb } from './schema';
+import { CircleCiFile, type CircleCiOrb } from './schema';
 
 function extractDefinition(
+  deps: PackageDependency[],
   definition: CircleCiOrb | CircleCiFile,
-  config?: ExtractConfig,
-): PackageDependency[] {
-  const deps: PackageDependency[] = [];
-
-  for (const [key, orb] of Object.entries(definition.orbs ?? {})) {
+  registryAliases: Record<string, string>,
+): void {
+  for (const [key, orb] of Object.entries(definition.orbs)) {
     if (typeof orb === 'string') {
       const [packageName, currentValue] = orb.split('@');
 
@@ -30,49 +29,48 @@ function extractDefinition(
         datasource: OrbDatasource.id,
       });
     } else {
-      deps.push(...extractDefinition(orb, config));
+      extractDefinition(deps, orb, registryAliases);
     }
   }
 
   // extract environments
-  const environments: CircleCiJob[] = [
-    Object.values(definition.executors ?? {}),
-    Object.values(definition.jobs ?? {}),
-  ].flat();
-  for (const job of environments) {
-    for (const dockerElement of coerceArray(job.docker)) {
-      deps.push({
-        ...getDep(dockerElement.image, true, config?.registryAliases),
-        depType: 'docker',
-      });
-    }
+  const environments = [...definition.executors, ...definition.jobs];
+  for (const dockerImage of environments) {
+    deps.push({
+      ...getDep(dockerImage, true, registryAliases),
+      depType: 'docker',
+    });
   }
-
-  return deps;
 }
 
 export function extractPackageFile(
   content: string,
   packageFile?: string,
   config?: ExtractConfig,
 ): PackageFileContent | null {
-  const deps: PackageDependency[] = [];
-  try {
-    const parsed = CircleCiFile.parse(parseSingleYaml(content));
+  const { val: parsed, err } = Result.wrap(() =>
+    CircleCiFile.parse(parseSingleYaml(content)),
+  ).unwrap();
 
-    deps.push(...extractDefinition(parsed, config));
-
-    for (const alias of parsed.aliases) {
-      deps.push({
-        ...getDep(alias.image, true, config?.registryAliases),
-        depType: 'docker',
-      });
-    }
-  } catch (err) /* istanbul ignore next */ {
+  if (err) {
     logger.debug({ err, packageFile }, 'Error extracting circleci images');
+    return null;
   }
+
+  const registryAliases = config?.registryAliases ?? {};
+  const deps: PackageDependency[] = [];
+  extractDefinition(deps, parsed, registryAliases);
+
+  for (const alias of parsed.aliases) {
+    deps.push({
+      ...getDep(alias, true, registryAliases),
+      depType: 'docker',
+    });
+  }
+
   if (!deps.length) {
     return null;
   }
+
   return { deps };
 }

lib/modules/manager/circleci/schema.ts

@@ -1,37 +1,43 @@
 import { z } from 'zod';
-import { LooseArray, NotCircular } from '../../../util/schema-utils';
+import {
+  LooseArray,
+  LooseRecord,
+  NotCircular,
+} from '../../../util/schema-utils';
 
-export const CircleCiDocker = z.object({
-  image: z.string(),
-});
+export const CircleCiDocker = z
+  .object({ image: z.string() })
+  .transform(({ image }) => image);
 
-export const CircleCiJob = z.object({
-  docker: z.array(CircleCiDocker).optional(),
-});
+export const CircleCiJob = z
+  .object({
+    docker: LooseArray(CircleCiDocker).catch([]),
+  })
+  .transform(({ docker }) => docker);
 export type CircleCiJob = z.infer<typeof CircleCiJob>;
 
-const baseOrb = z.object({
-  executors: z.record(z.string(), CircleCiJob).optional(),
-  jobs: z.record(z.string(), CircleCiJob).optional(),
+const CircleCiJobList = LooseRecord(CircleCiJob)
+  .transform((x) => Object.values(x).flat())
+  .catch([]);
+
+const BaseOrb = z.object({
+  executors: CircleCiJobList,
+  jobs: CircleCiJobList,
 });
 
-type Orb = z.infer<typeof baseOrb> & {
-  orbs?: Record<string, string | Orb>;
+type Orb = z.infer<typeof BaseOrb> & {
+  orbs: Record<string, string | Orb>;
 };
 
-export const CircleCiOrb: z.ZodType<Orb> = baseOrb.extend({
-  orbs: z.lazy(() =>
-    z.record(z.string(), z.union([z.string(), CircleCiOrb])).optional(),
-  ),
-});
+export const CircleCiOrb: z.ZodType<Orb> = BaseOrb.extend({
+  orbs: LooseRecord(z.union([z.string(), z.lazy(() => CircleCiOrb)])).catch({}),
+}) as never;
 export type CircleCiOrb = z.infer<typeof CircleCiOrb>;
 
 export const CircleCiFile = NotCircular.pipe(
-  z.object({
+  BaseOrb.extend({
     aliases: LooseArray(CircleCiDocker).catch([]),
-    executors: z.record(z.string(), CircleCiJob).optional(),
-    jobs: z.record(z.string(), CircleCiJob).optional(),
-    orbs: z.record(z.string(), z.union([z.string(), CircleCiOrb])).optional(),
+    orbs: LooseRecord(z.union([z.string(), CircleCiOrb])).catch({}),
   }),
 );
 export type CircleCiFile = z.infer<typeof CircleCiFile>;