pi-codex-auto-review 0.1.2 → 0.1.4

package/node_modules/zod/src/v4/classic/tests/record.test.ts

@@ -1,342 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("type inference", () => {
-  const booleanRecord = z.record(z.string(), z.boolean());
-  type booleanRecord = typeof booleanRecord._output;
-
-  const recordWithEnumKeys = z.record(z.enum(["Tuna", "Salmon"]), z.string());
-  type recordWithEnumKeys = z.infer<typeof recordWithEnumKeys>;
-
-  const recordWithLiteralKey = z.record(z.literal(["Tuna", "Salmon"]), z.string());
-  type recordWithLiteralKey = z.infer<typeof recordWithLiteralKey>;
-
-  const recordWithLiteralUnionKeys = z.record(z.union([z.literal("Tuna"), z.literal("Salmon")]), z.string());
-  type recordWithLiteralUnionKeys = z.infer<typeof recordWithLiteralUnionKeys>;
-
-  expectTypeOf<booleanRecord>().toEqualTypeOf<Record<string, boolean>>();
-  expectTypeOf<recordWithEnumKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
-  expectTypeOf<recordWithLiteralKey>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
-  expectTypeOf<recordWithLiteralUnionKeys>().toEqualTypeOf<Record<"Tuna" | "Salmon", string>>();
-});
-
-test("enum exhaustiveness", () => {
-  const schema = z.record(z.enum(["Tuna", "Salmon"]), z.string());
-  expect(
-    schema.parse({
-      Tuna: "asdf",
-      Salmon: "asdf",
-    })
-  ).toEqual({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "unrecognized_keys",
-        "keys": [
-          "Trout"
-        ],
-        "path": [],
-        "message": "Unrecognized key: \\"Trout\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "Salmon"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("literal exhaustiveness", () => {
-  const schema = z.record(z.literal(["Tuna", "Salmon"]), z.string());
-  schema.parse({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "unrecognized_keys",
-        "keys": [
-          "Trout"
-        ],
-        "path": [],
-        "message": "Unrecognized key: \\"Trout\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "Salmon"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("pipe exhaustiveness", () => {
-  const schema = z.record(z.enum(["Tuna", "Salmon"]).pipe(z.any()), z.string());
-  expect(schema.parse({ Tuna: "asdf", Salmon: "asdf" })).toEqual({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "unrecognized_keys",
-        "keys": [
-          "Trout"
-        ],
-        "path": [],
-        "message": "Unrecognized key: \\"Trout\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "Salmon"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("union exhaustiveness", () => {
-  const schema = z.record(z.union([z.literal("Tuna"), z.literal("Salmon")]), z.string());
-  expect(schema.parse({ Tuna: "asdf", Salmon: "asdf" })).toEqual({
-    Tuna: "asdf",
-    Salmon: "asdf",
-  });
-
-  expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "unrecognized_keys",
-        "keys": [
-          "Trout"
-        ],
-        "path": [],
-        "message": "Unrecognized key: \\"Trout\\""
-      }
-    ]],
-      "success": false,
-    }
-  `);
-  expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "Salmon"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("string record parse - pass", () => {
-  const schema = z.record(z.string(), z.boolean());
-  schema.parse({
-    k1: true,
-    k2: false,
-    1234: false,
-  });
-
-  expect(schema.safeParse({ asdf: 1234 }).success).toEqual(false);
-  expect(schema.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "record",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected record, received string"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("key and value getters", () => {
-  const rec = z.record(z.string(), z.number());
-
-  rec.keyType.parse("asdf");
-  rec.valueType.parse(1234);
-});
-
-test("is not vulnerable to prototype pollution", async () => {
-  const rec = z.record(
-    z.string(),
-    z.object({
-      a: z.string(),
-    })
-  );
-
-  const data = JSON.parse(`
-    {
-      "__proto__": {
-        "a": "evil"
-      },
-      "b": {
-        "a": "good"
-      }
-    }
-  `);
-
-  const obj1 = rec.parse(data);
-  expect(obj1.a).toBeUndefined();
-
-  const obj2 = rec.safeParse(data);
-  expect(obj2.success).toBe(true);
-  if (obj2.success) {
-    expect(obj2.data.a).toBeUndefined();
-  }
-
-  const obj3 = await rec.parseAsync(data);
-  expect(obj3.a).toBeUndefined();
-
-  const obj4 = await rec.safeParseAsync(data);
-  expect(obj4.success).toBe(true);
-  if (obj4.success) {
-    expect(obj4.data.a).toBeUndefined();
-  }
-});
-
-test("dont remove undefined values", () => {
-  const result1 = z.record(z.string(), z.any()).parse({ foo: undefined });
-
-  expect(result1).toEqual({
-    foo: undefined,
-  });
-});
-
-test("allow undefined values", () => {
-  const schema = z.record(z.string(), z.undefined());
-
-  expect(
-    Object.keys(
-      schema.parse({
-        _test: undefined,
-      })
-    )
-  ).toEqual(["_test"]);
-});
-
-test("async parsing", async () => {
-  const schema = z
-    .record(
-      z.string(),
-      z
-        .string()
-        .optional()
-        .refine(async () => true)
-    )
-    .refine(async () => true);
-
-  const data = {
-    foo: "bar",
-    baz: "qux",
-  };
-  const result = await schema.safeParseAsync(data);
-  expect(result.data).toEqual(data);
-});
-
-test("async parsing", async () => {
-  const schema = z
-    .record(
-      z.string(),
-      z
-        .string()
-        .optional()
-        .refine(async () => false)
-    )
-    .refine(async () => false);
-
-  const data = {
-    foo: "bar",
-    baz: "qux",
-  };
-  const result = await schema.safeParseAsync(data);
-  expect(result.success).toEqual(false);
-  expect(result.error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "foo"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [
-          "baz"
-        ],
-        "message": "Invalid input"
-      },
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-});
-
-test("partial record", () => {
-  const schema = z.partialRecord(z.string(), z.string());
-  type schema = z.infer<typeof schema>;
-  expectTypeOf<schema>().toEqualTypeOf<Partial<Record<string, string>>>();
-
-  const Keys = z.enum(["id", "name", "email"]).or(z.never());
-  const Person = z.partialRecord(Keys, z.string());
-  expectTypeOf<z.infer<typeof Person>>().toEqualTypeOf<Partial<Record<"id" | "name" | "email", string>>>();
-});

package/node_modules/zod/src/v4/classic/tests/recursive-types.test.ts

@@ -1,356 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("recursion with z.lazy", () => {
-  const data = {
-    name: "I",
-    subcategories: [
-      {
-        name: "A",
-        subcategories: [
-          {
-            name: "1",
-            subcategories: [
-              {
-                name: "a",
-                subcategories: [],
-              },
-            ],
-          },
-        ],
-      },
-    ],
-  };
-
-  const Category = z.object({
-    name: z.string(),
-    get subcategories() {
-      return z.array(Category).optional().nullable();
-    },
-  });
-  type Category = z.infer<typeof Category>;
-  interface _Category {
-    name: string;
-    subcategories?: _Category[] | undefined | null;
-  }
-  expectTypeOf<Category>().toEqualTypeOf<_Category>();
-  Category.parse(data);
-});
-
-test("recursion involving union type", () => {
-  const data = {
-    value: 1,
-    next: {
-      value: 2,
-      next: {
-        value: 3,
-        next: {
-          value: 4,
-          next: null,
-        },
-      },
-    },
-  };
-
-  const LL = z.object({
-    value: z.number(),
-    get next() {
-      return LL.nullable();
-    },
-  });
-  type LL = z.infer<typeof LL>;
-  type _LL = {
-    value: number;
-    next: _LL | null;
-  };
-  expectTypeOf<LL>().toEqualTypeOf<_LL>();
-
-  LL.parse(data);
-});
-
-test("mutual recursion - native", () => {
-  const Alazy = z.object({
-    val: z.number(),
-    get b() {
-      return Blazy;
-    },
-  });
-
-  const Blazy = z.object({
-    val: z.number(),
-    get a() {
-      return Alazy.optional();
-    },
-  });
-  const testData = {
-    val: 1,
-    b: {
-      val: 5,
-      a: {
-        val: 3,
-        b: {
-          val: 4,
-          a: {
-            val: 2,
-            b: {
-              val: 1,
-            },
-          },
-        },
-      },
-    },
-  };
-
-  type Alazy = z.infer<typeof Alazy>;
-  type Blazy = z.infer<typeof Blazy>;
-  interface _Alazy {
-    val: number;
-    b: _Blazy;
-  }
-  interface _Blazy {
-    val: number;
-    a?: _Alazy | undefined;
-  }
-  expectTypeOf<Alazy>().toEqualTypeOf<_Alazy>();
-  expectTypeOf<Blazy>().toEqualTypeOf<_Blazy>();
-  Alazy.parse(testData);
-  Blazy.parse(testData.b);
-
-  expect(() => Alazy.parse({ val: "asdf" })).toThrow();
-});
-
-test("pick and omit with getter", () => {
-  const Category = z.strictObject({
-    name: z.string(),
-    get subcategories() {
-      return z.array(Category);
-    },
-  });
-
-  type Category = z.infer<typeof Category>;
-
-  interface _Category {
-    name: string;
-    subcategories: _Category[];
-  }
-  expectTypeOf<Category>().toEqualTypeOf<_Category>();
-
-  const PickedCategory = Category.pick({ name: true });
-  const OmittedCategory = Category.omit({ subcategories: true });
-
-  const picked = { name: "test" };
-  const omitted = { name: "test" };
-
-  PickedCategory.parse(picked);
-  OmittedCategory.parse(omitted);
-
-  expect(() => PickedCategory.parse({ name: "test", subcategories: [] })).toThrow();
-  expect(() => OmittedCategory.parse({ name: "test", subcategories: [] })).toThrow();
-});
-
-test("deferred self-recursion", () => {
-  const Feature = z.object({
-    title: z.string(),
-    get features(): z.ZodOptional<z.ZodArray<typeof Feature>> {
-      return z.optional(z.array(Feature)); //.optional();
-    },
-  });
-  // type Feature = z.infer<typeof Feature>;
-
-  const Output = z.object({
-    id: z.int(), //.nonnegative(),
-    name: z.string(),
-    get features(): z.ZodArray<typeof Feature> {
-      return Feature.array();
-    },
-  });
-  type Output = z.output<typeof Output>;
-
-  type _Feature = {
-    title: string;
-    features?: _Feature[] | undefined;
-  };
-
-  type _Output = {
-    id: number;
-    name: string;
-    features: _Feature[];
-  };
-
-  // expectTypeOf<Feature>().toEqualTypeOf<_Feature>();
-  expectTypeOf<Output>().toEqualTypeOf<_Output>();
-});
-
-test("deferred mutual recursion", () => {
-  const Slot = z.object({
-    slotCode: z.string(),
-
-    get blocks() {
-      return z.array(Block);
-    },
-  });
-  type Slot = z.infer<typeof Slot>;
-
-  const Block = z.object({
-    blockCode: z.string(),
-    get slots() {
-      return z.array(Slot).optional();
-    },
-  });
-  type Block = z.infer<typeof Block>;
-
-  const Page = z.object({
-    slots: z.array(Slot),
-  });
-  type Page = z.infer<typeof Page>;
-
-  type _Slot = {
-    slotCode: string;
-    blocks: _Block[];
-  };
-  type _Block = {
-    blockCode: string;
-    slots?: _Slot[] | undefined;
-  };
-  type _Page = {
-    slots: _Slot[];
-  };
-  expectTypeOf<Slot>().toEqualTypeOf<_Slot>();
-  expectTypeOf<Block>().toEqualTypeOf<_Block>();
-  expectTypeOf<Page>().toEqualTypeOf<_Page>();
-});
-
-test("mutual recursion with meta", () => {
-  const A = z
-    .object({
-      name: z.string(),
-      get b() {
-        return B;
-      },
-    })
-    .readonly()
-    .meta({ id: "A" })
-    .optional();
-
-  const B = z
-    .object({
-      name: z.string(),
-      get a() {
-        return A;
-      },
-    })
-    .readonly()
-    .meta({ id: "B" });
-
-  type A = z.infer<typeof A>;
-  type B = z.infer<typeof B>;
-
-  type _A =
-    | Readonly<{
-        name: string;
-        b: _B;
-      }>
-    | undefined;
-  // | undefined;
-  type _B = Readonly<{
-    name: string;
-    a?: _A;
-  }>;
-  expectTypeOf<A>().toEqualTypeOf<_A>();
-  expectTypeOf<B>().toEqualTypeOf<_B>();
-});
-
-test("recursion compatibility", () => {
-  // array
-  const A = z.object({
-    get array() {
-      return A.array();
-    },
-    get optional() {
-      return A.optional();
-    },
-    get nullable() {
-      return A.nullable();
-    },
-    get nonoptional() {
-      return A.nonoptional();
-    },
-    get readonly() {
-      return A.readonly();
-    },
-    get describe() {
-      return A.describe("A recursive type");
-    },
-    get meta() {
-      return A.meta({ description: "A recursive type" });
-    },
-    get pipe() {
-      return A.pipe(z.any());
-    },
-    get strict() {
-      return A.strict();
-    },
-    get tuple() {
-      return z.tuple([A, A]);
-    },
-    get object() {
-      return z
-        .object({
-          subcategories: A,
-        })
-        .strict()
-        .loose();
-    },
-    get union() {
-      return z.union([A, A]);
-    },
-    get intersection() {
-      return z.intersection(A, A);
-    },
-    get record() {
-      return z.record(z.string(), A);
-    },
-    get map() {
-      return z.map(z.string(), A);
-    },
-    get set() {
-      return z.set(A);
-    },
-    get lazy() {
-      return z.lazy(() => A);
-    },
-    get promise() {
-      return z.promise(A);
-    },
-  });
-});
-
-// biome-ignore lint: sadf
-export type RecursiveA = z.ZodUnion<
-  [
-    z.ZodObject<{
-      a: z.ZodDefault<RecursiveA>;
-      b: z.ZodPrefault<RecursiveA>;
-      c: z.ZodNonOptional<RecursiveA>;
-      d: z.ZodOptional<RecursiveA>;
-      e: z.ZodNullable<RecursiveA>;
-      g: z.ZodReadonly<RecursiveA>;
-      h: z.ZodPipe<RecursiveA, z.ZodString>;
-      i: z.ZodArray<RecursiveA>;
-      j: z.ZodSet<RecursiveA>;
-      k: z.ZodMap<RecursiveA, RecursiveA>;
-      l: z.ZodRecord<z.ZodString, RecursiveA>;
-      m: z.ZodUnion<[RecursiveA, RecursiveA]>;
-      n: z.ZodIntersection<RecursiveA, RecursiveA>;
-      o: z.ZodLazy<RecursiveA>;
-      p: z.ZodPromise<RecursiveA>;
-      q: z.ZodCatch<RecursiveA>;
-      r: z.ZodSuccess<RecursiveA>;
-      s: z.ZodTransform<RecursiveA, string>;
-      t: z.ZodTuple<[RecursiveA, RecursiveA]>;
-      u: z.ZodObject<{
-        a: RecursiveA;
-      }>;
-    }>,
-  ]
->;