fullstacked 0.12.1-1371 → 0.12.2-1382

package/fullstacked_modules/zod/src/v4/classic/tests/prefault.test.ts

@@ -1,74 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import { z } from "zod/v4";
-
-test("basic prefault", () => {
-  const a = z.prefault(z.string().trim(), "  default  ");
-  expect(a).toBeInstanceOf(z.ZodPrefault);
-  expect(a.parse("  asdf  ")).toEqual("asdf");
-  expect(a.parse(undefined)).toEqual("default");
-
-  type inp = z.input<typeof a>;
-  expectTypeOf<inp>().toEqualTypeOf<string | undefined>();
-  type out = z.output<typeof a>;
-  expectTypeOf<out>().toEqualTypeOf<string>();
-});
-
-test("prefault inside object", () => {
-  // test optinality
-  const a = z.object({
-    name: z.string().optional(),
-    age: z.number().default(1234),
-    email: z.string().prefault("1234"),
-  });
-
-  type inp = z.input<typeof a>;
-  expectTypeOf<inp>().toEqualTypeOf<{
-    name?: string | undefined;
-    age?: number | undefined;
-    email?: string | undefined;
-  }>();
-
-  type out = z.output<typeof a>;
-  expectTypeOf<out>().toEqualTypeOf<{
-    name?: string | undefined;
-    age: number;
-    email: string;
-  }>();
-});
-
-test("object schema with prefault should return shallow clone", () => {
-  const schema = z
-    .object({
-      a: z.string(),
-    })
-    .default({ a: "x" });
-  const result1 = schema.parse(undefined);
-  const result2 = schema.parse(undefined);
-  expect(result1).not.toBe(result2);
-  expect(result1).toEqual(result2);
-});
-
-test("direction-aware prefault", () => {
-  const schema = z.string().prefault("hello");
-
-  // Forward direction (regular parse): prefault should be applied
-  expect(schema.parse(undefined)).toBe("hello");
-
-  // Reverse direction (encode): prefault should NOT be applied, undefined should fail validation
-  expect(z.safeEncode(schema, undefined as any)).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected string, received undefined"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  // But valid values should still work in reverse
-  expect(z.encode(schema, "world")).toBe("world");
-});

package/fullstacked_modules/zod/src/v4/classic/tests/preprocess.test.ts

