@undefineds.co/xpod 0.4.18 → 0.4.20

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/classic/tests/function.test.ts

@@ -0,0 +1,360 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const args1 = z.tuple([z.string()]);
+const returns1 = z.number();
+const func1 = z.function({
+  input: args1,
+
+  output: returns1,
+});
+
+test("function parsing", () => {
+  const parsed = func1.implement((arg: any) => arg.length);
+  const result = parsed("asdf");
+  expect(result).toBe(4);
+});
+
+test("parsed function fail 1", () => {
+  // @ts-expect-error
+  const parsed = func1.implement((x: string) => x);
+  expect(() => parsed("asdf")).toThrow();
+});
+
+test("parsed function fail 2", () => {
+  // @ts-expect-error
+  const parsed = func1.implement((x: string) => x);
+  expect(() => parsed(13 as any)).toThrow();
+});
+
+test("function inference 1", () => {
+  type func1 = (typeof func1)["_input"];
+  expectTypeOf<func1>().toEqualTypeOf<(k: string) => number>();
+});
+
+test("method parsing", () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z
+      .function()
+      .input(z.tuple([z.string()]))
+      .output(z.number()),
+  });
+  const methodInstance = {
+    property: 3,
+    method: function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("async method parsing", async () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z.function().input([z.string()]).output(z.promise(z.number())),
+  });
+  const methodInstance = {
+    property: 3,
+    method: async function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("args method", () => {
+  const t1 = z.function();
+  type t1 = (typeof t1)["_input"];
+  expectTypeOf<t1>().toEqualTypeOf<(...args_1: never[]) => unknown>();
+  t1._input;
+
+  const t2args = z.tuple([z.string()], z.unknown());
+
+  const t2 = t1.input(t2args);
+  type t2 = (typeof t2)["_input"];
+  expectTypeOf<t2>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => unknown>();
+
+  const t3 = t2.output(z.boolean());
+  type t3 = (typeof t3)["_input"];
+  expectTypeOf<t3>().toEqualTypeOf<(arg: string, ...args_1: unknown[]) => boolean>();
+});
+
+// test("custom args", () => {
+//   const fn = z.function().implement((_a: string, _b: number) => {
+//     return new Date();
+//   });
+
+//   expectTypeOf(fn).toEqualTypeOf<(a: string, b: number) => Date>();
+// });
+
+const args2 = z.tuple([
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+]);
+const returns2 = z.union([z.string(), z.number()]);
+
+const func2 = z.function({
+  input: args2,
+  output: returns2,
+});
+
+test("function inference 2", () => {
+  type func2 = (typeof func2)["_input"];
+
+  expectTypeOf<func2>().toEqualTypeOf<
+    (arg: {
+      f3?: (boolean | undefined)[] | undefined;
+      f1: number;
+      f2: string | null;
+    }) => string | number
+  >();
+});
+
+test("valid function run", () => {
+  const validFunc2Instance = func2.implement((_x) => {
+    _x.f2;
+    _x.f3![0];
+    return "adf" as any;
+  });
+
+  validFunc2Instance({
+    f1: 21,
+    f2: "asdf",
+    f3: [true, false],
+  });
+});
+
+const args3 = [
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+] as const;
+const returns3 = z.union([z.string(), z.number()]);
+
+const func3 = z.function({
+  input: args3,
+  output: returns3,
+});
+
+test("function inference 3", () => {
+  type func3 = (typeof func3)["_input"];
+
+  expectTypeOf<func3>().toEqualTypeOf<
+    (arg: {
+      f3?: (boolean | undefined)[] | undefined;
+      f1: number;
+      f2: string | null;
+    }) => string | number
+  >();
+});
+
+test("valid function run", () => {
+  const validFunc3Instance = func3.implement((_x) => {
+    _x.f2;
+    _x.f3![0];
+    return "adf" as any;
+  });
+
+  validFunc3Instance({
+    f1: 21,
+    f2: "asdf",
+    f3: [true, false],
+  });
+});
+
+test("input validation error", () => {
+  const schema = z.function({
+    input: z.tuple([z.string()]),
+    output: z.void(),
+  });
+  const fn = schema.implement(() => 1234 as any);
+
+  // @ts-expect-error
+  const checker = () => fn();
+
+  try {
+    checker();
+  } catch (e: any) {
+    expect(e.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "too_small",
+          "inclusive": true,
+          "message": "Too small: expected array to have >=1 items",
+          "minimum": 1,
+          "origin": "array",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});
+
+test("array inputs", () => {
+  const a = z.function({
+    input: [
+      z.object({
+        name: z.string(),
+        age: z.number().int(),
+      }),
+    ],
+    output: z.string(),
+  });
+
+  a.implement((args) => {
+    return `${args.age}`;
+  });
+
+  const b = z.function({
+    input: [
+      z.object({
+        name: z.string(),
+        age: z.number().int(),
+      }),
+    ],
+  });
+  b.implement((args) => {
+    return `${args.age}`;
+  });
+});
+
+test("output validation error", () => {
+  const schema = z.function({
+    input: z.tuple([]),
+    output: z.string(),
+  });
+  const fn = schema.implement(() => 1234 as any);
+  try {
+    fn();
+  } catch (e: any) {
+    expect(e.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});
+
+test("function with async refinements", async () => {
+  const schema = z
+    .function()
+    .input([z.string().refine(async (val) => val.length > 10)])
+    .output(z.promise(z.number().refine(async (val) => val > 10)));
+
+  const func = schema.implementAsync(async (val) => {
+    return val.length;
+  });
+  const results = [];
+  try {
+    await func("asdfasdf");
+    results.push("success");
+  } catch (_) {
+    results.push("fail");
+  }
+  try {
+    await func("asdflkjasdflkjsf");
+    results.push("success");
+  } catch (_) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail", "success"]);
+});
+
+test("implement async with transforms", async () => {
+  const typeGuard = (data: string): data is "1234" => data === "1234";
+  const codeSchema = z.string().transform((data, ctx) => {
+    if (typeGuard(data)) {
+      return data;
+    } else {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Invalid code",
+      });
+      return z.NEVER;
+    }
+  });
+  const inputSchema = z.object({
+    code: codeSchema,
+  });
+  const outputSchema = z.object({
+    data: z.array(z.string()).default([]),
+  });
+  const fnImplementation = async (data: z.infer<typeof inputSchema>): Promise<z.infer<typeof outputSchema>> => {
+    return {
+      data: [data.code],
+    };
+  };
+  const schema = z.function().input([inputSchema]).output(outputSchema);
+
+  const func = schema.implementAsync(fnImplementation);
+  type TheInterface = {
+    myFunction: (data: z.infer<typeof inputSchema>) => Promise<z.infer<typeof outputSchema>>;
+  };
+  const theImplementation: TheInterface = {
+    myFunction: func,
+  };
+  const results = [];
+  try {
+    await theImplementation.myFunction({
+      code: "1234",
+    });
+    results.push("success");
+  } catch (_) {
+    results.push("fail");
+  }
+  try {
+    await func({ data: "asdflkjasdflkjsf" } as any);
+    results.push("success");
+  } catch (_) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["success", "fail"]);
+});
+
+test("non async function with async refinements should fail", async () => {
+  const func = z
+    .function()
+    .input([z.string().refine(async (val) => val.length > 10)])
+    .output(z.number().refine(async (val) => val > 10))
+    .implement((val) => {
+      return val.length;
+    });
+
+  const results = [];
+  try {
+    await func("asdasdfasdffasdf");
+    results.push("success");
+  } catch (_) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail"]);
+});
+
+test("extra parameters with rest", () => {
+  const maxLength5 = z
+    .function()
+    .input([z.string()], z.unknown())
+    .output(z.boolean())
+    .implement((str, _arg, _qewr) => {
+      return str.length <= 5;
+    });
+
+  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
+  expect(filteredList.length).toEqual(2);
+});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/classic/tests/generics.test.ts

@@ -0,0 +1,72 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+function nest<TData extends z.ZodType>(schema: TData) {
+  return z.object({
+    nested: schema,
+  });
+}
+
+test("generics", () => {
+  const a = nest(z.object({ a: z.string() }));
+  type a = z.infer<typeof a>;
+  expectTypeOf<a>().toEqualTypeOf<{ nested: { a: string } }>();
+
+  const b = nest(z.object({ a: z.string().optional() }));
+  type b = z.infer<typeof b>;
+  expectTypeOf<b>().toEqualTypeOf<{ nested: { a?: string | undefined } }>();
+});
+
+test("generics with optional", () => {
+  async function stripOuter<TData extends z.ZodType>(schema: TData, data: unknown) {
+    return z
+      .object({
+        nested: schema.optional(),
+      })
+      .transform((data) => {
+        return data.nested;
+      })
+      .parse({ nested: data });
+  }
+
+  const result = stripOuter(z.object({ a: z.string() }), { a: "asdf" });
+  expectTypeOf<typeof result>().toEqualTypeOf<Promise<{ a: string } | undefined>>();
+});
+
+// test("assignability", () => {
+//   const createSchemaAndParse = <K extends string, VS extends z.ZodString>(key: K, valueSchema: VS, data: unknown) => {
+//     const schema = z.object({
+//       [key]: valueSchema,
+//     });
+//     // return { [key]: valueSchema };
+//     const parsed = schema.parse(data);
+//     return parsed;
+//     // const inferred: z.infer<z.ZodObject<{ [k in K]: VS }>> = parsed;
+//     // return inferred;
+//   };
+//   const parsed = createSchemaAndParse("foo", z.string(), { foo: "" });
+//   expectTypeOf<typeof parsed>().toEqualTypeOf<{ foo: string }>();
+// });
+
+test("nested no undefined", () => {
+  const inner = z.string().or(z.array(z.string()));
+  const outer = z.object({ inner });
+  type outerSchema = z.infer<typeof outer>;
+  expectTypeOf<outerSchema>().toEqualTypeOf<{ inner: string | string[] }>();
+
+  expect(outer.safeParse({ inner: undefined }).success).toEqual(false);
+});
+
+test("generic on output type", () => {
+  const createV4Schema = <Output>(opts: {
+    schema: z.ZodType<Output>;
+  }) => {
+    return opts.schema;
+  };
+
+  createV4Schema({
+    schema: z.object({
+      name: z.string(),
+    }),
+  })?._zod?.output?.name;
+});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/classic/tests/global-config.test.ts

@@ -0,0 +1,39 @@
+import { afterEach, expect, test } from "vitest";
+import * as z from "zod/v4";
+import * as core from "zod/v4/core";
+
+// `globalConfig` is attached to `globalThis.__zod_globalConfig` so that a
+// single config object is shared across CJS/ESM builds and across multiple
+// bundled copies of Zod in a monorepo. This mirrors the existing
+// `globalRegistry` -> `globalThis.__zod_globalRegistry` treatment.
+//
+// See #5789 for the footgun this fixes: users with both CJS and ESM
+// instances of Zod loaded had to call `z.config({ jitless: true })`
+// twice — once per instance — because each module-scope `globalConfig`
+// was a different object. With this change, one call updates state seen
+// by every loaded copy.
+
+afterEach(() => {
+  // Don't leak config mutations into other test files.
+  delete core.globalConfig.jitless;
+});
+
+test("globalConfig is singleton and attached to globalThis", () => {
+  expect(core.globalConfig).toBe((globalThis as any).__zod_globalConfig);
+});
+
+test("z.config writes are observed via globalThis.__zod_globalConfig", () => {
+  z.config({ jitless: true });
+  expect((globalThis as any).__zod_globalConfig.jitless).toBe(true);
+});
+
+test("pre-set globalThis.__zod_globalConfig is preserved on import", () => {
+  // Object identity is preserved across reloads of the module: anyone who
+  // pre-populates `globalThis.__zod_globalConfig` before Zod loads (e.g.
+  // an inline script before the bundle) keeps that exact object as the
+  // source of truth. Mutating it directly is equivalent to z.config().
+  const direct = (globalThis as any).__zod_globalConfig;
+  direct.jitless = true;
+  expect(core.globalConfig.jitless).toBe(true);
+  expect(z.config()).toBe(core.globalConfig);
+});

package/node_modules/@undefineds.co/drizzle-solid/node_modules/zod/src/v4/classic/tests/hash.test.ts

@@ -0,0 +1,68 @@
+import { expect, expectTypeOf, test } from "vitest";
+import { type ZodCustomStringFormat, hash } from "zod"; // adjust path as needed
+
+test("hash() API — types and runtime across all alg/enc combinations", async () => {
+  const { createHash } = await import("node:crypto");
+
+  type Alg = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+  // type Enc = "hex" | "base64" | "base64url";
+
+  const toB64Url = (b64: string) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+
+  const makeDigests = (alg: Alg, input: string) => {
+    const buf = createHash(alg).update(input).digest();
+    const hex = buf.toString("hex");
+    const base64 = buf.toString("base64");
+    const base64url = toB64Url(base64);
+    return { hex, base64, base64url };
+  };
+
+  const algs: ReadonlyArray<Alg> = ["md5", "sha1", "sha256", "sha384", "sha512"];
+  const input = "zodasklfjaasdf";
+
+  // --- Type-level checks (ensure the literal format string is encoded in the return type)
+  expectTypeOf(hash("md5")).toEqualTypeOf<ZodCustomStringFormat<"md5_hex">>();
+  expectTypeOf(hash("sha1")).toEqualTypeOf<ZodCustomStringFormat<"sha1_hex">>();
+  expectTypeOf(hash("sha256", { enc: "base64" as const })).toEqualTypeOf<ZodCustomStringFormat<"sha256_base64">>();
+  expectTypeOf(hash("sha384", { enc: "base64url" as const })).toEqualTypeOf<
+    ZodCustomStringFormat<"sha384_base64url">
+  >();
+
+  // Test generic format types are correctly inferred and Enc defaults to "hex"
+  expectTypeOf(hash("sha256")).toEqualTypeOf<ZodCustomStringFormat<"sha256_hex">>();
+
+  // --- Runtime matrix (success + a few sharp-edged failures per combo)
+  for (const alg of algs) {
+    const { hex, base64, base64url } = makeDigests(alg, input);
+
+    // Success cases
+    expect(hash(alg).parse(hex)).toBe(hex); // default enc=hex
+    expect(hash(alg, { enc: "hex" }).parse(hex)).toBe(hex);
+    expect(hash(alg, { enc: "base64" }).parse(base64)).toBe(base64);
+    expect(hash(alg, { enc: "base64url" }).parse(base64url)).toBe(base64url);
+
+    // Failure cases (wrong encoding to schema)
+    expect(() => hash(alg, { enc: "hex" }).parse(base64)).toThrow();
+    expect(() => hash(alg, { enc: "base64" }).parse(hex)).toThrow();
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64)).toThrow();
+
+    // Encoding-specific failures
+    // hex: uppercase allowed, wrong length should fail
+    hash(alg, { enc: "hex" }).parse(hex.toUpperCase());
+    expect(() => hash(alg, { enc: "hex" }).parse(hex.slice(0, -1))).toThrow();
+
+    // base64: missing required padding should fail (only for algorithms that require padding)
+    if (base64.includes("=")) {
+      const base64NoPad = base64.replace(/=+$/g, "");
+      expect(() => hash(alg, { enc: "base64" }).parse(base64NoPad)).toThrow();
+    }
+
+    // base64url: adding padding or using invalid characters should fail
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "=")).toThrow();
+    expect(() => hash(alg, { enc: "base64url" }).parse(base64url + "!")).toThrow();
+
+    // Param object present but enc omitted should still default to hex at runtime
+    const schemaWithEmptyParams = hash(alg, {} as any);
+    expect(schemaWithEmptyParams.parse(hex)).toBe(hex);
+  }
+});