fullstacked 0.12.1-1370 → 0.12.2-1380

package/fullstacked_modules/zod/src/v3/tests/transformer.test.ts

@@ -1,233 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const stringToNumber = z.string().transform((arg) => Number.parseFloat(arg));
-// const numberToString = z
-//   .transformer(z.number())
-//   .transform((n) => String(n));
-const asyncNumberToString = z.number().transform(async (n) => String(n));
-
-test("transform ctx.addIssue with parse", () => {
-  const strs = ["foo", "bar"];
-
-  expect(() => {
-    z.string()
-      .transform((data, ctx) => {
-        const i = strs.indexOf(data);
-        if (i === -1) {
-          ctx.addIssue({
-            code: "custom",
-            message: `${data} is not one of our allowed strings`,
-          });
-        }
-        return data.length;
-      })
-      .parse("asdf");
-  }).toThrow(
-    JSON.stringify(
-      [
-        {
-          code: "custom",
-          message: "asdf is not one of our allowed strings",
-          path: [],
-        },
-      ],
-      null,
-      2
-    )
-  );
-});
-
-test("transform ctx.addIssue with parseAsync", async () => {
-  const strs = ["foo", "bar"];
-
-  const result = await z
-    .string()
-    .transform(async (data, ctx) => {
-      const i = strs.indexOf(data);
-      if (i === -1) {
-        ctx.addIssue({
-          code: "custom",
-          message: `${data} is not one of our allowed strings`,
-        });
-      }
-      return data.length;
-    })
-    .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 transform", () => {
-  const foo = z
-    .number()
-    .optional()
-    .transform((val, ctx) => {
-      if (!val) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "bad" });
-        return z.NEVER;
-      }
-      return val;
-    });
-  type foo = z.infer<typeof foo>;
-  util.assertEqual<foo, number>(true);
-  const arg = foo.safeParse(undefined);
-  if (!arg.success) {
-    expect(arg.error.issues[0].message).toEqual("bad");
-  }
-});
-
-test("basic transformations", () => {
-  const r1 = z
-    .string()
-    .transform((data) => data.length)
-    .parse("asdf");
-  expect(r1).toEqual(4);
-});
-
-test("coercion", () => {
-  const numToString = z.number().transform((n) => String(n));
-  const data = z
-    .object({
-      id: numToString,
-    })
-    .parse({ id: 5 });
-
-  expect(data).toEqual({ id: "5" });
-});
-
-test("async coercion", async () => {
-  const numToString = z.number().transform(async (n) => String(n));
-  const data = await z
-    .object({
-      id: numToString,
-    })
-    .parseAsync({ id: 5 });
-
-  expect(data).toEqual({ id: "5" });
-});
-
-test("sync coercion async error", async () => {
-  expect(() =>
-    z
-      .object({
-        id: asyncNumberToString,
-      })
-      .parse({ id: 5 })
-  ).toThrow();
-  // expect(data).toEqual({ id: '5' });
-});
-
-test("default", () => {
-  const data = z.string().default("asdf").parse(undefined); // => "asdf"
-  expect(data).toEqual("asdf");
-});
-
-test("dynamic default", () => {
-  const data = z
-    .string()
-    .default(() => "string")
-    .parse(undefined); // => "asdf"
-  expect(data).toEqual("string");
-});
-
-test("default when property is null or undefined", () => {
-  const data = z
-    .object({
-      foo: z.boolean().nullable().default(true),
-      bar: z.boolean().default(true),
-    })
-    .parse({ foo: null });
-
-  expect(data).toEqual({ foo: null, bar: true });
-});
-
-test("default with falsy values", () => {
-  const schema = z.object({
-    emptyStr: z.string().default("def"),
-    zero: z.number().default(5),
-    falseBoolean: z.boolean().default(true),
-  });
-  const input = { emptyStr: "", zero: 0, falseBoolean: true };
-  const output = schema.parse(input);
-  // defaults are not supposed to be used
-  expect(output).toEqual(input);
-});
-
-test("object typing", () => {
-  const t1 = z.object({
-    stringToNumber,
-  });
-
-  type t1 = z.input<typeof t1>;
-  type t2 = z.output<typeof t1>;
-
-  util.assertEqual<t1, { stringToNumber: string }>(true);
-  util.assertEqual<t2, { stringToNumber: number }>(true);
-});
-
-test("transform method overloads", () => {
-  const t1 = z.string().transform((val) => val.toUpperCase());
-  expect(t1.parse("asdf")).toEqual("ASDF");
-
-  const t2 = z.string().transform((val) => val.length);
-  expect(t2.parse("asdf")).toEqual(4);
-});
-
-test("multiple transformers", () => {
-  const doubler = stringToNumber.transform((val) => {
-    return val * 2;
-  });
-  expect(doubler.parse("5")).toEqual(10);
-});
-
-test("short circuit on dirty", () => {
-  const schema = z
-    .string()
-    .refine(() => false)
-    .transform((val) => val.toUpperCase());
-  const result = schema.safeParse("asdf");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.custom);
-  }
-
-  const result2 = schema.safeParse(1234);
-  expect(result2.success).toEqual(false);
-  if (!result2.success) {
-    expect(result2.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_type);
-  }
-});
-
-test("async short circuit on dirty", async () => {
-  const schema = z
-    .string()
-    .refine(() => false)
-    .transform((val) => val.toUpperCase());
-  const result = await schema.spa("asdf");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.custom);
-  }
-
-  const result2 = await schema.spa(1234);
-  expect(result2.success).toEqual(false);
-  if (!result2.success) {
-    expect(result2.error.issues[0].code).toEqual(z.ZodIssueCode.invalid_type);
-  }
-});

