@suveren/gateway 0.39.0 → 0.41.0

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

@@ -40,7 +40,7 @@ test("continuability", () => {
         "message": "Invalid email address",
         "origin": "string",
         "path": [],
-        "pattern": "/^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
+        "pattern": "/^(?:[A-Za-z0-9_'+\\-]+\\.)*[A-Za-z0-9_'+\\-]*[A-Za-z0-9_+-]@(?:[A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$/",
       },
       {
         "code": "custom",
@@ -62,7 +62,7 @@ test("continuability", () => {
         "message": "Invalid UUID",
         "origin": "string",
         "path": [],
-        "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/",
+        "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/",
       },
       {
         "code": "custom",
@@ -195,6 +195,28 @@ test("continuability", () => {
       },
     ]
   `);
+  expect(
+    z
+      .mac()
+      .refine(() => false)
+      .safeParse("invalid_value").error!.issues
+  ).toMatchInlineSnapshot(`
+    [
+      {
+        "code": "invalid_format",
+        "format": "mac",
+        "message": "Invalid MAC address",
+        "origin": "string",
+        "path": [],
+        "pattern": "/^(?:[0-9A-F]{2}:){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}:){5}[0-9a-f]{2}$/",
+      },
+      {
+        "code": "custom",
+        "message": "Invalid input",
+        "path": [],
+      },
+    ]
+  `);
   expect(
     z
       .emoji()
@@ -208,7 +230,7 @@ test("continuability", () => {
         "message": "Invalid emoji",
         "origin": "string",
         "path": [],
-        "pattern": "/^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$/u",
+        "pattern": "/^(?=[\\s\\S]*[\\p{Extended_Pictographic}\\p{Regional_Indicator}\\u20E3])[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$/u",
       },
       {
         "code": "custom",
@@ -252,7 +274,7 @@ test("continuability", () => {
         "message": "Invalid cuid",
         "origin": "string",
         "path": [],
-        "pattern": "/^[cC][^\\s-]{8,}$/",
+        "pattern": "/^[cC][0-9a-z]{6,}$/",
       },
       {
         "code": "custom",
@@ -296,7 +318,7 @@ test("continuability", () => {
         "message": "Invalid ULID",
         "origin": "string",
         "path": [],
-        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
+        "pattern": "/^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/",
       },
       {
         "code": "custom",

package/node_modules/zod/src/v4/classic/tests/credit-card.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "vitest";
+import * as z from "zod";
+
+describe("z.creditCard", () => {
+  // Luhn-valid PANs. The last four are the schemes an issuer allowlist would turn away — validation is shape plus Luhn only, so the BIN is never consulted.
+  const valid: [string, string][] = [
+    ["Visa", "4111111111111111"],
+    ["Visa (13)", "4007000000027"],
+    ["Mastercard", "5555555555554444"],
+    ["AmEx", "378282246310005"],
+    ["Discover", "6011111111111117"],
+    ["JCB", "3530111333300000"],
+    ["Diners Club", "30569309025904"],
+    ["UnionPay", "6200000000000005"],
+    ["Mir", "2200000000000004"],
+    ["Elo", "6362000000000009"],
+    ["Discover 644-649", "6450000000000002"],
+    ["Troy", "9792000000000003"],
+  ];
+
+  test.each(valid)("accepts %s", (_label, n) => {
+    expect(z.creditCard().parse(n)).toBe(n);
+  });
+
+  test("accepts single space or hyphen separators", () => {
+    expect(z.creditCard().parse("4111 1111 1111 1111")).toBe("4111 1111 1111 1111");
+    expect(z.creditCard().parse("4111-1111-1111-1111")).toBe("4111-1111-1111-1111");
+  });
+
+  test("rejects other separator shapes", () => {
+    for (const n of ["4111  1111 1111 1111", " 4111111111111111", "4111111111111111 ", "4111.1111.1111.1111"]) {
+      expect(() => z.creditCard().parse(n)).toThrow();
+    }
+  });
+
+  test("accepts the 12- and 19-digit length bounds", () => {
+    expect(z.creditCard().parse("400000000002")).toBe("400000000002");
+    expect(z.creditCard().parse("6250000000000000005")).toBe("6250000000000000005");
+  });
+
+  test("rejects Luhn-valid input outside 12-19 digits", () => {
+    expect(() => z.creditCard().parse("40000000006")).toThrow();
+    expect(() => z.creditCard().parse("40000000000000000002")).toThrow();
+  });
+
+  test("rejects when Luhn fails (right shape, wrong checksum)", () => {
+    expect(() => z.creditCard().parse("4111111111111112")).toThrow();
+  });
+
+  test("rejects non-digit input", () => {
+    expect(() => z.creditCard().parse("not-a-card")).toThrow();
+    expect(() => z.creditCard().parse("")).toThrow();
+  });
+
+  test("carries the shape regex as its JSON Schema pattern", () => {
+    // Luhn is not expressible as a pattern, so `pattern` covers length and separators only.
+    expect(z.toJSONSchema(z.creditCard())).toMatchObject({
+      format: "credit_card",
+      pattern: z.regexes.creditCard.source,
+    });
+  });
+
+  test("round-trips through JSON Schema with the checksum intact", () => {
+    const schema = z.fromJSONSchema(z.toJSONSchema(z.creditCard()));
+    expect(schema.safeParse("4111111111111111").success).toBe(true);
+    expect(schema.safeParse("4111111111111112").success).toBe(false);
+  });
+
+  test("error message references credit card", () => {
+    const result = z.creditCard().safeParse("not-a-card");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]?.message).toMatch(/credit card/i);
+    }
+  });
+});