@nocobase/plugin-ai-gigachat 2.0.3

package/dist/node_modules/langchain-gigachat/node_modules/zod/src/v3/tests/deepmasking.test.ts

@@ -0,0 +1,186 @@
+// @ts-ignore TS6133
+import { test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("test", () => {
+  z;
+});
+
+// const fish = z.object({
+//   name: z.string(),
+//   props: z.object({
+//     color: z.string(),
+//     numScales: z.number(),
+//   }),
+// });
+
+// const nonStrict = z
+//   .object({
+//     name: z.string(),
+//     color: z.string(),
+//   })
+//   .nonstrict();
+
+// test('object pick type', () => {
+//   const modNonStrictFish = nonStrict.omit({ name: true });
+//   modNonStrictFish.parse({ color: 'asdf' });
+
+//   const bad1 = () => fish.pick({ props: { unknown: true } } as any);
+//   const bad2 = () => fish.omit({ name: true, props: { unknown: true } } as any);
+
+//   expect(bad1).toThrow();
+//   expect(bad2).toThrow();
+// });
+
+// test('f1', () => {
+//   const f1 = fish.pick(true);
+//   f1.parse({ name: 'a', props: { color: 'b', numScales: 3 } });
+// });
+// test('f2', () => {
+//   const f2 = fish.pick({ props: true });
+//   f2.parse({ props: { color: 'asdf', numScales: 1 } });
+//   const badcheck2 = () => f2.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck2).toThrow();
+// });
+// test('f3', () => {
+//   const f3 = fish.pick({ props: { color: true } });
+//   f3.parse({ props: { color: 'b' } });
+//   const badcheck3 = () => f3.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck3).toThrow();
+// });
+// test('f4', () => {
+//   const badcheck4 = () => fish.pick({ props: { color: true, unknown: true } });
+//   expect(badcheck4).toThrow();
+// });
+// test('f6', () => {
+//   const f6 = fish.omit({ props: true });
+//   const badcheck6 = () => f6.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   f6.parse({ name: 'adsf' });
+//   expect(badcheck6).toThrow();
+// });
+// test('f7', () => {
+//   const f7 = fish.omit({ props: { color: true } });
+//   f7.parse({ name: 'a', props: { numScales: 3 } });
+//   const badcheck7 = () => f7.parse({ name: 'a', props: { color: 'b', numScales: 3 } } as any);
+//   expect(badcheck7).toThrow();
+// });
+// test('f8', () => {
+//   const badcheck8 = () => fish.omit({ props: { color: true, unknown: true } });
+//   expect(badcheck8).toThrow();
+// });
+// test('f9', () => {
+//   const f9 = nonStrict.pick(true);
+//   f9.parse({ name: 'a', color: 'asdf' });
+// });
+// test('f10', () => {
+//   const f10 = nonStrict.pick({ name: true });
+//   f10.parse({ name: 'a' });
+//   const val = f10.parse({ name: 'a', color: 'b' });
+//   expect(val).toEqual({ name: 'a' });
+// });
+// test('f12', () => {
+//   const badfcheck12 = () => nonStrict.omit({ color: true, asdf: true });
+//   expect(badfcheck12).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishArray = fishArray.pick({
+//     name: true,
+//     props: {
+//       numScales: true,
+//     },
+//   });
+
+//   modFishArray.parse([{ name: 'fish', props: { numScales: 12 } }]);
+//   const bad1 = () => modFishArray.parse([{ name: 'fish', props: { numScales: 12, color: 'asdf' } }] as any);
+//   expect(bad1).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.pick({
+//       name: true,
+//       props: {
+//         whatever: true,
+//       },
+//     } as any);
+//   expect(fail).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const fail = () =>
+//     fishArray.omit({
+//       whateve: true,
+//     } as any);
+//   expect(fail).toThrow();
+// });
+
+// test('array masking', () => {
+//   const fishArray = z.array(fish);
+//   const modFishList = fishArray.omit({
+//     name: true,
+//     props: {
+//       color: true,
+//     },
+//   });
+
+//   modFishList.parse([{ props: { numScales: 12 } }]);
+//   const fail = () => modFishList.parse([{ name: 'hello', props: { numScales: 12 } }] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('primitive array masking', () => {
+//   const fishArray = z.array(z.number());
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+
+// test('other array masking', () => {
+//   const fishArray = z.array(z.array(z.number()));
+//   const fail = () => fishArray.pick({} as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #1', () => {
+//   const fail = () => fish.pick(1 as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #2', () => {
+//   const fail = () => fish.pick([] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #3', () => {
+//   const fail = () => fish.pick(false as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #4', () => {
+//   const fail = () => fish.pick('asdf' as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #5', () => {
+//   const fail = () => fish.omit(1 as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #6', () => {
+//   const fail = () => fish.omit([] as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #7', () => {
+//   const fail = () => fish.omit(false as any);
+//   expect(fail).toThrow();
+// });
+
+// test('invalid mask #8', () => {
+//   const fail = () => fish.omit('asdf' as any);
+//   expect(fail).toThrow();
+// });

package/dist/node_modules/langchain-gigachat/node_modules/zod/src/v3/tests/default.test.ts

@@ -0,0 +1,112 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import { z } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("basic defaults", () => {
+  expect(z.string().default("default").parse(undefined)).toBe("default");
+});
+
+test("default with transform", () => {
+  const stringWithDefault = z
+    .string()
+    .transform((val) => val.toUpperCase())
+    .default("default");
+  expect(stringWithDefault.parse(undefined)).toBe("DEFAULT");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
+  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("default on existing optional", () => {
+  const stringWithDefault = z.string().optional().default("asdf");
+  expect(stringWithDefault.parse(undefined)).toBe("asdf");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
+  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("optional on default", () => {
+  const stringWithDefault = z.string().default("asdf").optional();
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string | undefined>(true);
+});
+
+test("complex chain example", () => {
+  const complex = z
+    .string()
+    .default("asdf")
+    .transform((val) => val.toUpperCase())
+    .default("qwer")
+    .removeDefault()
+    .optional()
+    .default("asdfasdf");
+
+  expect(complex.parse(undefined)).toBe("ASDFASDF");
+});
+
+test("removeDefault", () => {
+  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
+
+  type out = z.output<typeof stringWithRemovedDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("nested", () => {
+  const inner = z.string().default("asdf");
+  const outer = z.object({ inner }).default({
+    inner: undefined,
+  });
+  type input = z.input<typeof outer>;
+  util.assertEqual<input, { inner?: string | undefined } | undefined>(true);
+  type out = z.output<typeof outer>;
+  util.assertEqual<out, { inner: string }>(true);
+  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
+  expect(outer.parse({})).toEqual({ inner: "asdf" });
+  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
+});
+
+test("chained defaults", () => {
+  const stringWithDefault = z.string().default("inner").default("outer");
+  const result = stringWithDefault.parse(undefined);
+  expect(result).toEqual("outer");
+});
+
+test("factory", () => {
+  expect(z.ZodDefault.create(z.string(), { default: "asdf" }).parse(undefined)).toEqual("asdf");
+});
+
+test("native enum", () => {
+  enum Fruits {
+    apple = "apple",
+    orange = "orange",
+  }
+
+  const schema = z.object({
+    fruit: z.nativeEnum(Fruits).default(Fruits.apple),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
+});
+
+test("enum", () => {
+  const schema = z.object({
+    fruit: z.enum(["apple", "orange"]).default("apple"),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: "apple" });
+});

package/dist/node_modules/langchain-gigachat/node_modules/zod/src/v3/tests/description.test.ts

@@ -0,0 +1,33 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const description = "a description";
+
+test("passing `description` to schema should add a description", () => {
+  expect(z.string({ description }).description).toEqual(description);
+  expect(z.number({ description }).description).toEqual(description);
+  expect(z.boolean({ description }).description).toEqual(description);
+});
+
+test("`.describe` should add a description", () => {
+  expect(z.string().describe(description).description).toEqual(description);
+  expect(z.number().describe(description).description).toEqual(description);
+  expect(z.boolean().describe(description).description).toEqual(description);
+});
+
+test("description should carry over to chained schemas", () => {
+  const schema = z.string({ description });
+  expect(schema.description).toEqual(description);
+  expect(schema.optional().description).toEqual(description);
+  expect(schema.optional().nullable().default("default").description).toEqual(description);
+});
+
+test("description should not carry over to chained array schema", () => {
+  const schema = z.string().describe(description);
+
+  expect(schema.description).toEqual(description);
+  expect(schema.array().description).toEqual(undefined);
+  expect(z.array(schema).description).toEqual(undefined);
+});

package/dist/node_modules/langchain-gigachat/node_modules/zod/src/v3/tests/discriminated-unions.test.ts

@@ -0,0 +1,315 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("valid", () => {
+  expect(
+    z
+      .discriminatedUnion("type", [
+        z.object({ type: z.literal("a"), a: z.string() }),
+        z.object({ type: z.literal("b"), b: z.string() }),
+      ])
+      .parse({ type: "a", a: "abc" })
+  ).toEqual({ type: "a", a: "abc" });
+});
+
+test("valid - discriminator value of various primitive types", () => {
+  const schema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("1"), val: z.literal(1) }),
+    z.object({ type: z.literal(1), val: z.literal(2) }),
+    z.object({ type: z.literal(BigInt(1)), val: z.literal(3) }),
+    z.object({ type: z.literal("true"), val: z.literal(4) }),
+    z.object({ type: z.literal(true), val: z.literal(5) }),
+    z.object({ type: z.literal("null"), val: z.literal(6) }),
+    z.object({ type: z.literal(null), val: z.literal(7) }),
+    z.object({ type: z.literal("undefined"), val: z.literal(8) }),
+    z.object({ type: z.literal(undefined), val: z.literal(9) }),
+    z.object({ type: z.literal("transform"), val: z.literal(10) }),
+    z.object({ type: z.literal("refine"), val: z.literal(11) }),
+    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
+  ]);
+
+  expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
+  expect(schema.parse({ type: 1, val: 2 })).toEqual({ type: 1, val: 2 });
+  expect(schema.parse({ type: BigInt(1), val: 3 })).toEqual({
+    type: BigInt(1),
+    val: 3,
+  });
+  expect(schema.parse({ type: "true", val: 4 })).toEqual({
+    type: "true",
+    val: 4,
+  });
+  expect(schema.parse({ type: true, val: 5 })).toEqual({
+    type: true,
+    val: 5,
+  });
+  expect(schema.parse({ type: "null", val: 6 })).toEqual({
+    type: "null",
+    val: 6,
+  });
+  expect(schema.parse({ type: null, val: 7 })).toEqual({
+    type: null,
+    val: 7,
+  });
+  expect(schema.parse({ type: "undefined", val: 8 })).toEqual({
+    type: "undefined",
+    val: 8,
+  });
+  expect(schema.parse({ type: undefined, val: 9 })).toEqual({
+    type: undefined,
+    val: 9,
+  });
+});
+
+test("invalid - null", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse(null);
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_type,
+        expected: z.ZodParsedType.object,
+        message: "Expected object, received null",
+        received: z.ZodParsedType.null,
+        path: [],
+      },
+    ]);
+  }
+});
+
+test("invalid discriminator value", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse({ type: "x", a: "abc" });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_union_discriminator,
+        options: ["a", "b"],
+        message: "Invalid discriminator value. Expected 'a' | 'b'",
+        path: ["type"],
+      },
+    ]);
+  }
+});
+
+test("valid discriminator value, invalid data", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse({ type: "a", b: "abc" });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_type,
+        expected: z.ZodParsedType.string,
+        message: "Required",
+        path: ["a"],
+        received: z.ZodParsedType.undefined,
+      },
+    ]);
+  }
+});
+
+test("wrong schema - missing discriminator", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ b: z.string() }) as any,
+    ]);
+    throw new Error();
+  } catch (e: any) {
+    expect(e.message.includes("could not be extracted")).toBe(true);
+  }
+});
+
+test("wrong schema - duplicate discriminator values", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("a"), b: z.string() }),
+    ]);
+    throw new Error();
+  } catch (e: any) {
+    expect(e.message.includes("has duplicate value")).toEqual(true);
+  }
+});
+
+test("async - valid", async () => {
+  expect(
+    await z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("a"),
+          a: z
+            .string()
+            .refine(async () => true)
+            .transform(async (val) => Number(val)),
+        }),
+        z.object({
+          type: z.literal("b"),
+          b: z.string(),
+        }),
+      ])
+      .parseAsync({ type: "a", a: "1" })
+  ).toEqual({ type: "a", a: 1 });
+});
+
+test("async - invalid", async () => {
+  try {
+    await z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("a"),
+          a: z
+            .string()
+            .refine(async () => true)
+            .transform(async (val) => val),
+        }),
+        z.object({
+          type: z.literal("b"),
+          b: z.string(),
+        }),
+      ])
+      .parseAsync({ type: "a", a: 1 });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: "invalid_type",
+        expected: "string",
+        received: "number",
+        path: ["a"],
+        message: "Expected string, received number",
+      },
+    ]);
+  }
+});
+
+test("valid - literals with .default or .preprocess", () => {
+  const schema = z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("foo").default("foo"),
+      a: z.string(),
+    }),
+    z.object({
+      type: z.literal("custom"),
+      method: z.string(),
+    }),
+    z.object({
+      type: z.preprocess((val) => String(val), z.literal("bar")),
+      c: z.string(),
+    }),
+  ]);
+  expect(schema.parse({ type: "foo", a: "foo" })).toEqual({
+    type: "foo",
+    a: "foo",
+  });
+});
+
+test("enum and nativeEnum", () => {
+  enum MyEnum {
+    d = 0,
+    e = "e",
+  }
+
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a"),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.enum(["b", "c"]),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.nativeEnum(MyEnum),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  // type schema = z.infer<typeof schema>;
+
+  schema.parse({ key: "a" });
+  schema.parse({ key: "b" });
+  schema.parse({ key: "c" });
+  schema.parse({ key: MyEnum.d });
+  schema.parse({ key: MyEnum.e });
+  schema.parse({ key: "e" });
+});
+
+test("branded", () => {
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a"),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.literal("b").brand("asdfaf"),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  // type schema = z.infer<typeof schema>;
+
+  schema.parse({ key: "a" });
+  schema.parse({ key: "b" });
+  expect(() => {
+    schema.parse({ key: "c" });
+  }).toThrow();
+});
+
+test("optional and nullable", () => {
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a").optional(),
+      a: z.literal(true),
+    }),
+    z.object({
+      key: z.literal("b").nullable(),
+      b: z.literal(true),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  type schema = z.infer<typeof schema>;
+  z.util.assertEqual<schema, { key?: "a" | undefined; a: true } | { key: "b" | null; b: true }>(true);
+
+  schema.parse({ key: "a", a: true });
+  schema.parse({ key: undefined, a: true });
+  schema.parse({ key: "b", b: true });
+  schema.parse({ key: null, b: true });
+  expect(() => {
+    schema.parse({ key: null, a: true });
+  }).toThrow();
+  expect(() => {
+    schema.parse({ key: "b", a: true });
+  }).toThrow();
+
+  const value = schema.parse({ key: null, b: true });
+
+  if (!("key" in value)) value.a;
+  if (value.key === undefined) value.a;
+  if (value.key === "a") value.a;
+  if (value.key === "b") value.b;
+  if (value.key === null) value.b;
+});
+
+test("readonly array of options", () => {
+  const options = [
+    z.object({ type: z.literal("x"), val: z.literal(1) }),
+    z.object({ type: z.literal("y"), val: z.literal(2) }),
+  ] as const;
+
+  expect(z.discriminatedUnion("type", options).parse({ type: "x", val: 1 })).toEqual({ type: "x", val: 1 });
+});