@suveren/gateway 0.39.0 → 0.40.0

package/node_modules/zod/src/v4/mini/tests/apply.test.ts

@@ -0,0 +1,57 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("basic apply (number)", () => {
+  const setCommonNumberChecks = <T extends z.ZodMiniNumber>(schema: T) => {
+    return schema.check(z.minimum(0), z.maximum(100));
+  };
+
+  const schema = z.nullable(z.number().apply(setCommonNumberChecks));
+
+  expect(() => z.parse(schema, -1)).toThrowError();
+  expect(() => z.parse(schema, 101)).toThrowError();
+  expect(z.parse(schema, 0)).toBe(0);
+  expect(z.parse(schema, null)).toBe(null);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
+});
+
+test("The callback's return value becomes the apply's return value.", () => {
+  const symbol = Symbol();
+  const result = z.number().apply(() => symbol);
+
+  expect(result).toBe(symbol);
+  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
+});
+
+test("apply forwards extra args to the callback", () => {
+  const calls: unknown[] = [];
+  const capture = (schema: z.ZodMiniString, ...args: unknown[]) => {
+    calls.push(schema, ...args);
+    return schema;
+  };
+
+  const schema = z.string();
+  const result = schema.apply(capture, "id", 42);
+
+  expect(calls[0]).toBe(schema);
+  expect(calls[1]).toBe("id");
+  expect(calls[2]).toBe(42);
+  expect(z.parse(result, "value")).toBe("value");
+  expectTypeOf<z.infer<typeof result>>().toEqualTypeOf<string>();
+});
+
+test("apply type-checks the extra args", () => {
+  const withMin = (schema: z.ZodMiniString, n: number) => schema.check(z.minLength(n));
+
+  expect(z.parse(z.string().apply(withMin, 3), "abcd")).toBe("abcd");
+  expectTypeOf(
+    z.number().apply<z.ZodMiniNumber>((schema) => schema.check(z.minimum(0)))
+  ).toEqualTypeOf<z.ZodMiniNumber>();
+
+  // @ts-expect-error wrong arg type
+  z.string().apply(withMin, "3");
+  // @ts-expect-error missing arg
+  z.string().apply(withMin);
+  // @ts-expect-error extra arg for a single-parameter callback
+  z.string().apply((schema: z.ZodMiniString) => schema, 3);
+});

package/node_modules/zod/src/v4/mini/tests/assignability.test.ts

@@ -1,6 +1,6 @@
-import { test } from "vitest";
+import { expectTypeOf, test } from "vitest";
 
-import * as z from "zod/v4-mini";
+import * as z from "zod/mini";
 
 test("assignability", () => {
   // $ZodString
@@ -116,6 +116,67 @@ test("assignability", () => {
   z.file() satisfies z.core.$ZodFile;
 });
 
+test("toZod", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.nullable(z.string()),
+  });
+  const Company = z.toZod<Company>()(CompanySchema);
+
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = z.core.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toZod<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  const Transformed = z.toZod<{ count: number }>()(
+    z.object({
+      count: z.pipe(
+        z.string(),
+        z.transform((value) => value.length)
+      ),
+    })
+  );
+  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
+  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
+
+  z.toZod<Company>()(
+    // @ts-expect-error missing optional keys still fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error extra keys fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+      extra: z.string(),
+    })
+  );
+
+  z.toZod<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+    })
+  );
+});
+
 test("assignability with type narrowing", () => {
   type _RefinedSchema<T extends z.ZodMiniType<object> | z.ZodMiniUnion> = T extends z.ZodMiniUnion
     ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.

package/node_modules/zod/src/v4/mini/tests/brand.test.ts

@@ -49,3 +49,46 @@ test("branded types", () => {
   // @ts-expect-error
   doStuff({ name: "hello there!" });
 });
+
+test("brand direction: out (default)", () => {
+  const schema = z.string().brand<"A">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded (default behavior)
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: out (explicit)", () => {
+  const schema = z.string().brand<"A", "out">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: in", () => {
+  const schema = z.string().brand<"A", "in">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // input is branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  // output is NOT branded
+  expectTypeOf<Output>().toEqualTypeOf<string>();
+});
+
+test("brand direction: inout", () => {
+  const schema = z.string().brand<"A", "inout">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // both are branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+});

package/node_modules/zod/src/v4/mini/tests/checks.test.ts

@@ -41,6 +41,14 @@ test("z.gte", () => {
   expect(z.safeParse(a, 9).success).toEqual(false);
 });
 
+test("z.gte/z.lte origin on a date schema with a numeric bound", () => {
+  const bound = new Date(Date.UTC(2022, 10, 5)).getTime();
+  const tooSmall = z.safeParse(z.date().check(z.gte(bound)), new Date(Date.UTC(2022, 10, 4)));
+  const tooBig = z.safeParse(z.date().check(z.lte(bound)), new Date(Date.UTC(2022, 10, 6)));
+  expect(tooSmall.error!.issues[0]).toMatchObject({ code: "too_small", origin: "date" });
+  expect(tooBig.error!.issues[0]).toMatchObject({ code: "too_big", origin: "date" });
+});
+
 // min;
 test("z.min", () => {
   const a = z.number().check(z.minimum(10));
@@ -132,6 +140,12 @@ test("z.overwrite", () => {
 // toUpperCase;
 // property
 
+test("z.properties", () => {
+  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:"), hostname: z.string() }));
+  expect(z.safeParse(a, new URL("https://example.com")).success).toEqual(true);
+  expect(z.safeParse(a, new URL("http://example.com")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+});
+
 test("abort early", () => {
   const schema = z.string().check(
     z.refine((val) => val.length > 1),