fullstacked 0.12.0-1272 → 0.12.0-1290

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,
-    }
-  `);
-});