aws-runtime-bridge 1.9.70 → 1.9.72

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

@@ -0,0 +1,34 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("instanceof", async () => {
+  class Test {}
+  class Subtest extends Test {}
+  abstract class AbstractBar {
+    constructor(public val: string) {}
+  }
+  class Bar extends AbstractBar {}
+
+  const TestSchema = z.instanceof(Test);
+  const SubtestSchema = z.instanceof(Subtest);
+  const AbstractSchema = z.instanceof(AbstractBar);
+  const BarSchema = z.instanceof(Bar);
+
+  TestSchema.parse(new Test());
+  TestSchema.parse(new Subtest());
+  SubtestSchema.parse(new Subtest());
+  AbstractSchema.parse(new Bar("asdf"));
+  const bar = BarSchema.parse(new Bar("asdf"));
+  expect(bar.val).toEqual("asdf");
+
+  await expect(() => SubtestSchema.parse(new Test())).toThrow();
+  await expect(() => TestSchema.parse(12)).toThrow();
+
+  expectTypeOf<Test>().toEqualTypeOf<z.infer<typeof TestSchema>>();
+});
+
+test("instanceof fatal", () => {
+  const schema = z.instanceof(Date).refine((d) => d.toString());
+  const res = schema.safeParse(null);
+  expect(res.success).toBe(false);
+});

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