package/fullstacked_modules/zod/src/v3/tests/tuple.test.ts

@@ -1,90 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { ZodError } from "../ZodError.js";
-import { util } from "../helpers/util.js";
-
-const testTuple = z.tuple([z.string(), z.object({ name: z.literal("Rudy") }), z.array(z.literal("blue"))]);
-const testData = ["asdf", { name: "Rudy" }, ["blue"]];
-const badData = [123, { name: "Rudy2" }, ["blue", "red"]];
-
-test("tuple inference", () => {
-  const args1 = z.tuple([z.string()]);
-  const returns1 = z.number();
-  const func1 = z.function(args1, returns1);
-  type func1 = z.TypeOf<typeof func1>;
-  util.assertEqual<func1, (k: string) => number>(true);
-});
-
-test("successful validation", () => {
-  const val = testTuple.parse(testData);
-  expect(val).toEqual(["asdf", { name: "Rudy" }, ["blue"]]);
-});
-
-test("successful async validation", async () => {
-  const val = await testTuple.parseAsync(testData);
-  return expect(val).toEqual(testData);
-});
-
-test("failed validation", () => {
-  const checker = () => {
-    testTuple.parse([123, { name: "Rudy2" }, ["blue", "red"]] as any);
-  };
-  try {
-    checker();
-  } catch (err) {
-    if (err instanceof ZodError) {
-      expect(err.issues.length).toEqual(3);
-    }
-  }
-});
-
-test("failed async validation", async () => {
-  const res = await testTuple.safeParse(badData);
-  expect(res.success).toEqual(false);
-  if (!res.success) {
-    expect(res.error.issues.length).toEqual(3);
-  }
-  // try {
-  //   checker();
-  // } catch (err) {
-  //   if (err instanceof ZodError) {
-  //     expect(err.issues.length).toEqual(3);
-  //   }
-  // }
-});
-
-test("tuple with transformers", () => {
-  const stringToNumber = z.string().transform((val) => val.length);
-  const val = z.tuple([stringToNumber]);
-
-  type t1 = z.input<typeof val>;
-  util.assertEqual<t1, [string]>(true);
-  type t2 = z.output<typeof val>;
-  util.assertEqual<t2, [number]>(true);
-  expect(val.parse(["1234"])).toEqual([4]);
-});
-
-test("tuple with rest schema", () => {
-  const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
-  expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
-
-  expect(myTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
-
-  expect(() => myTuple.parse(["asdf", 1234, "asdf"])).toThrow();
-  type t1 = z.output<typeof myTuple>;
-
-  util.assertEqual<t1, [string, number, ...boolean[]]>(true);
-});
-
-test("parse should fail given sparse array as tuple", () => {
-  expect(() => testTuple.parse(new Array(3))).toThrow();
-});
-
-// test('tuple with optional elements', () => {
-//   const result = z
-//     .tuple([z.string(), z.number().optional()])
-//     .safeParse(['asdf']);
-//   expect(result).toEqual(['asdf']);
-// });

package/fullstacked_modules/zod/src/v3/tests/unions.test.ts

@@ -1,57 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("function parsing", () => {
-  const schema = z.union([z.string().refine(() => false), z.number().refine(() => false)]);
-  const result = schema.safeParse("asdf");
-  expect(result.success).toEqual(false);
-});
-
-test("union 2", () => {
-  const result = z.union([z.number(), z.string().refine(() => false)]).safeParse("a");
-  expect(result.success).toEqual(false);
-});
-
-test("return valid over invalid", () => {
-  const schema = z.union([
-    z.object({
-      email: z.string().email(),
-    }),
-    z.string(),
-  ]);
-  expect(schema.parse("asdf")).toEqual("asdf");
-  expect(schema.parse({ email: "asdlkjf@lkajsdf.com" })).toEqual({
-    email: "asdlkjf@lkajsdf.com",
-  });
-});
-
-test("return dirty result over aborted", () => {
-  const result = z.union([z.number(), z.string().refine(() => false)]).safeParse("a");
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues).toEqual([
-      {
-        code: "custom",
-        message: "Invalid input",
-        path: [],
-      },
-    ]);
-  }
-});
-
-test("options getter", async () => {
-  const union = z.union([z.string(), z.number()]);
-  union.options[0].parse("asdf");
-  union.options[1].parse(1234);
-  await union.options[0].parseAsync("asdf");
-  await union.options[1].parseAsync(1234);
-});
-
-test("readonly union", async () => {
-  const options = [z.string(), z.number()] as const;
-  const union = z.union(options);
-  union.parse("asdf");
-  union.parse(12);
-});

