makecoder 1.0.25

package/dist/zod/src/v3/tests/parseUtil.test.ts

@@ -0,0 +1,23 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import { type SyncParseReturnType, isAborted, isDirty, isValid } from "../helpers/parseUtil.js";
+
+test("parseUtil isInvalid should use structural typing", () => {
+  // Test for issue #556: https://github.com/colinhacks/zod/issues/556
+  const aborted: SyncParseReturnType = { status: "aborted" };
+  const dirty: SyncParseReturnType = { status: "dirty", value: "whatever" };
+  const valid: SyncParseReturnType = { status: "valid", value: "whatever" };
+
+  expect(isAborted(aborted)).toBe(true);
+  expect(isAborted(dirty)).toBe(false);
+  expect(isAborted(valid)).toBe(false);
+
+  expect(isDirty(aborted)).toBe(false);
+  expect(isDirty(dirty)).toBe(true);
+  expect(isDirty(valid)).toBe(false);
+
+  expect(isValid(aborted)).toBe(false);
+  expect(isValid(dirty)).toBe(false);
+  expect(isValid(valid)).toBe(true);
+});

package/dist/zod/src/v3/tests/parser.test.ts

@@ -0,0 +1,41 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("parse strict object with unknown keys", () => {
+  expect(() =>
+    z
+      .object({ name: z.string() })
+      .strict()
+      .parse({ name: "bill", unknownKey: 12 } as any)
+  ).toThrow();
+});
+
+test("parse nonstrict object with unknown keys", () => {
+  z.object({ name: z.string() }).nonstrict().parse({ name: "bill", unknownKey: 12 });
+});
+
+test("invalid left side of intersection", () => {
+  expect(() => z.intersection(z.string(), z.number()).parse(12 as any)).toThrow();
+});
+
+test("invalid right side of intersection", () => {
+  expect(() => z.intersection(z.string(), z.number()).parse("12" as any)).toThrow();
+});
+
+test("parsing non-array in tuple schema", () => {
+  expect(() => z.tuple([]).parse("12" as any)).toThrow();
+});
+
+test("incorrect num elements in tuple", () => {
+  expect(() => z.tuple([]).parse(["asdf"] as any)).toThrow();
+});
+
+test("invalid enum value", () => {
+  expect(() => z.enum(["Blue"]).parse("Red" as any)).toThrow();
+});
+
+test("parsing unknown", () => {
+  z.string().parse("Red" as unknown);
+});

package/dist/zod/src/v3/tests/partials.test.ts