@@ -0,0 +1,171 @@
+import { expect, expectTypeOf, test } from "vitest";
+import type { util } from "zod/v4/core";
+
+import * as z from "zod/v4";
+
+test("object intersection", () => {
+  const A = z.object({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string } & { b: string }>();
+  const data = { a: "foo", b: "foo" };
+  expect(C.parse(data)).toEqual(data);
+  expect(() => C.parse({ a: "foo" })).toThrow();
+});
+
+test("object intersection: loose", () => {
+  const A = z.looseObject({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string; [x: string]: unknown } & { b: string }>();
+  const data = { a: "foo", b: "foo", c: "extra" };
+  expect(C.parse(data)).toEqual(data);
+  expect(() => C.parse({ a: "foo" })).toThrow();
+});
+
+test("object intersection: strict", () => {
+  const A = z.strictObject({ a: z.string() });
+  const B = z.object({ b: z.string() });
+
+  const C = z.intersection(A, B); // BaseC.merge(HasID);
+  type C = z.infer<typeof C>;
+  expectTypeOf<C>().toEqualTypeOf<{ a: string } & { b: string }>();
+  const data = { a: "foo", b: "foo", c: "extra" };
+
+  const result = C.safeParse(data);
+  expect(result.success).toEqual(false);
+});
+
+test("deep intersection", () => {
+  const Animal = z.object({
+    properties: z.object({
+      is_animal: z.boolean(),
+    }),
+  });
+  const Cat = z.intersection(
+    z.object({
+      properties: z.object({
+        jumped: z.boolean(),
+      }),
+    }),
+    Animal
+  );
+
+  type Cat = util.Flatten<z.infer<typeof Cat>>;
+  expectTypeOf<Cat>().toEqualTypeOf<{ properties: { is_animal: boolean } & { jumped: boolean } }>();
+  const a = Cat.safeParse({ properties: { is_animal: true, jumped: true } });
+  expect(a.data!.properties).toEqual({ is_animal: true, jumped: true });
+});
+
+test("deep intersection of arrays", async () => {
+  const Author = z.object({
+    posts: z.array(
+      z.object({
+        post_id: z.number(),
+      })
+    ),
+  });
+  const Registry = z.intersection(
+    Author,
+    z.object({
+      posts: z.array(
+        z.object({
+          title: z.string(),
+        })
+      ),
+    })
+  );
+
+  const posts = [
+    { post_id: 1, title: "Novels" },
+    { post_id: 2, title: "Fairy tales" },
+  ];
+  const cat = Registry.parse({ posts });
+  expect(cat.posts).toEqual(posts);
+  const asyncCat = await Registry.parseAsync({ posts });
+  expect(asyncCat.posts).toEqual(posts);
+});
+
+test("invalid intersection types", async () => {
+  const numberIntersection = z.intersection(
+    z.number(),
+    z.number().transform((x) => x + 1)
+  );
+
+  expect(() => {
+    numberIntersection.parse(1234);
+  }).toThrowErrorMatchingInlineSnapshot(`[Error: Unmergable intersection. Error path: []]`);
+});
+
+test("invalid array merge (incompatible lengths)", async () => {
+  const stringArrInt = z.intersection(
+    z.string().array(),
+    z
+      .string()
+      .array()
+      .transform((val) => [...val, "asdf"])
+  );
+
+  expect(() => stringArrInt.safeParse(["asdf", "qwer"])).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: []]`
+  );
+});
+
+test("invalid array merge (incompatible elements)", async () => {
+  const stringArrInt = z.intersection(
+    z.string().array(),
+    z
+      .string()
+      .array()
+      .transform((val) => [...val.slice(0, -1), "asdf"])
+  );
+
+  expect(() => stringArrInt.safeParse(["asdf", "qwer"])).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: [1]]`
+  );
+});
+
+test("invalid object merge", async () => {
+  const Cat = z.object({
+    phrase: z.string().transform((val) => `${val} Meow`),
+  });
+  const Dog = z.object({
+    phrase: z.string().transform((val) => `${val} Woof`),
+  });
+  const CatDog = z.intersection(Cat, Dog);
+
+  expect(() => CatDog.parse({ phrase: "Hello, my name is CatDog." })).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: ["phrase"]]`
+  );
+});
+
+test("invalid deep merge of object and array combination", async () => {
+  const University = z.object({
+    students: z.array(
+      z.object({
+        name: z.string().transform((val) => `Student name: ${val}`),
+      })
+    ),
+  });
+  const Registry = z.intersection(
+    University,
+    z.object({
+      students: z.array(
+        z.object({
+          name: z.string(),
+          surname: z.string(),
+        })
+      ),
+    })
+  );
+
+  const students = [{ name: "John", surname: "Doe" }];
+
+  expect(() => Registry.parse({ students })).toThrowErrorMatchingInlineSnapshot(
+    `[Error: Unmergable intersection. Error path: ["students",0,"name"]]`
+  );
+});

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

@@ -0,0 +1,108 @@
+import { test } from "vitest";
+// import * as z from "zod/v4";
+
+test(() => {});
+// test("overload types", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   const schema2 = z.string().json(z.number());
+//   util.assertEqual<typeof schema2, z.ZodPipe<z.ZodTransform<any, string>, z.ZodNumber>>(true);
+//   const r2 = schema2.parse("12");
+//   util.assertEqual<number, typeof r2>(true);
+// });
+// test("parse string to json", async () => {
+//   const Env = z.object({
+//     myJsonConfig: z.string().jsonString(z.object({ foo: z.number() })),
+//     someOtherValue: z.string(),
+//   });
+
+//   expect(
+//     Env.parse({
+//       myJsonConfig: '{ "foo": 123 }',
+//       someOtherValue: "abc",
+//     })
+//   ).toEqual({
+//     myJsonConfig: { foo: 123 },
+//     someOtherValue: "abc",
+//   });
+
+//   const invalidValues = Env.safeParse({
+//     myJsonConfig: '{"foo": "not a number!"}',
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidValues))).toEqual({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_type",
+//           expected: "number",
+//           input: "not a number!",
+//           received: "string",
+//           path: ["myJsonConfig", "foo"],
+//           message: "Expected number, received string",
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+
+//   const invalidJsonSyntax = Env.safeParse({
+//     myJsonConfig: "This is not valid json",
+//     someOtherValue: null,
+//   });
+//   expect(JSON.parse(JSON.stringify(invalidJsonSyntax))).toMatchObject({
+//     success: false,
+//     error: {
+//       name: "ZodError",
+//       issues: [
+//         {
+//           code: "invalid_string",
+//           input: {
+//             _def: {
+//               catchall: {
+//                 _def: {
+//                   typeName: "ZodNever",
+//                 },
+//               },
+//               typeName: "ZodObject",
+//               unknownKeys: "strip",
+//             },
+//           },
+//           validation: "json",
+//           message: "Invalid json",
+//           path: ["myJsonConfig"],
+//         },
+//         {
+//           code: "invalid_type",
+//           expected: "string",
+//           input: null,
+//           received: "null",
+//           path: ["someOtherValue"],
+//           message: "Expected string, received null",
+//         },
+//       ],
+//     },
+//   });
+// });
+
+// test("no argument", () => {
+//   const schema = z.string().json();
+//   util.assertEqual<typeof schema, z.ZodString>(true);
+//   z.string().json().parse(`{}`);
+//   z.string().json().parse(`null`);
+//   z.string().json().parse(`12`);
+//   z.string().json().parse(`{ "test": "test"}`);
+//   expect(() => z.string().json().parse(`asdf`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": undefined }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ "test": 12n }`)).toThrow();
+//   expect(() => z.string().json().parse(`{ test: "test" }`)).toThrow();
+// });

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

