fullstacked 0.12.0-1273 → 0.12.0-1291

package/fullstacked_modules/zod/src/v4/classic/tests/string.test.ts

@@ -318,83 +318,6 @@ test("url validations", () => {
   expect(() => url.parse("https://")).toThrow();
 });
 
-test("url preserves original input", () => {
-  const url = z.string().url();
-
-  // Test the specific case from the user report
-  const input = "https://example.com?key=NUXOmHqWNVTapJkJJHw8BfD155AuqhH_qju_5fNmQ4ZHV7u8";
-  const output = url.parse(input);
-  expect(output).toBe(input); // Should preserve the original input exactly
-
-  // Test other cases where URL constructor would normalize
-  expect(url.parse("https://example.com?foo=bar")).toBe("https://example.com?foo=bar");
-  expect(url.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
-  expect(url.parse("https://sub.example.com?param=value&other=data")).toBe(
-    "https://sub.example.com?param=value&other=data"
-  );
-
-  // Test cases with trailing slashes are preserved
-  expect(url.parse("https://example.com/")).toBe("https://example.com/");
-  expect(url.parse("https://example.com/path/")).toBe("https://example.com/path/");
-
-  // Test cases with paths and query parameters
-  expect(url.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
-});
-
-test("url trims whitespace", () => {
-  const url = z.string().url();
-
-  // Test trimming whitespace from URLs
-  expect(url.parse("  https://example.com  ")).toBe("https://example.com");
-  expect(url.parse("  https://example.com/path?query=param  ")).toBe("https://example.com/path?query=param");
-  expect(url.parse("\t\nhttps://example.com\t\n")).toBe("https://example.com");
-  expect(url.parse("   https://example.com?key=value   ")).toBe("https://example.com?key=value");
-
-  // Test that URLs without extra whitespace are unchanged
-  expect(url.parse("https://example.com")).toBe("https://example.com");
-  expect(url.parse("https://example.com/path")).toBe("https://example.com/path");
-});
-
-test("url normalize flag", () => {
-  const normalizeUrl = z.url({ normalize: true });
-  const preserveUrl = z.url(); // normalize: false/undefined by default
-
-  // Test that normalize flag causes URL normalization
-  expect(normalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
-  expect(normalizeUrl.parse("http://example.com?test=123")).toBe("http://example.com/?test=123");
-
-  // Test with already normalized URLs
-  expect(normalizeUrl.parse("https://example.com/")).toBe("https://example.com/");
-  expect(normalizeUrl.parse("https://example.com/path?query=param")).toBe("https://example.com/path?query=param");
-
-  // Test complex URLs with normalization
-  expect(normalizeUrl.parse("https://example.com/../?key=value")).toBe("https://example.com/?key=value");
-  expect(normalizeUrl.parse("https://example.com/./path?key=value")).toBe("https://example.com/path?key=value");
-
-  // Compare with non-normalize behavior
-  expect(preserveUrl.parse("https://example.com?key=value")).toBe("https://example.com?key=value");
-  expect(preserveUrl.parse("http://example.com?test=123")).toBe("http://example.com?test=123");
-
-  // Test trimming with normalize
-  expect(normalizeUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com/?key=value");
-  expect(preserveUrl.parse("  https://example.com?key=value  ")).toBe("https://example.com?key=value");
-});
-
-test("url normalize with hostname and protocol constraints", () => {
-  const constrainedNormalizeUrl = z.url({
-    normalize: true,
-    protocol: /^https$/,
-    hostname: /^example\.com$/,
-  });
-
-  // Test that normalization works with constraints
-  expect(constrainedNormalizeUrl.parse("https://example.com?key=value")).toBe("https://example.com/?key=value");
-
-  // Test that constraints are still enforced
-  expect(() => constrainedNormalizeUrl.parse("http://example.com?key=value")).toThrow();
-  expect(() => constrainedNormalizeUrl.parse("https://other.com?key=value")).toThrow();
-});
-
 test("httpurl", () => {
   const httpUrl = z.url({
     protocol: /^https?$/,
@@ -541,8 +464,8 @@ test(`bad uuid`, () => {
     "9491d710-3185-0e06-bea0-6a2f275345e0",
     "9491d710-3185-5e06-0ea0-6a2f275345e0",
     "d89e7b01-7598-ed11-9d7a-0022489382fd", // new sequential id
-    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
-    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
+    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
+    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
     "invalid uuid",
     "9491d710-3185-4e06-bea0-6a2f275345e0X",
     "ffffffff-ffff-ffff-ffff-ffffffffffff",
@@ -558,8 +481,8 @@ test("good guid", () => {
   for (const goodGuid of [
     "9491d710-3185-4e06-bea0-6a2f275345e0",
     "d89e7b01-7598-ed11-9d7a-0022489382fd", // new sequential id
-    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 9562/4122: Reserved, NCS backward compatibility
-    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 9562/4122: Reserved, Microsoft Corporation backward compatibility
+    "b3ce60f8-e8b9-40f5-1150-172ede56ff74", // Variant 0 - RFC 4122: Reserved, NCS backward compatibility
+    "92e76bf9-28b3-4730-cd7f-cb6bc51f8c09", // Variant 2 - RFC 4122: Reserved, Microsoft Corporation backward compatibility
     "00000000-0000-0000-0000-000000000000",
     "ffffffff-ffff-ffff-ffff-ffffffffffff",
   ]) {
@@ -956,41 +879,3 @@ test("E.164 validation", () => {
   expect(validE164Numbers.every((number) => e164Number.safeParse(number).success)).toBe(true);
   expect(invalidE164Numbers.every((number) => e164Number.safeParse(number).success === false)).toBe(true);
 });
-
-test("hostname", () => {
-  const hostname = z.hostname();
-
-  // Valid hostnames
-  hostname.parse("localhost");
-  hostname.parse("example.com");
-  hostname.parse("sub.example.com");
-  hostname.parse("a-b-c.example.com");
-  hostname.parse("123.example.com");
-  hostname.parse("example-123.com");
-  hostname.parse("example-123.1234");
-  hostname.parse("developer.mozilla.org");
-  hostname.parse("hello.world.example.com");
-  hostname.parse("www.google.com");
-  hostname.parse("192.168.1.1");
-  hostname.parse("xn--d1acj3b.com");
-  hostname.parse("xn--d1acj3b.org");
-  hostname.parse("xn--d1acj3b");
-
-  // Invalid hostnames
-  expect(() => hostname.parse("")).toThrow();
-  expect(() => hostname.parse("example..com")).toThrow();
-  expect(() => hostname.parse("example-.com")).toThrow();
-  expect(() => hostname.parse("-example.com")).toThrow();
-  expect(() => hostname.parse("example.com-")).toThrow();
-  expect(() => hostname.parse("example_com")).toThrow();
-  expect(() => hostname.parse("example.com:8080")).toThrow();
-  expect(() => hostname.parse("http://example.com")).toThrow();
-  expect(() => hostname.parse("ht!tp://invalid.com")).toThrow();
-
-  expect(() => hostname.parse("xn--d1acj3b..com")).toThrow();
-  expect(() => hostname.parse("ex@mple.com")).toThrow();
-  expect(() => hostname.parse("[2001:db8::zzzz]")).toThrow();
-  expect(() => hostname.parse("exa mple.com")).toThrow();
-  expect(() => hostname.parse("-example.com")).toThrow();
-  expect(() => hostname.parse("example..com")).toThrow();
-});

package/fullstacked_modules/zod/src/v4/classic/tests/template-literal.test.ts

@@ -6,7 +6,6 @@ const hello = z.templateLiteral(["hello"]);
 const world = z.templateLiteral(["", z.literal("world")]);
 const one = z.templateLiteral([1]);
 const two = z.templateLiteral(["", z.literal(2)]);
-const onePointOne = z.templateLiteral([z.literal(1.1)]);
 const truee = z.templateLiteral([true]);
 const anotherTrue = z.templateLiteral(["", z.literal(true)]);
 const falsee = z.templateLiteral([false]);
@@ -290,7 +289,6 @@ test("template literal parsing - success - basic cases", () => {
   world.parse("world");
   one.parse("1");
   two.parse("2");
-  onePointOne.parse("1.1");
   truee.parse("true");
   anotherTrue.parse("true");
   falsee.parse("false");
@@ -383,7 +381,6 @@ test("template literal parsing - failure - basic cases", () => {
   expect(() => one.parse("2")).toThrow();
   expect(() => one.parse("12")).toThrow();
   expect(() => one.parse("21")).toThrow();
-  expect(() => onePointOne.parse("1s1")).toThrow();
   expect(() => two.parse("1")).toThrow();
   expect(() => two.parse("21")).toThrow();
   expect(() => two.parse("12")).toThrow();

package/fullstacked_modules/zod/src/v4/classic/tests/to-json-schema.test.ts

@@ -539,19 +539,6 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("number constraints draft-4", () => {
-    expect(z.toJSONSchema(z.number().gt(5).lt(10), { target: "draft-4" })).toMatchInlineSnapshot(`
-      {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "exclusiveMaximum": true,
-        "exclusiveMinimum": true,
-        "maximum": 10,
-        "minimum": 5,
-        "type": "number",
-      }
-    `);
-  });
-
   test("arrays", () => {
     expect(z.toJSONSchema(z.array(z.string()))).toMatchInlineSnapshot(`
       {
@@ -758,19 +745,6 @@ describe("toJSONSchema", () => {
     `);
   });
 
-  test("literal draft-4", () => {
-    const a = z.literal("hello");
-    expect(z.toJSONSchema(a, { target: "draft-4" })).toMatchInlineSnapshot(`
-      {
-        "$schema": "http://json-schema.org/draft-04/schema#",
-        "enum": [
-          "hello",
-        ],
-        "type": "string",
-      }
-    `);
-  });
-
   // pipe
   test("pipe", () => {
     const schema = z
@@ -1978,7 +1952,6 @@ test("input type", () => {
       "required": [
         "a",
         "d",
-        "f",
         "g",
       ],
       "type": "object",

package/fullstacked_modules/zod/src/v4/classic/tests/transform.test.ts

@@ -248,107 +248,3 @@ test("async short circuit on dirty", async () => {
     ]]
   `);
 });
-
-test("do not continue by default", () => {
-  const A = z
-    .string()
-    .transform((val, ctx) => {
-      ctx.addIssue({
-        code: "custom",
-        message: `custom error`,
-      });
-      ctx.addIssue({
-        code: "custom",
-        message: `custom error`,
-      });
-      return val;
-    })
-    .pipe(z.number() as any);
-  expect(A.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      },
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  const B = z
-    .string()
-    .transform((val, ctx) => {
-      ctx.issues.push({
-        code: "custom",
-        message: `custom error`,
-        input: val,
-      });
-      ctx.issues.push({
-        code: "custom",
-        message: `custom error`,
-        input: val,
-      });
-      return val;
-    })
-    .pipe(z.number() as any);
-  expect(B.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      },
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-
-  const C = z
-    .string()
-    .transform((val, ctx) => {
-      ctx.issues.push({
-        code: "custom",
-        message: `custom error`,
-        input: val,
-        continue: true,
-      });
-      ctx.issues.push({
-        code: "custom",
-        message: `custom error`,
-        input: val,
-        continue: true,
-      });
-      return val;
-    })
-    .pipe(z.number() as any);
-  expect(C.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      },
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});

package/fullstacked_modules/zod/src/v4/classic/tests/tuple.test.ts

@@ -28,9 +28,9 @@ test("successful validation", () => {
   expect(r2.error!).toMatchInlineSnapshot(`
     [ZodError: [
       {
+        "origin": "array",
         "code": "too_big",
         "maximum": 2,
-        "origin": "array",
         "path": [],
         "message": "Too big: expected array to have <2 items"
       }
@@ -80,9 +80,9 @@ test("async validation", async () => {
   expect(r2.error!).toMatchInlineSnapshot(`
     [ZodError: [
       {
+        "origin": "array",
         "code": "too_big",
         "maximum": 2,
-        "origin": "array",
         "path": [],
         "message": "Too big: expected array to have <2 items"
       }

package/fullstacked_modules/zod/src/v4/classic/tests/union.test.ts

@@ -27,7 +27,7 @@ test("return valid over invalid", () => {
 });
 
 test("return errors from both union arms", () => {
-  const result = z.union([z.number(), z.boolean()]).safeParse("a");
+  const result = z.union([z.number(), z.string().refine(() => false)]).safeParse("a");
   expect(result.success).toEqual(false);
   if (!result.success) {
     expect(result.error.issues).toMatchInlineSnapshot(`
@@ -45,9 +45,8 @@ test("return errors from both union arms", () => {
             ],
             [
               {
-                "code": "invalid_type",
-                "expected": "boolean",
-                "message": "Invalid input: expected boolean, received string",
+                "code": "custom",
+                "message": "Invalid input",
                 "path": [],
               },
             ],
@@ -93,89 +92,3 @@ test("union values", () => {
     }
   `);
 });
-
-test("non-aborted errors", () => {
-  const zItemTest = z.union([
-    z.object({
-      date: z.number(),
-      startDate: z.optional(z.null()),
-      endDate: z.optional(z.null()),
-    }),
-    z
-      .object({
-        date: z.optional(z.null()),
-        startDate: z.number(),
-        endDate: z.number(),
-      })
-      .refine((data) => data.startDate !== data.endDate, {
-        error: "startDate and endDate must be different",
-        path: ["endDate"],
-      }),
-  ]);
-
-  const res = zItemTest.safeParse({
-    date: null,
-    startDate: 1,
-    endDate: 1,
-  });
-
-  expect(res).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "path": [
-          "endDate"
-        ],
-        "message": "startDate and endDate must be different"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("surface continuable errors only if they exist", () => {
-  const schema = z.union([z.boolean(), z.uuid(), z.jwt()]);
-
-  expect(schema.safeParse("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "invalid_union",
-        "errors": [
-          [
-            {
-              "expected": "boolean",
-              "code": "invalid_type",
-              "path": [],
-              "message": "Invalid input: expected boolean, received string"
-            }
-          ],
-          [
-            {
-              "origin": "string",
-              "code": "invalid_format",
-              "format": "uuid",
-              "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)$/",
-              "path": [],
-              "message": "Invalid UUID"
-            }
-          ],
-          [
-            {
-              "code": "invalid_format",
-              "format": "jwt",
-              "path": [],
-              "message": "Invalid JWT"
-            }
-          ]
-        ],
-        "path": [],
-        "message": "Invalid input"
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});