package/fullstacked_modules/zod/src/v3/tests/validations.test.ts

@@ -1,133 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("array min", async () => {
-  try {
-    await z.array(z.string()).min(4).parseAsync([]);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Array must contain at least 4 element(s)");
-  }
-});
-
-test("array max", async () => {
-  try {
-    await z.array(z.string()).max(2).parseAsync(["asdf", "asdf", "asdf"]);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Array must contain at most 2 element(s)");
-  }
-});
-
-test("array length", async () => {
-  try {
-    await z.array(z.string()).length(2).parseAsync(["asdf", "asdf", "asdf"]);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Array must contain exactly 2 element(s)");
-  }
-
-  try {
-    await z.array(z.string()).length(2).parseAsync(["asdf"]);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Array must contain exactly 2 element(s)");
-  }
-});
-
-test("string length", async () => {
-  try {
-    await z.string().length(4).parseAsync("asd");
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("String must contain exactly 4 character(s)");
-  }
-
-  try {
-    await z.string().length(4).parseAsync("asdaa");
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("String must contain exactly 4 character(s)");
-  }
-});
-
-test("string min", async () => {
-  try {
-    await z.string().min(4).parseAsync("asd");
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("String must contain at least 4 character(s)");
-  }
-});
-
-test("string max", async () => {
-  try {
-    await z.string().max(4).parseAsync("aasdfsdfsd");
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("String must contain at most 4 character(s)");
-  }
-});
-
-test("number min", async () => {
-  try {
-    await z.number().gte(3).parseAsync(2);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be greater than or equal to 3");
-  }
-});
-
-test("number max", async () => {
-  try {
-    await z.number().lte(3).parseAsync(4);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be less than or equal to 3");
-  }
-});
-
-test("number nonnegative", async () => {
-  try {
-    await z.number().nonnegative().parseAsync(-1);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be greater than or equal to 0");
-  }
-});
-
-test("number nonpositive", async () => {
-  try {
-    await z.number().nonpositive().parseAsync(1);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be less than or equal to 0");
-  }
-});
-
-test("number negative", async () => {
-  try {
-    await z.number().negative().parseAsync(1);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be less than 0");
-  }
-});
-
-test("number positive", async () => {
-  try {
-    await z.number().positive().parseAsync(-1);
-  } catch (err) {
-    expect((err as z.ZodError).issues[0].message).toEqual("Number must be greater than 0");
-  }
-});
-
-test("instantiation", () => {
-  z.string().min(5);
-  z.string().max(5);
-  z.string().length(5);
-  z.string().email();
-  z.string().url();
-  z.string().uuid();
-  z.string().min(5, { message: "Must be 5 or more characters long" });
-  z.string().max(5, { message: "Must be 5 or fewer characters long" });
-  z.string().length(5, { message: "Must be exactly 5 characters long" });
-  z.string().email({ message: "Invalid email address." });
-  z.string().url({ message: "Invalid url" });
-  z.string().uuid({ message: "Invalid UUID" });
-});
-
-test("int", async () => {
-  const int = z.number().int();
-  int.parse(4);
-  expect(() => int.parse(3.5)).toThrow();
-});

package/fullstacked_modules/zod/src/v3/tests/void.test.ts

@@ -1,15 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-test("void", () => {
-  const v = z.void();
-  v.parse(undefined);
-
-  expect(() => v.parse(null)).toThrow();
-  expect(() => v.parse("")).toThrow();
-
-  type v = z.infer<typeof v>;
-  util.assertEqual<v, void>(true);
-});