@@ -0,0 +1,196 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+const stringMap = z.map(z.string(), z.string());
+type stringMap = z.infer<typeof stringMap>;
+
+test("type inference", () => {
+  expectTypeOf<stringMap>().toEqualTypeOf<Map<string, string>>();
+});
+
+test("valid parse", () => {
+  const result = stringMap.safeParse(
+    new Map([
+      ["first", "foo"],
+      ["second", "bar"],
+    ])
+  );
+  expect(result.success).toEqual(true);
+  expect(result.data).toMatchInlineSnapshot(`
+    Map {
+      "first" => "foo",
+      "second" => "bar",
+    }
+  `);
+});
+
+test("valid parse async", async () => {
+  const asyncMap = z.map(
+    z.string().refine(async () => false, "bad key"),
+    z.string().refine(async () => false, "bad value")
+  );
+  const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
+  expect(result.success).toEqual(false);
+  expect(result.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad key"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad value"
+      }
+    ]]
+  `);
+});
+
+test("throws when a Set is given", () => {
+  const result = stringMap.safeParse(new Set([]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual("invalid_type");
+  }
+});
+
+test("throws when the given map has invalid key and invalid input", () => {
+  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error).toMatchInlineSnapshot(`
+      [ZodError: [
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received number"
+        },
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received symbol"
+        }
+      ]]
+    `);
+  }
+});
+
+test("throws when the given map has multiple invalid entries", () => {
+  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+
+  const result = stringMap.safeParse(
+    new Map([
+      [1, "foo"],
+      ["bar", 2],
+    ] as [any, any][]) as Map<any, any>
+  );
+
+  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [
+            1,
+          ],
+        },
+        {
+          "code": "invalid_type",
+          "expected": "string",
+          "message": "Invalid input: expected string, received number",
+          "path": [
+            "bar",
+          ],
+        },
+      ]
+    `);
+  }
+});
+
+test("dirty", async () => {
+  const map = z.map(
+    z.string().refine((val) => val === val.toUpperCase(), {
+      message: "Keys must be uppercase",
+    }),
+    z.string()
+  );
+  const result = await map.spa(
+    new Map([
+      ["first", "foo"],
+      ["second", "bar"],
+    ])
+  );
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error).toMatchInlineSnapshot(`
+      [ZodError: [
+        {
+          "code": "custom",
+          "path": [
+            "first"
+          ],
+          "message": "Keys must be uppercase"
+        },
+        {
+          "code": "custom",
+          "path": [
+            "second"
+          ],
+          "message": "Keys must be uppercase"
+        }
+      ]]
+    `);
+  }
+});
+
+test("map with object keys", () => {
+  const map = z.map(
+    z.object({
+      name: z.string(),
+      age: z.number(),
+    }),
+    z.string()
+  );
+  const data = new Map([
+    [{ name: "John", age: 30 }, "foo"],
+    [{ name: "Jane", age: 25 }, "bar"],
+  ]);
+  const result = map.safeParse(data);
+  expect(result.success).toEqual(true);
+  expect(result.data!).toEqual(data);
+
+  const badData = new Map([["bad", "foo"]]);
+  const badResult = map.safeParse(badData);
+  expect(badResult.success).toEqual(false);
+  expect(badResult.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "expected": "object",
+        "code": "invalid_type",
+        "path": [
+          "bad"
+        ],
+        "message": "Invalid input: expected object, received string"
+      }
+    ]]
+  `);
+});