feat(schema): Add utility for detecting circular data (#35223)

Author: zharinov

lib/modules/manager/circleci/schema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { LooseArray } from '../../../util/schema-utils';
+import { LooseArray, NotCircular } from '../../../util/schema-utils';
 
 export const CircleCiDocker = z.object({
   image: z.string(),
@@ -26,10 +26,12 @@ export const CircleCiOrb: z.ZodType<Orb> = baseOrb.extend({
 });
 export type CircleCiOrb = z.infer<typeof CircleCiOrb>;
 
-export const CircleCiFile = z.object({
-  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(),
-});
+export const CircleCiFile = NotCircular.pipe(
+  z.object({
+    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(),
+  }),
+);
 export type CircleCiFile = z.infer<typeof CircleCiFile>;

lib/util/schema-utils.spec.ts

@@ -7,6 +7,7 @@ import {
   LooseArray,
   LooseRecord,
   MultidocYaml,
+  NotCircular,
   Toml,
   UtcDate,
   Yaml,
@@ -548,4 +549,152 @@ describe('util/schema-utils', () => {
       );
     });
   });
+
+  describe('NotCircular', () => {
+    it('allows non-circular primitive values', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      expect(Schema.parse(undefined)).toBeUndefined();
+      expect(Schema.parse(null)).toBeNull();
+      expect(Schema.parse(123)).toBe(123);
+      expect(Schema.parse('string')).toBe('string');
+      expect(Schema.parse(true)).toBe(true);
+    });
+
+    it('allows non-circular arrays', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      expect(Schema.parse([1, 2, 3])).toEqual([1, 2, 3]);
+      expect(Schema.parse([{ a: 1 }, { b: 2 }])).toEqual([{ a: 1 }, { b: 2 }]);
+      expect(
+        Schema.parse([
+          [1, 2],
+          [3, 4],
+        ]),
+      ).toEqual([
+        [1, 2],
+        [3, 4],
+      ]);
+    });
+
+    it('allows non-circular objects', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      expect(Schema.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+      expect(Schema.parse({ a: { b: 1 }, c: { d: 2 } })).toEqual({
+        a: { b: 1 },
+        c: { d: 2 },
+      });
+    });
+
+    it('allows objects reuse', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      const reused = { value: 42 };
+      const obj = {
+        foo: reused,
+        bar: reused,
+      };
+
+      expect(Schema.parse(obj)).toEqual({
+        foo: { value: 42 },
+        bar: { value: 42 },
+      });
+    });
+
+    it('rejects circular objects', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      const obj: any = { a: 1 };
+      obj.self = obj;
+
+      expect(Schema.safeParse(obj)).toMatchObject({
+        success: false,
+        error: {
+          issues: [
+            {
+              code: 'custom',
+              message: 'values cannot be circular data structures',
+              path: [],
+            },
+          ],
+        },
+      });
+    });
+
+    it('rejects circular arrays', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      const arr: any[] = [1, 2, 3];
+      arr.push(arr);
+
+      expect(Schema.safeParse(arr)).toMatchObject({
+        success: false,
+        error: {
+          issues: [
+            {
+              code: 'custom',
+              message: 'values cannot be circular data structures',
+              path: [],
+            },
+          ],
+        },
+      });
+    });
+
+    it('rejects deeply nested circular references', () => {
+      const Schema = NotCircular.pipe(z.any());
+
+      const obj: any = {
+        a: {
+          b: {
+            c: {
+              d: {},
+            },
+          },
+        },
+      };
+
+      obj.a.b.c.d.circular = obj.a;
+
+      expect(Schema.safeParse(obj)).toMatchObject({
+        success: false,
+        error: {
+          issues: [
+            {
+              code: 'custom',
+              message: 'values cannot be circular data structures',
+              path: [],
+            },
+          ],
+        },
+      });
+    });
+
+    it('can be combined with other schema types', () => {
+      const Schema = z.object({
+        data: NotCircular.pipe(z.any()),
+      });
+
+      expect(Schema.parse({ data: { a: 1, b: 2 } })).toEqual({
+        data: { a: 1, b: 2 },
+      });
+
+      const obj: any = { a: 1 };
+      obj.self = obj;
+
+      expect(Schema.safeParse({ data: obj })).toMatchObject({
+        success: false,
+        error: {
+          issues: [
+            {
+              code: 'custom',
+              message: 'values cannot be circular data structures',
+              path: ['data'],
+            },
+          ],
+        },
+      });
+    });
+  });
 });

lib/util/schema-utils.ts

@@ -318,3 +318,47 @@ export function withTraceMessage<Input, Output>(
     return value;
   };
 }
+
+function isCircular(value: unknown, visited = new Set<unknown>()): boolean {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+
+  if (visited.has(value)) {
+    return true;
+  }
+
+  const downstreamVisited = new Set(visited);
+  downstreamVisited.add(value);
+
+  if (Array.isArray(value)) {
+    for (const childValue of value) {
+      if (isCircular(childValue, downstreamVisited)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  const values = Object.values(value);
+  for (const ov of values) {
+    if (isCircular(ov, downstreamVisited)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export const NotCircular = z.unknown().superRefine((val, ctx) => {
+  if (isCircular(val)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: 'values cannot be circular data structures',
+      fatal: true,
+    });
+
+    return z.NEVER;
+  }
+});