@suveren/gateway 0.39.0 → 0.40.0

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "vitest";
 import * as z from "zod/v4";
 
 describe("basic refinement functionality", () => {
@@ -167,8 +167,8 @@ describe("early termination options", () => {
 });
 
 describe("custom error paths", () => {
-  test("should use custom path in error message", async () => {
-    const result = await z
+  test("should use custom path in error message", () => {
+    const result = z
       .object({ password: z.string(), confirm: z.string() })
       .refine((data) => data.confirm === data.password, { path: ["confirm"] })
       .safeParse({ password: "asdf", confirm: "qewr" });
@@ -252,6 +252,79 @@ describe("superRefine functionality", () => {
     await expect(Strings.parseAsync(validArray)).resolves.toEqual(validArray);
   });
 
+  test("should test continuability of custom issues", () => {
+    // Default continue behavior - allows subsequent refinements
+    const defaultContinue = z
+      .string()
+      .superRefine((_, ctx) => {
+        ctx.addIssue({ code: "custom", message: "First issue" });
+      })
+      .refine(() => false, "Second issue");
+
+    expect(defaultContinue.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First issue",
+          "path": []
+        },
+        {
+          "code": "custom",
+          "path": [],
+          "message": "Second issue"
+        }
+      ]],
+        "success": false,
+      }
+    `);
+
+    // Explicit continue: false - prevents subsequent refinements
+    const explicitContinueFalse = z
+      .string()
+      .superRefine((_, ctx) => {
+        ctx.addIssue({ code: "custom", message: "First issue", continue: false });
+      })
+      .refine(() => false, "Second issue");
+
+    expect(explicitContinueFalse.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First issue",
+          "path": []
+        }
+      ]],
+        "success": false,
+      }
+    `);
+
+    // Multiple issues in same refinement - both always added regardless of continue
+    const multipleInSame = z.string().superRefine((_, ctx) => {
+      ctx.addIssue({ code: "custom", message: "First", continue: false });
+      ctx.addIssue({ code: "custom", message: "Second" });
+    });
+
+    expect(multipleInSame.safeParse("test")).toMatchInlineSnapshot(`
+      {
+        "error": [ZodError: [
+        {
+          "code": "custom",
+          "message": "First",
+          "path": []
+        },
+        {
+          "code": "custom",
+          "message": "Second",
+          "path": []
+        }
+      ]],
+        "success": false,
+      }
+    `);
+  });
+
   test("should accept string as shorthand for custom error message", () => {
     const schema = z.string().superRefine((_, ctx) => {
       ctx.addIssue("bad stuff");
@@ -265,6 +338,66 @@ describe("superRefine functionality", () => {
     }
   });
 
+  test("should preserve explicit nullish issue input", () => {
+    const schema = z.string().superRefine((_, ctx) => {
+      ctx.addIssue({ code: "custom", message: "default" });
+      ctx.addIssue({ code: "custom", message: "null", input: null });
+      ctx.addIssue({ code: "custom", message: "undefined", input: undefined });
+    });
+
+    const result = schema.safeParse("sensitive", { reportInput: true });
+    expect(result.success).toEqual(false);
+    if (!result.success) {
+      expect(result.error.issues).toHaveLength(3);
+      expect(result.error.issues[0].input).toEqual("sensitive");
+      expect(result.error.issues[1].input).toEqual(null);
+      expect(result.error.issues[2]).toHaveProperty("input");
+      expect(result.error.issues[2].input).toEqual(undefined);
+    }
+  });
+
+  test("should keep issue input aligned with the issue path", () => {
+    const nested = z.object({ a: z.string().nullable() }).superRefine((val, ctx) => {
+      if (val.a === null) ctx.addIssue({ code: "custom", path: ["a"], input: val.a, message: "no null" });
+    });
+
+    const direct = nested.safeParse({ a: null }, { reportInput: true });
+    expect(direct.success).toEqual(false);
+    if (!direct.success) {
+      expect(direct.error.issues[0].path).toEqual(["a"]);
+      expect(direct.error.issues[0].input).toEqual(null);
+    }
+
+    // Forwarding a nested parse's issues must not overwrite their input with the outer payload.
+    const inner = z.object({ x: z.string() });
+    const forwarding = z.unknown().superRefine((val, ctx) => {
+      const result = inner.safeParse(val, { reportInput: true });
+      if (!result.success) {
+        for (const iss of result.error.issues) {
+          ctx.addIssue({ code: "custom", path: iss.path, input: iss.input, message: iss.message });
+        }
+      }
+    });
+
+    const forwarded = forwarding.safeParse({}, { reportInput: true });
+    expect(forwarded.success).toEqual(false);
+    if (!forwarded.success) {
+      expect(forwarded.error.issues[0].path).toEqual(["x"]);
+      expect(forwarded.error.issues[0]).toHaveProperty("input");
+      expect(forwarded.error.issues[0].input).toEqual(undefined);
+    }
+  });
+
+  test("should surface an explicit undefined input to the error map", () => {
+    const schema = z.object({ a: z.string().optional() }).superRefine((val, ctx) => {
+      if (!val.a) ctx.addIssue({ code: "custom", path: ["a"], input: val.a });
+    });
+
+    const result = schema.safeParse({}, { error: (iss) => (iss.input === undefined ? "Required" : "Invalid") });
+    expect(result.success).toEqual(false);
+    if (!result.success) expect(result.error.issues[0].message).toEqual("Required");
+  });
+
   test("should respect fatal flag in superRefine", () => {
     const schema = z
       .string()
@@ -341,86 +474,114 @@ describe("chained refinements", () => {
     };
     expect(objectSchema.parse(validData)).toEqual(validData);
   });
-});
 
-// Commented tests can be uncommented once type-checking issues are resolved
-/*
-describe("type refinement", () => {
-  test("refinement type guard", () => {
-    const validationSchema = z.object({
-      a: z.string().refine((s): s is "a" => s === "a"),
+  test("should run superRefine validation even when base schema validation fails when 'when' is defined and returns true", () => {
+    const baseSchema = z.object({
+      foo: z.number(),
+      bar: z.number(),
     });
-    type Input = z.input<typeof validationSchema>;
-    type Schema = z.infer<typeof validationSchema>;
-
-    expectTypeOf<Input["a"]>().not.toEqualTypeOf<"a">();
-    expectTypeOf<Input["a"]>().toEqualTypeOf<string>();
 
-    expectTypeOf<Schema["a"]>().toEqualTypeOf<"a">();
-    expectTypeOf<Schema["a"]>().not.toEqualTypeOf<string>();
-  });
-
-  test("superRefine - type narrowing", () => {
-    type NarrowType = { type: string; age: number };
-    const schema = z
-      .object({
-        type: z.string(),
-        age: z.number(),
-      })
-      .nullable()
-      .superRefine((arg, ctx): arg is NarrowType => {
-        if (!arg) {
-          // still need to make a call to ctx.addIssue
+    const schema = baseSchema.superRefine(
+      (data, ctx) => {
+        if (data.foo > 10) {
           ctx.addIssue({
-            input: arg,
             code: "custom",
-            message: "cannot be null",
-            fatal: true,
+            message: "foo must be less than 10",
           });
-          return false;
         }
-        return true;
-      });
+      },
+      {
+        when: ({ value }) => baseSchema.pick({ foo: true }).safeParse(value).success,
+      }
+    );
 
-    expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<NarrowType>();
+    const result = schema.safeParse({
+      foo: 11,
+    });
+    expect(result.success).toEqual(false);
 
-    expect(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
-    expect(schema.safeParse(null).success).toEqual(false);
+    if (!result.success) {
+      expect(result.error.issues.length).toEqual(2);
+      expect(result.error.issues[0].message).toEqual("Invalid input: expected number, received undefined");
+      expect(result.error.issues[1].message).toEqual("foo must be less than 10");
+    }
   });
 
-  test("chained mixed refining types", () => {
-    type firstRefinement = { first: string; second: number; third: true };
-    type secondRefinement = { first: "bob"; second: number; third: true };
-    type thirdRefinement = { first: "bob"; second: 33; third: true };
-    const schema = z
-      .object({
-        first: z.string(),
-        second: z.number(),
-        third: z.boolean(),
-      })
-      .nullable()
-      .refine((arg): arg is firstRefinement => !!arg?.third)
-      .superRefine((arg, ctx): arg is secondRefinement => {
-        expectTypeOf<typeof arg>().toEqualTypeOf<firstRefinement>();
-        if (arg.first !== "bob") {
+  test("should not run superRefine validation when 'when' is defined and returns false", () => {
+    const baseSchema = z.object({
+      foo: z.number(),
+      bar: z.number(),
+    });
+
+    const schema = baseSchema.superRefine(
+      (data, ctx) => {
+        if (data.foo > 10) {
           ctx.addIssue({
-            input: arg,
             code: "custom",
-            message: "`first` property must be `bob`",
+            message: "foo must be less than 10",
           });
-          return false;
         }
-        return true;
-      })
-      .refine((arg): arg is thirdRefinement => {
-        expectTypeOf<typeof arg>().toEqualTypeOf<secondRefinement>();
-        return arg.second === 33;
-      });
+      },
+      {
+        when: ({ value }) => baseSchema.safeParse(value).success,
+      }
+    );
+
+    const result = schema.safeParse({
+      foo: 11,
+    });
+    expect(result.success).toEqual(false);
 
-    expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<thirdRefinement>();
+    if (!result.success) {
+      expect(result.error.issues.length).toEqual(1);
+      expect(result.error.issues[0].message).toEqual("Invalid input: expected number, received undefined");
+    }
   });
 });
-*/
+
+describe("type refinement with type guards", () => {
+  test("type guard narrows output type", () => {
+    const schema = z.string().refine((s): s is "a" => s === "a");
+
+    expectTypeOf<z.input<typeof schema>>().toEqualTypeOf<string>();
+    expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<"a">();
+  });
+
+  test("non-type-guard refine does not narrow", () => {
+    const schema = z.string().refine((s) => s.length > 0);
+
+    expectTypeOf<z.input<typeof schema>>().toEqualTypeOf<string>();
+    expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<string>();
+  });
+
+  // TODO: Implement type narrowing for superRefine
+  // test("superRefine - type narrowing", () => {
+  //   type NarrowType = { type: string; age: number };
+  //   const schema = z
+  //     .object({
+  //       type: z.string(),
+  //       age: z.number(),
+  //     })
+  //     .nullable()
+  //     .superRefine((arg, ctx): arg is NarrowType => {
+  //       if (!arg) {
+  //         ctx.addIssue({
+  //           input: arg,
+  //           code: "custom",
+  //           message: "cannot be null",
+  //           fatal: true,
+  //         });
+  //         return false;
+  //       }
+  //       return true;
+  //     });
+  //
+  //   expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<NarrowType>();
+  //
+  //   expect(schema.safeParse({ type: "test", age: 0 }).success).toEqual(true);
+  //   expect(schema.safeParse(null).success).toEqual(false);
+  // });
+});
 
 test("when", () => {
   const schema = z
@@ -431,9 +592,9 @@ test("when", () => {
     })
     .refine(
       (data) => {
-        console.log("running check...");
-        console.log(data);
-        console.log(data.password);
+        // console.log("running check...");
+        // console.log(data);
+        // console.log(data.password);
         return data.password === data.confirmPassword;
       },
       {

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

@@ -19,6 +19,10 @@ test("globalRegistry", () => {
   expect(z.globalRegistry.has(a)).toEqual(false);
 });
 
+test("globalRegistry is singleton and attached to globalThis", () => {
+  expect(z.globalRegistry).toBe((globalThis as any).__zod_globalRegistry);
+});
+
 test("z.registry", () => {
   const fieldRegistry = z.registry<{ name: string; description: string }>();
 
@@ -164,7 +168,7 @@ test("loose examples", () => {
   });
 });
 
-test("function meta witout replacement", () => {
+test("function meta without replacement", () => {
   const myReg = z.registry<{
     defaulter: (arg: string, test: boolean) => number;
   }>();
@@ -202,3 +206,38 @@ test("test .clear()", () => {
   reg.clear();
   expect(reg.has(a)).toEqual(false);
 });
+
+test("re-registering same id silently overwrites", () => {
+  const reg = z.registry<z.core.GlobalMeta>();
+  const a = z.string();
+  const b = z.number();
+
+  reg.add(a, { id: "shared-id" });
+  reg.add(b, { id: "shared-id" });
+
+  // No error thrown, b now owns the id
+  expect(reg._idmap.get("shared-id")).toBe(b);
+});
+
+test("toJSONSchema throws on duplicate id across different schemas", () => {
+  const reg = z.registry<z.core.GlobalMeta>();
+  const a = z.string().register(reg, { id: "duplicate-id" });
+  const b = z.number().register(reg, { id: "duplicate-id" });
+
+  const wrapper = z.object({ a, b });
+
+  expect(() => z.toJSONSchema(wrapper, { metadata: reg })).toThrow(
+    'Duplicate schema id "duplicate-id" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.'
+  );
+});
+
+test("toJSONSchema allows same schema with same id", () => {
+  const reg = z.registry<z.core.GlobalMeta>();
+  const shared = z.string().register(reg, { id: "shared-id" });
+
+  const wrapper = z.object({ a: shared, b: shared });
+
+  // Should not throw - same schema instance used twice
+  const result = z.toJSONSchema(wrapper, { metadata: reg });
+  expect(result.$defs?.["shared-id"]).toBeDefined();
+});

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

@@ -39,7 +39,7 @@ test("valid parse async", async () => {
   expect(result.data!.has("second")).toEqual(true);
   expect(result.data!.has("third")).toEqual(false);
 
-  const asyncResult = await stringSet.safeParse(new Set(["first", "second"]));
+  const asyncResult = stringSet.safeParse(new Set(["first", "second"]));
   expect(asyncResult.success).toEqual(true);
   expect(asyncResult.data!.has("first")).toEqual(true);
   expect(asyncResult.data!.has("second")).toEqual(true);
@@ -83,6 +83,21 @@ test("failing when set is bigger than max() ", () => {
   expect(result.success).toEqual(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error!.issues[0].code).toEqual("too_big");
+  expect(
+    z
+      .set(z.string())
+      .max(1)
+      .safeParse(new Set([1, 2])).error!.issues
+  ).toMatchObject([{ code: "too_big" }]);
+});
+
+test("failing when set does not match size() ", () => {
+  expect(justTwo.safeParse(new Set(["one"])).error!.issues[0].message).toEqual(
+    "Too small: expected set to have exactly 2 items"
+  );
+  expect(justTwo.safeParse(new Set(["one", "two", "three"])).error!.issues[0].message).toEqual(
+    "Too big: expected set to have exactly 2 items"
+  );
 });
 
 test("doesn’t throw when an empty set is given", () => {
@@ -155,7 +170,8 @@ test("min/max", async () => {
     [
       {
         "code": "too_small",
-        "message": "Too small: expected set to have >4 items",
+        "inclusive": true,
+        "message": "Too small: expected set to have >=4 items",
         "minimum": 4,
         "origin": "set",
         "path": [],
@@ -169,8 +185,9 @@ test("min/max", async () => {
     [
       {
         "code": "too_big",
+        "inclusive": true,
         "maximum": 5,
-        "message": "Too big: expected set to have <5 items",
+        "message": "Too big: expected set to have <=5 items",
         "origin": "set",
         "path": [],
       },

package/node_modules/zod/src/v4/classic/tests/standard-schema.test.ts

@@ -55,3 +55,99 @@ test("length checks", async () => {
     }
   `);
 });
+
+test("schemas conform to StandardJSONSchemaV1", async () => {
+  const schema = z.codec(z.string(), z.number(), {
+    decode: (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(),
+  });
+  expect(schema["~standard"].validate).toBeTypeOf("function");
+  expect(await schema["~standard"].validate("42")).toMatchInlineSnapshot(`
+		{
+		  "value": 42,
+		}
+	`);
+  expect(schema["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "string",
+		}
+	`);
+  expect(schema["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "number",
+		}
+	`);
+});
+
+test(".toJSONSchema() returns StandardJSONSchemaV1", async () => {
+  const codec = z.codec(z.string(), z.number(), {
+    decode: (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(),
+  });
+  const result = codec.toJSONSchema();
+  expect(result["~standard"].validate).toBeTypeOf("function");
+  expect(await result["~standard"].validate("42")).toMatchInlineSnapshot(`
+		{
+		  "value": 42,
+		}
+	`);
+  expect(result["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "string",
+		}
+	`);
+  expect(result["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "number",
+		}
+	`);
+});
+
+test("z.toJSONSchema() returns StandardJSONSchemaV1", async () => {
+  const codec = z.codec(z.string(), z.number(), {
+    decode: (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(),
+  });
+  const result = z.toJSONSchema(codec);
+  expect(result["~standard"].validate).toBeTypeOf("function");
+  expect(await result["~standard"].validate("42")).toMatchInlineSnapshot(`
+		{
+		  "value": 42,
+		}
+	`);
+  expect(result["~standard"].jsonSchema.input({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "string",
+		}
+	`);
+  expect(result["~standard"].jsonSchema.output({ target: "draft-2020-12" })).toMatchInlineSnapshot(`
+		{
+		  "$schema": "https://json-schema.org/draft/2020-12/schema",
+		  "type": "number",
+		}
+	`);
+});
+
+test("a failing validate reports the same issues as safeParse, without a ZodError", async () => {
+  const schema = z.object({ name: z.string().min(3), age: z.number().refine(async (n) => n > 0) });
+  const input = { name: "ab", age: -1 };
+  const result = (await schema["~standard"].validate(input)) as { issues: unknown[] };
+  expect(result.issues).toEqual((await schema.safeParseAsync(input)).error!.issues);
+  expect(result).not.toHaveProperty("error");
+  const sync = z.string().min(3)["~standard"].validate("ab") as { issues: unknown[] };
+  expect(sync.issues).toEqual(z.string().min(3).safeParse("ab").error!.issues);
+});
+
+test("a synchronously throwing check rejects through ~standard instead of throwing", async () => {
+  const schema = z.string().refine(() => {
+    throw new Error("boom");
+  });
+  const result = schema["~standard"].validate("abc");
+  expect(result).toBeInstanceOf(Promise);
+  await expect(result as Promise<unknown>).rejects.toThrow("boom");
+});

package/node_modules/zod/src/v4/classic/tests/string-formats.test.ts

@@ -107,3 +107,19 @@ test("z.stringFormat", () => {
     `/\\^\\(\\?:\\\\d\\{14,19\\}\\|\\\\d\\{4\\}\\(\\?: \\\\d\\{3,6\\}\\)\\{2,4\\}\\|\\\\d\\{4\\}\\(\\?:-\\\\d\\{3,6\\}\\)\\{2,4\\}\\)\\$/u`
   );
 });
+
+test("z.hex", () => {
+  const hexSchema = z.hex();
+
+  // Valid hex strings
+  expect(hexSchema.safeParse("").success).toBe(true); // Empty string is valid hex
+  expect(hexSchema.safeParse("123abc").success).toBe(true);
+  expect(hexSchema.safeParse("DEADBEEF").success).toBe(true);
+  expect(hexSchema.safeParse("0123456789abcdefABCDEF").success).toBe(true);
+
+  // Invalid hex strings
+  expect(hexSchema.safeParse("xyz").success).toBe(false);
+  expect(hexSchema.safeParse("123g").success).toBe(false);
+  expect(hexSchema.safeParse("hello world").success).toBe(false);
+  expect(hexSchema.safeParse("123-abc").success).toBe(false);
+});