@@ -1,282 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("preprocess", () => {
-  const schema = z.preprocess((data) => [data], z.string().array());
-  const value = schema.parse("asdf");
-  expect(value).toEqual(["asdf"]);
-  expectTypeOf<(typeof schema)["_input"]>().toEqualTypeOf<unknown>();
-});
-
-test("async preprocess", async () => {
-  const schema = z.preprocess(async (data) => {
-    return [data];
-  }, z.string().array());
-  const value = await schema.safeParseAsync("asdf");
-  expect(value.data).toEqual(["asdf"]);
-  expect(value).toMatchInlineSnapshot(`
-    {
-      "data": [
-        "asdf",
-      ],
-      "success": true,
-    }
-  `);
-});
-
-test("ctx.addIssue accepts string", () => {
-  const schema = z.preprocess((_, ctx) => {
-    ctx.addIssue("bad stuff");
-  }, z.string());
-  const result = schema.safeParse("asdf");
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "message": "bad stuff",
-        "code": "custom",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue with parse", () => {
-  const a = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      message: `${data} is not one of our allowed strings`,
-    });
-    return data;
-  }, z.string());
-
-  const result = a.safeParse("asdf");
-
-  // expect(result.error!.toJSON()).toContain("not one of our allowed strings");
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue fatal by default", () => {
-  const schema = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      code: "custom",
-      message: `custom error`,
-    });
-
-    return data;
-  }, z.string());
-  const result = schema.safeParse(1234);
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue fatal true", () => {
-  const schema = z.preprocess((data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      origin: "custom",
-      message: `custom error`,
-      fatal: true,
-    });
-    return data;
-  }, z.string());
-
-  const result = schema.safeParse(1234);
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "origin": "custom",
-        "message": "custom error",
-        "fatal": true,
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("async preprocess ctx.addIssue with parseAsync", async () => {
-  const schema = z.preprocess(async (data, ctx) => {
-    ctx.addIssue({
-      input: data,
-      code: "custom",
-      message: `${data} is not one of our allowed strings`,
-    });
-    return data;
-  }, z.string());
-
-  const result = await schema.safeParseAsync("asdf");
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "asdf is not one of our allowed strings",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("z.NEVER in preprocess", () => {
-  const foo = z.preprocess((val, ctx) => {
-    if (!val) {
-      ctx.addIssue({ input: val, code: "custom", message: "bad" });
-      return z.NEVER;
-    }
-    return val;
-  }, z.number());
-
-  type foo = z.infer<typeof foo>;
-  expectTypeOf<foo>().toEqualTypeOf<number>();
-  const result = foo.safeParse(undefined);
-
-  expect(result.error!.issues).toHaveLength(1);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "bad",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-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.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "origin": "string",
-        "code": "too_small",
-        "minimum": 1,
-        "inclusive": true,
-        "path": [
-          "nonEmptyStr"
-        ],
-        "message": "Too small: expected string to have >=1 characters"
-      },
-      {
-        "origin": "number",
-        "code": "too_small",
-        "minimum": 0,
-        "inclusive": false,
-        "path": [
-          "positiveNum"
-        ],
-        "message": "Too small: expected number to be >0"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess validates with sibling errors", () => {
-  const schema = z.object({
-    missing: z.string().refine(() => false),
-    preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
-  });
-
-  const result = schema.safeParse({ preprocess: " asdf" });
-
-  expect(result.error!.issues).toHaveLength(2);
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "string",
-        "code": "invalid_type",
-        "path": [
-          "missing"
-        ],
-        "message": "Invalid input: expected string, received undefined"
-      },
-      {
-        "origin": "string",
-        "code": "invalid_format",
-        "format": "regex",
-        "pattern": "/ asdf/",
-        "path": [
-          "preprocess"
-        ],
-        "message": "Invalid string: must match pattern / asdf/"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("perform transform with non-fatal issues", () => {
-  const A = z
-    .string()
-    .refine((_) => false)
-    .min(4)
-    .transform((val) => val.length)
-    .pipe(z.number())
-    .refine((_) => false);
-  expect(A.safeParse("asdfasdf").error!.issues).toHaveLength(1);
-  expect(A.safeParse("asdfasdf").error).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "custom",
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]]
-  `);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/primitive.test.ts

@@ -1,175 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const literalStringSchema = z.literal("asdf");
-const literalNumberSchema = z.literal(12);
-const literalBooleanSchema = z.literal(true);
-const literalBigIntSchema = z.literal(BigInt(42));
-
-const stringSchema = z.string();
-const numberSchema = z.number();
-const bigintSchema = z.bigint();
-const booleanSchema = z.boolean();
-const dateSchema = z.date();
-const symbolSchema = z.symbol();
-const nullSchema = z.null();
-const undefinedSchema = z.undefined();
-const stringSchemaOptional = z.string().optional();
-const stringSchemaNullable = z.string().nullable();
-const numberSchemaOptional = z.number().optional();
-const numberSchemaNullable = z.number().nullable();
-const bigintSchemaOptional = z.bigint().optional();
-const bigintSchemaNullable = z.bigint().nullable();
-const booleanSchemaOptional = z.boolean().optional();
-const booleanSchemaNullable = z.boolean().nullable();
-const dateSchemaOptional = z.date().optional();
-const dateSchemaNullable = z.date().nullable();
-const symbolSchemaOptional = z.symbol().optional();
-const symbolSchemaNullable = z.symbol().nullable();
-
-test("literal string schema", () => {
-  expect(literalStringSchema.parse("asdf")).toBe("asdf");
-  expect(() => literalStringSchema.parse("not_asdf")).toThrow();
-  expect(() => literalStringSchema.parse(123)).toThrow();
-  expect(() => literalStringSchema.parse(true)).toThrow();
-  expect(() => literalStringSchema.parse({})).toThrow();
-});
-
-test("literal number schema", () => {
-  expect(literalNumberSchema.parse(12)).toBe(12);
-  expect(() => literalNumberSchema.parse(13)).toThrow();
-  expect(() => literalNumberSchema.parse("foo")).toThrow();
-  expect(() => literalNumberSchema.parse(true)).toThrow();
-  expect(() => literalNumberSchema.parse({})).toThrow();
-});
-
-test("literal boolean schema", () => {
-  expect(literalBooleanSchema.parse(true)).toBe(true);
-  expect(() => literalBooleanSchema.parse(false)).toThrow();
-  expect(() => literalBooleanSchema.parse("asdf")).toThrow();
-  expect(() => literalBooleanSchema.parse(123)).toThrow();
-  expect(() => literalBooleanSchema.parse({})).toThrow();
-});
-
-test("literal bigint schema", () => {
-  expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
-  expect(() => literalBigIntSchema.parse(BigInt(43))).toThrow();
-  expect(() => literalBigIntSchema.parse("asdf")).toThrow();
-  expect(() => literalBigIntSchema.parse(123)).toThrow();
-  expect(() => literalBigIntSchema.parse({})).toThrow();
-});
-
-test("string schema", () => {
-  stringSchema.parse("foo");
-  expect(() => stringSchema.parse(Math.random())).toThrow();
-  expect(() => stringSchema.parse(true)).toThrow();
-  expect(() => stringSchema.parse(undefined)).toThrow();
-  expect(() => stringSchema.parse(null)).toThrow();
-});
-
-test("number schema", () => {
-  numberSchema.parse(Math.random());
-  expect(() => numberSchema.parse("foo")).toThrow();
-  expect(() => numberSchema.parse(BigInt(17))).toThrow();
-  expect(() => numberSchema.parse(true)).toThrow();
-  expect(() => numberSchema.parse(undefined)).toThrow();
-  expect(() => numberSchema.parse(null)).toThrow();
-});
-
-test("bigint schema", () => {
-  bigintSchema.parse(BigInt(17));
-  expect(() => bigintSchema.parse("foo")).toThrow();
-  expect(() => bigintSchema.parse(Math.random())).toThrow();
-  expect(() => bigintSchema.parse(true)).toThrow();
-  expect(() => bigintSchema.parse(undefined)).toThrow();
-  expect(() => bigintSchema.parse(null)).toThrow();
-});
-
-test("boolean schema", () => {
-  booleanSchema.parse(true);
-  expect(() => booleanSchema.parse("foo")).toThrow();
-  expect(() => booleanSchema.parse(Math.random())).toThrow();
-  expect(() => booleanSchema.parse(undefined)).toThrow();
-  expect(() => booleanSchema.parse(null)).toThrow();
-});
-
-test("date schema", async () => {
-  dateSchema.parse(new Date());
-  expect(() => dateSchema.parse("foo")).toThrow();
-  expect(() => dateSchema.parse(Math.random())).toThrow();
-  expect(() => dateSchema.parse(true)).toThrow();
-  expect(() => dateSchema.parse(undefined)).toThrow();
-  expect(() => dateSchema.parse(null)).toThrow();
-  expect(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "expected": "date",
-        "code": "invalid_type",
-        "received": "Invalid Date",
-        "path": [],
-        "message": "Invalid input: expected date, received Date"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("symbol schema", () => {
-  symbolSchema.parse(Symbol("foo"));
-  expect(() => symbolSchema.parse("foo")).toThrow();
-  expect(() => symbolSchema.parse(Math.random())).toThrow();
-  expect(() => symbolSchema.parse(true)).toThrow();
-  expect(() => symbolSchema.parse(new Date())).toThrow();
-  expect(() => symbolSchema.parse(undefined)).toThrow();
-  expect(() => symbolSchema.parse(null)).toThrow();
-});
-
-test("undefined schema", () => {
-  undefinedSchema.parse(undefined);
-  expect(() => undefinedSchema.parse("foo")).toThrow();
-  expect(() => undefinedSchema.parse(Math.random())).toThrow();
-  expect(() => undefinedSchema.parse(true)).toThrow();
-  expect(() => undefinedSchema.parse(null)).toThrow();
-});
-
-test("null schema", () => {
-  nullSchema.parse(null);
-  expect(() => nullSchema.parse("foo")).toThrow();
-  expect(() => nullSchema.parse(Math.random())).toThrow();
-  expect(() => nullSchema.parse(true)).toThrow();
-  expect(() => nullSchema.parse(undefined)).toThrow();
-});
-
-test("primitive inference", () => {
-  expectTypeOf<z.TypeOf<typeof literalStringSchema>>().toEqualTypeOf<"asdf">();
-  expectTypeOf<z.TypeOf<typeof literalNumberSchema>>().toEqualTypeOf<12>();
-  expectTypeOf<z.TypeOf<typeof literalBooleanSchema>>().toEqualTypeOf<true>();
-  expectTypeOf<z.TypeOf<typeof literalBigIntSchema>>().toEqualTypeOf<bigint>();
-  expectTypeOf<z.TypeOf<typeof stringSchema>>().toEqualTypeOf<string>();
-  expectTypeOf<z.TypeOf<typeof numberSchema>>().toEqualTypeOf<number>();
-  expectTypeOf<z.TypeOf<typeof bigintSchema>>().toEqualTypeOf<bigint>();
-  expectTypeOf<z.TypeOf<typeof booleanSchema>>().toEqualTypeOf<boolean>();
-  expectTypeOf<z.TypeOf<typeof dateSchema>>().toEqualTypeOf<Date>();
-  expectTypeOf<z.TypeOf<typeof symbolSchema>>().toEqualTypeOf<symbol>();
-  expectTypeOf<z.TypeOf<typeof nullSchema>>().toEqualTypeOf<null>();
-  expectTypeOf<z.TypeOf<typeof undefinedSchema>>().toEqualTypeOf<undefined>();
-  expectTypeOf<z.TypeOf<typeof stringSchemaOptional>>().toEqualTypeOf<string | undefined>();
-  expectTypeOf<z.TypeOf<typeof stringSchemaNullable>>().toEqualTypeOf<string | null>();
-  expectTypeOf<z.TypeOf<typeof numberSchemaOptional>>().toEqualTypeOf<number | undefined>();
-  expectTypeOf<z.TypeOf<typeof numberSchemaNullable>>().toEqualTypeOf<number | null>();
-  expectTypeOf<z.TypeOf<typeof bigintSchemaOptional>>().toEqualTypeOf<bigint | undefined>();
-  expectTypeOf<z.TypeOf<typeof bigintSchemaNullable>>().toEqualTypeOf<bigint | null>();
-  expectTypeOf<z.TypeOf<typeof booleanSchemaOptional>>().toEqualTypeOf<boolean | undefined>();
-  expectTypeOf<z.TypeOf<typeof booleanSchemaNullable>>().toEqualTypeOf<boolean | null>();
-  expectTypeOf<z.TypeOf<typeof dateSchemaOptional>>().toEqualTypeOf<Date | undefined>();
-  expectTypeOf<z.TypeOf<typeof dateSchemaNullable>>().toEqualTypeOf<Date | null>();
-  expectTypeOf<z.TypeOf<typeof symbolSchemaOptional>>().toEqualTypeOf<symbol | undefined>();
-  expectTypeOf<z.TypeOf<typeof symbolSchemaNullable>>().toEqualTypeOf<symbol | null>();
-});
-
-test("get literal values", () => {
-  expect(literalStringSchema.values).toEqual(new Set(["asdf"]));
-  expect(literalStringSchema._zod.def.values).toEqual(["asdf"]);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/promise.test.ts

@@ -1,81 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const promSchema = z.promise(
-  z.object({
-    name: z.string(),
-    age: z.number(),
-  })
-);
-
-test("promise inference", () => {
-  type promSchemaType = z.infer<typeof promSchema>;
-  expectTypeOf<promSchemaType>().toEqualTypeOf<{ name: string; age: number }>();
-});
-
-test("promise parsing success", async () => {
-  // expect(() => promSchema.parse(Promise.resolve({ name: "Bobby", age: 10 }))).toThrow();
-  const pr = promSchema.parseAsync(Promise.resolve({ name: "Bobby", age: 10 }));
-  expect(pr).toBeInstanceOf(Promise);
-  const result = await pr;
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "age": 10,
-      "name": "Bobby",
-    }
-  `);
-});
-
-test("promise parsing fail", async () => {
-  const bad = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
-  expect(bad.success).toBe(false);
-  expect(bad.error).toBeInstanceOf(z.ZodError);
-});
-
-test("promise parsing fail 2", async () => {
-  const result = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
-  expect(result.success).toBe(false);
-  expect(result.error).toBeInstanceOf(z.ZodError);
-});
-
-test("promise parsing fail", () => {
-  const bad = () => promSchema.parse({ then: () => {}, catch: {} });
-  expect(bad).toThrow();
-});
-
-test("sync promise parsing", () => {
-  expect(() => z.promise(z.string()).parse(Promise.resolve("asfd"))).toThrow();
-});
-
-const asyncFunction = z.function({
-  input: z.tuple([]),
-  output: promSchema,
-});
-
-test("async function pass", async () => {
-  const validatedFunction = asyncFunction.implementAsync(async () => {
-    return { name: "jimmy", age: 14 };
-  });
-  await expect(validatedFunction()).resolves.toEqual({
-    name: "jimmy",
-    age: 14,
-  });
-});
-
-test("async function fail", async () => {
-  const validatedFunction = asyncFunction.implementAsync(() => {
-    return Promise.resolve("asdf" as any);
-  });
-  await expect(validatedFunction()).rejects.toBeInstanceOf(z.core.$ZodError);
-});
-
-test("async promise parsing", () => {
-  const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
-  expect(res).toBeInstanceOf(Promise);
-});
-
-test("resolves", () => {
-  const foo = z.literal("foo");
-  const res = z.promise(foo);
-  expect(res.unwrap()).toEqual(foo);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/prototypes.test.ts

@@ -1,23 +0,0 @@
-import { expect, test } from "vitest";
-import * as z from "zod/v4";
-
-declare module "zod/v4" {
-  interface ZodType {
-    /** @deprecated */
-    _classic(): string;
-  }
-}
-
-test("prototype extension", () => {
-  z.ZodType.prototype._classic = function () {
-    return "_classic";
-  };
-
-  // should pass
-  const result = z.string()._classic();
-  expect(result).toBe("_classic");
-  // expectTypeOf<typeof result>().toEqualTypeOf<string>();
-
-  // clean up
-  z.ZodType.prototype._classic = undefined;
-});