@guru-ai-product/ai-product-kit 0.2.251112183752 → 0.2.251113155253

package/mcp/node_modules/zod/src/v3/tests/readonly.test.ts

@@ -0,0 +1,194 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+enum testEnum {
+  A = 0,
+  B = 1,
+}
+
+const schemas = [
+  z.string().readonly(),
+  z.number().readonly(),
+  z.nan().readonly(),
+  z.bigint().readonly(),
+  z.boolean().readonly(),
+  z.date().readonly(),
+  z.undefined().readonly(),
+  z.null().readonly(),
+  z.any().readonly(),
+  z.unknown().readonly(),
+  z.void().readonly(),
+  z.function().args(z.string(), z.number()).readonly(),
+
+  z.array(z.string()).readonly(),
+  z.tuple([z.string(), z.number()]).readonly(),
+  z.map(z.string(), z.date()).readonly(),
+  z.set(z.promise(z.string())).readonly(),
+  z.record(z.string()).readonly(),
+  z.record(z.string(), z.number()).readonly(),
+  z.object({ a: z.string(), 1: z.number() }).readonly(),
+  z.nativeEnum(testEnum).readonly(),
+  z.promise(z.string()).readonly(),
+] as const;
+
+test("flat inference", () => {
+  util.assertEqual<z.infer<(typeof schemas)[0]>, string>(true);
+  util.assertEqual<z.infer<(typeof schemas)[1]>, number>(true);
+  util.assertEqual<z.infer<(typeof schemas)[2]>, number>(true);
+  util.assertEqual<z.infer<(typeof schemas)[3]>, bigint>(true);
+  util.assertEqual<z.infer<(typeof schemas)[4]>, boolean>(true);
+  util.assertEqual<z.infer<(typeof schemas)[5]>, Date>(true);
+  util.assertEqual<z.infer<(typeof schemas)[6]>, undefined>(true);
+  util.assertEqual<z.infer<(typeof schemas)[7]>, null>(true);
+  util.assertEqual<z.infer<(typeof schemas)[8]>, any>(true);
+  util.assertEqual<z.infer<(typeof schemas)[9]>, Readonly<unknown>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[10]>, void>(true);
+  util.assertEqual<z.infer<(typeof schemas)[11]>, (args_0: string, args_1: number, ...args_2: unknown[]) => unknown>(
+    true
+  );
+  util.assertEqual<z.infer<(typeof schemas)[12]>, readonly string[]>(true);
+
+  util.assertEqual<z.infer<(typeof schemas)[13]>, readonly [string, number]>(true);
+  util.assertEqual<z.infer<(typeof schemas)[14]>, ReadonlyMap<string, Date>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[15]>, ReadonlySet<Promise<string>>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[16]>, Readonly<Record<string, string>>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[17]>, Readonly<Record<string, number>>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[18]>, { readonly a: string; readonly 1: number }>(true);
+  util.assertEqual<z.infer<(typeof schemas)[19]>, Readonly<testEnum>>(true);
+  util.assertEqual<z.infer<(typeof schemas)[20]>, Promise<string>>(true);
+});
+
+// test("deep inference", () => {
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[0]>, string>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[1]>, number>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[2]>, number>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[3]>, bigint>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[4]>, boolean>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[5]>, Date>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[6]>, undefined>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[7]>, null>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[8]>, any>(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[9]>,
+//     Readonly<unknown>
+//   >(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[10]>, void>(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[11]>,
+//     (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[12]>,
+//     readonly string[]
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[13]>,
+//     readonly [string, number]
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[14]>,
+//     ReadonlyMap<string, Date>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[15]>,
+//     ReadonlySet<Promise<string>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[16]>,
+//     Readonly<Record<string, string>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[17]>,
+//     Readonly<Record<string, number>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[18]>,
+//     { readonly a: string; readonly 1: number }
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[19]>,
+//     Readonly<testEnum>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[20]>,
+//     Promise<string>
+//   >(true);
+
+//   util.assertEqual<
+//     z.infer<typeof crazyDeepReadonlySchema>,
+//     ReadonlyMap<
+//       ReadonlySet<readonly [string, number]>,
+//       {
+//         readonly a: {
+//           readonly [x: string]: readonly any[];
+//         };
+//         readonly b: {
+//           readonly c: {
+//             readonly d: {
+//               readonly e: {
+//                 readonly f: {
+//                   readonly g?: {};
+//                 };
+//               };
+//             };
+//           };
+//         };
+//       }
+//     >
+//   >(true);
+// });
+
+test("object freezing", () => {
+  expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
+  expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
+  expect(
+    Object.isFrozen(
+      z
+        .map(z.string(), z.date())
+        .readonly()
+        .parse(new Map([["a", new Date()]]))
+    )
+  ).toBe(true);
+  expect(
+    Object.isFrozen(
+      z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parse(new Set([Promise.resolve("a")]))
+    )
+  ).toBe(true);
+  expect(Object.isFrozen(z.record(z.string()).readonly().parse({ a: "b" }))).toBe(true);
+  expect(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
+  expect(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
+  expect(Object.isFrozen(z.promise(z.string()).readonly().parse(Promise.resolve("a")))).toBe(true);
+});
+
+test("async object freezing", async () => {
+  expect(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
+  expect(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
+  expect(
+    Object.isFrozen(
+      await z
+        .map(z.string(), z.date())
+        .readonly()
+        .parseAsync(new Map([["a", new Date()]]))
+    )
+  ).toBe(true);
+  expect(
+    Object.isFrozen(
+      await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")]))
+    )
+  ).toBe(true);
+  expect(Object.isFrozen(await z.record(z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
+  expect(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
+  expect(
+    Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))
+  ).toBe(true);
+  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});

package/mcp/node_modules/zod/src/v3/tests/record.test.ts

@@ -0,0 +1,171 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const booleanRecord = z.record(z.boolean());
+type booleanRecord = z.infer<typeof booleanRecord>;
+
+const recordWithEnumKeys = z.record(z.enum(["Tuna", "Salmon"]), z.string());
+type recordWithEnumKeys = z.infer<typeof recordWithEnumKeys>;
+
+const recordWithLiteralKeys = z.record(z.union([z.literal("Tuna"), z.literal("Salmon")]), z.string());
+type recordWithLiteralKeys = z.infer<typeof recordWithLiteralKeys>;
+
+test("type inference", () => {
+  util.assertEqual<booleanRecord, Record<string, boolean>>(true);
+
+  util.assertEqual<recordWithEnumKeys, Partial<Record<"Tuna" | "Salmon", string>>>(true);
+
+  util.assertEqual<recordWithLiteralKeys, Partial<Record<"Tuna" | "Salmon", string>>>(true);
+});
+
+test("methods", () => {
+  booleanRecord.optional();
+  booleanRecord.nullable();
+});
+
+test("string record parse - pass", () => {
+  booleanRecord.parse({
+    k1: true,
+    k2: false,
+    1234: false,
+  });
+});
+
+test("string record parse - fail", () => {
+  const badCheck = () =>
+    booleanRecord.parse({
+      asdf: 1234,
+    } as any);
+  expect(badCheck).toThrow();
+
+  expect(() => booleanRecord.parse("asdf")).toThrow();
+});
+
+test("string record parse - fail", () => {
+  const badCheck = () =>
+    booleanRecord.parse({
+      asdf: {},
+    } as any);
+  expect(badCheck).toThrow();
+});
+
+test("string record parse - fail", () => {
+  const badCheck = () =>
+    booleanRecord.parse({
+      asdf: [],
+    } as any);
+  expect(badCheck).toThrow();
+});
+
+test("key schema", () => {
+  const result1 = recordWithEnumKeys.parse({
+    Tuna: "asdf",
+    Salmon: "asdf",
+  });
+  expect(result1).toEqual({
+    Tuna: "asdf",
+    Salmon: "asdf",
+  });
+
+  const result2 = recordWithLiteralKeys.parse({
+    Tuna: "asdf",
+    Salmon: "asdf",
+  });
+  expect(result2).toEqual({
+    Tuna: "asdf",
+    Salmon: "asdf",
+  });
+
+  // shouldn't require us to specify all props in record
+  const result3 = recordWithEnumKeys.parse({
+    Tuna: "abcd",
+  });
+  expect(result3).toEqual({
+    Tuna: "abcd",
+  });
+
+  // shouldn't require us to specify all props in record
+  const result4 = recordWithLiteralKeys.parse({
+    Salmon: "abcd",
+  });
+  expect(result4).toEqual({
+    Salmon: "abcd",
+  });
+
+  expect(() =>
+    recordWithEnumKeys.parse({
+      Tuna: "asdf",
+      Salmon: "asdf",
+      Trout: "asdf",
+    })
+  ).toThrow();
+
+  expect(() =>
+    recordWithLiteralKeys.parse({
+      Tuna: "asdf",
+      Salmon: "asdf",
+
+      Trout: "asdf",
+    })
+  ).toThrow();
+});
+
+// test("record element", () => {
+//   expect(booleanRecord.element).toBeInstanceOf(z.ZodBoolean);
+// });
+
+test("key and value getters", () => {
+  const rec = z.record(z.string(), z.number());
+
+  rec.keySchema.parse("asdf");
+  rec.valueSchema.parse(1234);
+  rec.element.parse(1234);
+});
+
+test("is not vulnerable to prototype pollution", async () => {
+  const rec = z.record(
+    z.object({
+      a: z.string(),
+    })
+  );
+
+  const data = JSON.parse(`
+    {
+      "__proto__": {
+        "a": "evil"
+      },
+      "b": {
+        "a": "good"
+      }
+    }
+  `);
+
+  const obj1 = rec.parse(data);
+  expect(obj1.a).toBeUndefined();
+
+  const obj2 = rec.safeParse(data);
+  expect(obj2.success).toBe(true);
+  if (obj2.success) {
+    expect(obj2.data.a).toBeUndefined();
+  }
+
+  const obj3 = await rec.parseAsync(data);
+  expect(obj3.a).toBeUndefined();
+
+  const obj4 = await rec.safeParseAsync(data);
+  expect(obj4.success).toBe(true);
+  if (obj4.success) {
+    expect(obj4.data.a).toBeUndefined();
+  }
+});
+
+test("dont parse undefined values", () => {
+  const result1 = z.record(z.any()).parse({ foo: undefined });
+
+  expect(result1).toEqual({
+    foo: undefined,
+  });
+});

package/mcp/node_modules/zod/src/v3/tests/recursive.test.ts

@@ -0,0 +1,197 @@
+// @ts-ignore TS6133
+import { test } from "vitest";
+
+import { z } from "zod/v3";
+
+interface Category {
+  name: string;
+  subcategories: Category[];
+}
+
+const testCategory: Category = {
+  name: "I",
+  subcategories: [
+    {
+      name: "A",
+      subcategories: [
+        {
+          name: "1",
+          subcategories: [
+            {
+              name: "a",
+              subcategories: [],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+test("recursion with z.late.object", () => {
+  const Category: z.ZodType<Category> = z.late.object(() => ({
+    name: z.string(),
+    subcategories: z.array(Category),
+  }));
+  Category.parse(testCategory);
+});
+
+test("recursion with z.lazy", () => {
+  const Category: z.ZodType<Category> = z.lazy(() =>
+    z.object({
+      name: z.string(),
+      subcategories: z.array(Category),
+    })
+  );
+  Category.parse(testCategory);
+});
+
+test("schema getter", () => {
+  z.lazy(() => z.string()).schema.parse("asdf");
+});
+
+type LinkedList = null | { value: number; next: LinkedList };
+
+const linkedListExample = {
+  value: 1,
+  next: {
+    value: 2,
+    next: {
+      value: 3,
+      next: {
+        value: 4,
+        next: null,
+      },
+    },
+  },
+};
+
+test("recursion involving union type", () => {
+  const LinkedListSchema: z.ZodType<LinkedList> = z.lazy(() =>
+    z.union([
+      z.null(),
+      z.object({
+        value: z.number(),
+        next: LinkedListSchema,
+      }),
+    ])
+  );
+  LinkedListSchema.parse(linkedListExample);
+});
+
+// interface A {
+//   val: number;
+//   b: B;
+// }
+
+// interface B {
+//   val: number;
+//   a: A;
+// }
+
+// const A: z.ZodType<A> = z.late.object(() => ({
+//   val: z.number(),
+//   b: B,
+// }));
+
+// const B: z.ZodType<B> = z.late.object(() => ({
+//   val: z.number(),
+//   a: A,
+// }));
+
+// const Alazy: z.ZodType<A> = z.lazy(() => z.object({
+//   val: z.number(),
+//   b: B,
+// }));
+
+// const Blazy: z.ZodType<B> = z.lazy(() => z.object({
+//   val: z.number(),
+//   a: A,
+// }));
+
+// const a: any = { val: 1 };
+// const b: any = { val: 2 };
+// a.b = b;
+// b.a = a;
+
+// test('valid check', () => {
+//   A.parse(a);
+//   B.parse(b);
+// });
+
+// test("valid check lazy", () => {
+//   A.parse({val:1, b:});
+//   B.parse(b);
+// });
+
+// test('masking check', () => {
+//   const FragmentOnA = z
+//     .object({
+//       val: z.number(),
+//       b: z
+//         .object({
+//           val: z.number(),
+//           a: z
+//             .object({
+//               val: z.number(),
+//             })
+//             .nonstrict(),
+//         })
+//         .nonstrict(),
+//     })
+//     .nonstrict();
+
+//   const fragment = FragmentOnA.parse(a);
+//   fragment;
+// });
+
+// test('invalid check', () => {
+//   expect(() => A.parse({} as any)).toThrow();
+// });
+
+// test('schema getter', () => {
+//   (A as z.ZodLazy<any>).schema;
+// });
+
+// test("self recursion with cyclical data", () => {
+//   interface Category {
+//     name: string;
+//     subcategories: Category[];
+//   }
+
+//   const Category: z.ZodType<Category> = z.late.object(() => ({
+//     name: z.string(),
+//     subcategories: z.array(Category),
+//   }));
+
+//   const untypedCategory: any = {
+//     name: "Category A",
+//   };
+//   // creating a cycle
+//   untypedCategory.subcategories = [untypedCategory];
+//   Category.parse(untypedCategory);
+// });
+
+// test("self recursion with base type", () => {
+//   const BaseCategory = z.object({
+//     name: z.string(),
+//   });
+//   type BaseCategory = z.infer<typeof BaseCategory>;
+
+//   type Category = BaseCategory & { subcategories: Category[] };
+
+//   const Category: z.ZodType<Category> = z.late
+//     .object(() => ({
+//       subcategories: z.array(Category),
+//     }))
+//     .extend({
+//       name: z.string(),
+//     });
+
+//   const untypedCategory: any = {
+//     name: "Category A",
+//   };
+//   // creating a cycle
+//   untypedCategory.subcategories = [untypedCategory];
+//   Category.parse(untypedCategory); // parses successfully
+// });