@@ -0,0 +1,243 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { ZodNullable, ZodOptional } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const nested = z.object({
+  name: z.string(),
+  age: z.number(),
+  outer: z.object({
+    inner: z.string(),
+  }),
+  array: z.array(z.object({ asdf: z.string() })),
+});
+
+test("shallow inference", () => {
+  const shallow = nested.partial();
+  type shallow = z.infer<typeof shallow>;
+  type correct = {
+    name?: string | undefined;
+    age?: number | undefined;
+    outer?: { inner: string } | undefined;
+    array?: { asdf: string }[];
+  };
+  util.assertEqual<shallow, correct>(true);
+});
+
+test("shallow partial parse", () => {
+  const shallow = nested.partial();
+  shallow.parse({});
+  shallow.parse({
+    name: "asdf",
+    age: 23143,
+  });
+});
+
+test("deep partial inference", () => {
+  const deep = nested.deepPartial();
+  const asdf = deep.shape.array.unwrap().element.shape.asdf.unwrap();
+  asdf.parse("asdf");
+  type deep = z.infer<typeof deep>;
+  type correct = {
+    array?: { asdf?: string }[];
+    name?: string | undefined;
+    age?: number | undefined;
+    outer?: { inner?: string | undefined } | undefined;
+  };
+
+  util.assertEqual<deep, correct>(true);
+});
+
+test("deep partial parse", () => {
+  const deep = nested.deepPartial();
+
+  expect(deep.shape.name instanceof z.ZodOptional).toBe(true);
+  expect(deep.shape.outer instanceof z.ZodOptional).toBe(true);
+  expect(deep.shape.outer._def.innerType instanceof z.ZodObject).toBe(true);
+  expect(deep.shape.outer._def.innerType.shape.inner instanceof z.ZodOptional).toBe(true);
+  expect(deep.shape.outer._def.innerType.shape.inner._def.innerType instanceof z.ZodString).toBe(true);
+});
+
+test("deep partial runtime tests", () => {
+  const deep = nested.deepPartial();
+  deep.parse({});
+  deep.parse({
+    outer: {},
+  });
+  deep.parse({
+    name: "asdf",
+    age: 23143,
+    outer: {
+      inner: "adsf",
+    },
+  });
+});
+
+test("deep partial optional/nullable", () => {
+  const schema = z
+    .object({
+      name: z.string().optional(),
+      age: z.number().nullable(),
+    })
+    .deepPartial();
+
+  expect(schema.shape.name.unwrap()).toBeInstanceOf(ZodOptional);
+  expect(schema.shape.age.unwrap()).toBeInstanceOf(ZodNullable);
+});
+
+test("deep partial tuple", () => {
+  const schema = z
+    .object({
+      tuple: z.tuple([
+        z.object({
+          name: z.string().optional(),
+          age: z.number().nullable(),
+        }),
+      ]),
+    })
+    .deepPartial();
+
+  expect(schema.shape.tuple.unwrap().items[0].shape.name).toBeInstanceOf(ZodOptional);
+});
+
+test("deep partial inference", () => {
+  const mySchema = z.object({
+    name: z.string(),
+    array: z.array(z.object({ asdf: z.string() })),
+    tuple: z.tuple([z.object({ value: z.string() })]),
+  });
+
+  const partialed = mySchema.deepPartial();
+  type partialed = z.infer<typeof partialed>;
+  type expected = {
+    name?: string | undefined;
+    array?:
+      | {
+          asdf?: string | undefined;
+        }[]
+      | undefined;
+    tuple?: [{ value?: string }] | undefined;
+  };
+  util.assertEqual<expected, partialed>(true);
+});
+
+test("required", () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    nullableField: z.number().nullable(),
+    nullishField: z.string().nullish(),
+  });
+
+  const requiredObject = object.required();
+  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+  expect(requiredObject.shape.nullableField).toBeInstanceOf(z.ZodNullable);
+  expect(requiredObject.shape.nullishField).toBeInstanceOf(z.ZodNullable);
+});
+
+test("required inference", () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    nullableField: z.number().nullable(),
+    nullishField: z.string().nullish(),
+  });
+
+  const requiredObject = object.required();
+
+  type required = z.infer<typeof requiredObject>;
+  type expected = {
+    name: string;
+    age: number;
+    field: string;
+    nullableField: number | null;
+    nullishField: string | null;
+  };
+  util.assertEqual<expected, required>(true);
+});
+
+test("required with mask", () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    country: z.string().optional(),
+  });
+
+  const requiredObject = object.required({ age: true });
+  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
+});
+
+test("required with mask -- ignore falsy values", () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    country: z.string().optional(),
+  });
+
+  // @ts-expect-error
+  const requiredObject = object.required({ age: true, country: false });
+  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
+  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
+  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
+  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
+});
+
+test("partial with mask", async () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    country: z.string(),
+  });
+
+  const masked = object.partial({ age: true, field: true, name: true }).strict();
+
+  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
+  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
+  expect(masked.shape.field).toBeInstanceOf(z.ZodOptional);
+  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
+
+  masked.parse({ country: "US" });
+  await masked.parseAsync({ country: "US" });
+});
+
+test("partial with mask -- ignore falsy values", async () => {
+  const object = z.object({
+    name: z.string(),
+    age: z.number().optional(),
+    field: z.string().optional().default("asdf"),
+    country: z.string(),
+  });
+
+  // @ts-expect-error
+  const masked = object.partial({ name: true, country: false }).strict();
+
+  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
+  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
+  expect(masked.shape.field).toBeInstanceOf(z.ZodDefault);
+  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
+
+  masked.parse({ country: "US" });
+  await masked.parseAsync({ country: "US" });
+});
+
+test("deeppartial array", () => {
+  const schema = z.object({ array: z.string().array().min(42) }).deepPartial();
+
+  // works as expected
+  schema.parse({});
+
+  // should be false, but is true
+  expect(schema.safeParse({ array: [] }).success).toBe(false);
+});

package/dist/zod/src/v3/tests/pickomit.test.ts

@@ -0,0 +1,111 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const fish = z.object({
+  name: z.string(),
+  age: z.number(),
+  nested: z.object({}),
+});
+
+test("pick type inference", () => {
+  const nameonlyFish = fish.pick({ name: true });
+  type nameonlyFish = z.infer<typeof nameonlyFish>;
+  util.assertEqual<nameonlyFish, { name: string }>(true);
+});
+
+test("pick parse - success", () => {
+  const nameonlyFish = fish.pick({ name: true });
+  nameonlyFish.parse({ name: "bob" });
+
+  // @ts-expect-error checking runtime picks `name` only.
+  const anotherNameonlyFish = fish.pick({ name: true, age: false });
+  anotherNameonlyFish.parse({ name: "bob" });
+});
+
+test("pick parse - fail", () => {
+  fish.pick({ name: true }).parse({ name: "12" } as any);
+  fish.pick({ name: true }).parse({ name: "bob", age: 12 } as any);
+  fish.pick({ age: true }).parse({ age: 12 } as any);
+
+  const nameonlyFish = fish.pick({ name: true }).strict();
+  const bad1 = () => nameonlyFish.parse({ name: 12 } as any);
+  const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 } as any);
+  const bad3 = () => nameonlyFish.parse({ age: 12 } as any);
+
+  // @ts-expect-error checking runtime picks `name` only.
+  const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
+  const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 } as any);
+
+  expect(bad1).toThrow();
+  expect(bad2).toThrow();
+  expect(bad3).toThrow();
+  expect(bad4).toThrow();
+});
+
+test("omit type inference", () => {
+  const nonameFish = fish.omit({ name: true });
+  type nonameFish = z.infer<typeof nonameFish>;
+  util.assertEqual<nonameFish, { age: number; nested: {} }>(true);
+});
+
+test("omit parse - success", () => {
+  const nonameFish = fish.omit({ name: true });
+  nonameFish.parse({ age: 12, nested: {} });
+
+  // @ts-expect-error checking runtime omits `name` only.
+  const anotherNonameFish = fish.omit({ name: true, age: false });
+  anotherNonameFish.parse({ age: 12, nested: {} });
+});
+
+test("omit parse - fail", () => {
+  const nonameFish = fish.omit({ name: true });
+  const bad1 = () => nonameFish.parse({ name: 12 } as any);
+  const bad2 = () => nonameFish.parse({ age: 12 } as any);
+  const bad3 = () => nonameFish.parse({} as any);
+
+  // @ts-expect-error checking runtime omits `name` only.
+  const anotherNonameFish = fish.omit({ name: true, age: false });
+  const bad4 = () => anotherNonameFish.parse({ nested: {} } as any);
+
+  expect(bad1).toThrow();
+  expect(bad2).toThrow();
+  expect(bad3).toThrow();
+  expect(bad4).toThrow();
+});
+
+test("nonstrict inference", () => {
+  const laxfish = fish.pick({ name: true }).catchall(z.any());
+  type laxfish = z.infer<typeof laxfish>;
+  util.assertEqual<laxfish, { name: string } & { [k: string]: any }>(true);
+});
+
+test("nonstrict parsing - pass", () => {
+  const laxfish = fish.passthrough().pick({ name: true });
+  laxfish.parse({ name: "asdf", whatever: "asdf" });
+  laxfish.parse({ name: "asdf", age: 12, nested: {} });
+});
+
+test("nonstrict parsing - fail", () => {
+  const laxfish = fish.passthrough().pick({ name: true });
+  const bad = () => laxfish.parse({ whatever: "asdf" } as any);
+  expect(bad).toThrow();
+});
+
+test("pick/omit/required/partial - do not allow unknown keys", () => {
+  const schema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  // @ts-expect-error
+  schema.pick({ $unknown: true });
+  // @ts-expect-error
+  schema.omit({ $unknown: true });
+  // @ts-expect-error
+  schema.required({ $unknown: true });
+  // @ts-expect-error
+  schema.partial({ $unknown: true });
+});

package/dist/zod/src/v3/tests/pipeline.test.ts

@@ -0,0 +1,29 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("string to number pipeline", () => {
+  const schema = z.string().transform(Number).pipe(z.number());
+  expect(schema.parse("1234")).toEqual(1234);
+});
+
+test("string to number pipeline async", async () => {
+  const schema = z
+    .string()
+    .transform(async (val) => Number(val))
+    .pipe(z.number());
+  expect(await schema.parseAsync("1234")).toEqual(1234);
+});
+
+test("break if dirty", () => {
+  const schema = z
+    .string()
+    .refine((c) => c === "1234")
+    .transform(async (val) => Number(val))
+    .pipe(z.number().refine((v) => v < 100));
+  const r1: any = schema.safeParse("12345");
+  expect(r1.error.issues.length).toBe(1);
+  const r2: any = schema.safeParse("3");
+  expect(r2.error.issues.length).toBe(1);
+});

package/dist/zod/src/v3/tests/preprocess.test.ts

@@ -0,0 +1,186 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("preprocess", () => {
+  const schema = z.preprocess((data) => [data], z.string().array());
+
+  const value = schema.parse("asdf");
+  expect(value).toEqual(["asdf"]);
+  util.assertEqual<(typeof schema)["_input"], unknown>(true);
+});
+
+test("async preprocess", async () => {
+  const schema = z.preprocess(async (data) => [data], z.string().array());
+
+  const value = await schema.parseAsync("asdf");
+  expect(value).toEqual(["asdf"]);
+});
+
+test("preprocess ctx.addIssue with parse", () => {
+  expect(() => {
+    z.preprocess((data, ctx) => {
+      ctx.addIssue({
+        code: "custom",
+        message: `${data} is not one of our allowed strings`,
+      });
+      return data;
+    }, z.string()).parse("asdf");
+  }).toThrow(
+    JSON.stringify(
+      [
+        {
+          code: "custom",
+          message: "asdf is not one of our allowed strings",
+          path: [],
+        },
+      ],
+      null,
+      2
+    )
+  );
+});
+
+test("preprocess ctx.addIssue non-fatal by default", () => {
+  try {
+    z.preprocess((data, ctx) => {
+      ctx.addIssue({
+        code: "custom",
+        message: `custom error`,
+      });
+      return data;
+    }, z.string()).parse(1234);
+  } catch (err) {
+    z.ZodError.assert(err);
+    expect(err.issues.length).toEqual(2);
+  }
+});
+
+test("preprocess ctx.addIssue fatal true", () => {
+  try {
+    z.preprocess((data, ctx) => {
+      ctx.addIssue({
+        code: "custom",
+        message: `custom error`,
+        fatal: true,
+      });
+      return data;
+    }, z.string()).parse(1234);
+  } catch (err) {
+    z.ZodError.assert(err);
+    expect(err.issues.length).toEqual(1);
+  }
+});
+
+test("async preprocess ctx.addIssue with parse", async () => {
+  const schema = z.preprocess(async (data, ctx) => {
+    ctx.addIssue({
+      code: "custom",
+      message: `custom error`,
+    });
+    return data;
+  }, z.string());
+
+  expect(await schema.safeParseAsync("asdf")).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("preprocess ctx.addIssue with parseAsync", async () => {
+  const result = await z
+    .preprocess(async (data, ctx) => {
+      ctx.addIssue({
+        code: "custom",
+        message: `${data} is not one of our allowed strings`,
+      });
+      return data;
+    }, z.string())
+    .safeParseAsync("asdf");
+
+  expect(JSON.parse(JSON.stringify(result))).toEqual({
+    success: false,
+    error: {
+      issues: [
+        {
+          code: "custom",
+          message: "asdf is not one of our allowed strings",
+          path: [],
+        },
+      ],
+      name: "ZodError",
+    },
+  });
+});
+
+test("z.NEVER in preprocess", () => {
+  const foo = z.preprocess((val, ctx) => {
+    if (!val) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "bad" });
+      return z.NEVER;
+    }
+    return val;
+  }, z.number());
+
+  type foo = z.infer<typeof foo>;
+  util.assertEqual<foo, number>(true);
+  const arg = foo.safeParse(undefined);
+  expect(arg.error!.issues).toHaveLength(2);
+  expect(arg.error!.issues[0].message).toEqual("bad");
+});
+test("preprocess as the second property of object", () => {
+  const schema = z.object({
+    nonEmptyStr: z.string().min(1),
+    positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
+  });
+  const result = schema.safeParse({
+    nonEmptyStr: "",
+    positiveNum: "",
+  });
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.too_small);
+    expect(result.error.issues[1].code).toEqual(z.ZodIssueCode.too_small);
+  }
+});
+
+test("preprocess validates with sibling errors", () => {
+  expect(() => {
+    z.object({
+      // Must be first
+      missing: z.string().refine(() => false),
+      preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
+    }).parse({ preprocess: " asdf" });
+  }).toThrow(
+    JSON.stringify(
+      [
+        {
+          code: "invalid_type",
+          expected: "string",
+          received: "undefined",
+          path: ["missing"],
+          message: "Required",
+        },
+        {
+          validation: "regex",
+          code: "invalid_string",
+          message: "Invalid",
+          path: ["preprocess"],
+        },
+      ],
+      null,
+      2
+    )
+  );
+});