@defai.digital/ax-cli 4.0.5 → 4.1.0

package/node_modules/zod/src/v3/tests/parseUtil.test.ts

@@ -1,23 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import { type SyncParseReturnType, isAborted, isDirty, isValid } from "../helpers/parseUtil.js";
-
-test("parseUtil isInvalid should use structural typing", () => {
-  // Test for issue #556: https://github.com/colinhacks/zod/issues/556
-  const aborted: SyncParseReturnType = { status: "aborted" };
-  const dirty: SyncParseReturnType = { status: "dirty", value: "whatever" };
-  const valid: SyncParseReturnType = { status: "valid", value: "whatever" };
-
-  expect(isAborted(aborted)).toBe(true);
-  expect(isAborted(dirty)).toBe(false);
-  expect(isAborted(valid)).toBe(false);
-
-  expect(isDirty(aborted)).toBe(false);
-  expect(isDirty(dirty)).toBe(true);
-  expect(isDirty(valid)).toBe(false);
-
-  expect(isValid(aborted)).toBe(false);
-  expect(isValid(dirty)).toBe(false);
-  expect(isValid(valid)).toBe(true);
-});

package/node_modules/zod/src/v3/tests/parser.test.ts

@@ -1,41 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("parse strict object with unknown keys", () => {
-  expect(() =>
-    z
-      .object({ name: z.string() })
-      .strict()
-      .parse({ name: "bill", unknownKey: 12 } as any)
-  ).toThrow();
-});
-
-test("parse nonstrict object with unknown keys", () => {
-  z.object({ name: z.string() }).nonstrict().parse({ name: "bill", unknownKey: 12 });
-});
-
-test("invalid left side of intersection", () => {
-  expect(() => z.intersection(z.string(), z.number()).parse(12 as any)).toThrow();
-});
-
-test("invalid right side of intersection", () => {
-  expect(() => z.intersection(z.string(), z.number()).parse("12" as any)).toThrow();
-});
-
-test("parsing non-array in tuple schema", () => {
-  expect(() => z.tuple([]).parse("12" as any)).toThrow();
-});
-
-test("incorrect num elements in tuple", () => {
-  expect(() => z.tuple([]).parse(["asdf"] as any)).toThrow();
-});
-
-test("invalid enum value", () => {
-  expect(() => z.enum(["Blue"]).parse("Red" as any)).toThrow();
-});
-
-test("parsing unknown", () => {
-  z.string().parse("Red" as unknown);
-});

package/node_modules/zod/src/v3/tests/partials.test.ts

@@ -1,243 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { ZodNullable, ZodOptional } from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const nested = z.object({
-  name: z.string(),
-  age: z.number(),
-  outer: z.object({
-    inner: z.string(),
-  }),
-  array: z.array(z.object({ asdf: z.string() })),
-});
-
-test("shallow inference", () => {
-  const shallow = nested.partial();
-  type shallow = z.infer<typeof shallow>;
-  type correct = {
-    name?: string | undefined;
-    age?: number | undefined;
-    outer?: { inner: string } | undefined;
-    array?: { asdf: string }[];
-  };
-  util.assertEqual<shallow, correct>(true);
-});
-
-test("shallow partial parse", () => {
-  const shallow = nested.partial();
-  shallow.parse({});
-  shallow.parse({
-    name: "asdf",
-    age: 23143,
-  });
-});
-
-test("deep partial inference", () => {
-  const deep = nested.deepPartial();
-  const asdf = deep.shape.array.unwrap().element.shape.asdf.unwrap();
-  asdf.parse("asdf");
-  type deep = z.infer<typeof deep>;
-  type correct = {
-    array?: { asdf?: string }[];
-    name?: string | undefined;
-    age?: number | undefined;
-    outer?: { inner?: string | undefined } | undefined;
-  };
-
-  util.assertEqual<deep, correct>(true);
-});
-
-test("deep partial parse", () => {
-  const deep = nested.deepPartial();
-
-  expect(deep.shape.name instanceof z.ZodOptional).toBe(true);
-  expect(deep.shape.outer instanceof z.ZodOptional).toBe(true);
-  expect(deep.shape.outer._def.innerType instanceof z.ZodObject).toBe(true);
-  expect(deep.shape.outer._def.innerType.shape.inner instanceof z.ZodOptional).toBe(true);
-  expect(deep.shape.outer._def.innerType.shape.inner._def.innerType instanceof z.ZodString).toBe(true);
-});
-
-test("deep partial runtime tests", () => {
-  const deep = nested.deepPartial();
-  deep.parse({});
-  deep.parse({
-    outer: {},
-  });
-  deep.parse({
-    name: "asdf",
-    age: 23143,
-    outer: {
-      inner: "adsf",
-    },
-  });
-});
-
-test("deep partial optional/nullable", () => {
-  const schema = z
-    .object({
-      name: z.string().optional(),
-      age: z.number().nullable(),
-    })
-    .deepPartial();
-
-  expect(schema.shape.name.unwrap()).toBeInstanceOf(ZodOptional);
-  expect(schema.shape.age.unwrap()).toBeInstanceOf(ZodNullable);
-});
-
-test("deep partial tuple", () => {
-  const schema = z
-    .object({
-      tuple: z.tuple([
-        z.object({
-          name: z.string().optional(),
-          age: z.number().nullable(),
-        }),
-      ]),
-    })
-    .deepPartial();
-
-  expect(schema.shape.tuple.unwrap().items[0].shape.name).toBeInstanceOf(ZodOptional);
-});
-
-test("deep partial inference", () => {
-  const mySchema = z.object({
-    name: z.string(),
-    array: z.array(z.object({ asdf: z.string() })),
-    tuple: z.tuple([z.object({ value: z.string() })]),
-  });
-
-  const partialed = mySchema.deepPartial();
-  type partialed = z.infer<typeof partialed>;
-  type expected = {
-    name?: string | undefined;
-    array?:
-      | {
-          asdf?: string | undefined;
-        }[]
-      | undefined;
-    tuple?: [{ value?: string }] | undefined;
-  };
-  util.assertEqual<expected, partialed>(true);
-});
-
-test("required", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    nullableField: z.number().nullable(),
-    nullishField: z.string().nullish(),
-  });
-
-  const requiredObject = object.required();
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.nullableField).toBeInstanceOf(z.ZodNullable);
-  expect(requiredObject.shape.nullishField).toBeInstanceOf(z.ZodNullable);
-});
-
-test("required inference", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    nullableField: z.number().nullable(),
-    nullishField: z.string().nullish(),
-  });
-
-  const requiredObject = object.required();
-
-  type required = z.infer<typeof requiredObject>;
-  type expected = {
-    name: string;
-    age: number;
-    field: string;
-    nullableField: number | null;
-    nullishField: string | null;
-  };
-  util.assertEqual<expected, required>(true);
-});
-
-test("required with mask", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string().optional(),
-  });
-
-  const requiredObject = object.required({ age: true });
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
-});
-
-test("required with mask -- ignore falsy values", () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string().optional(),
-  });
-
-  // @ts-expect-error
-  const requiredObject = object.required({ age: true, country: false });
-  expect(requiredObject.shape.name).toBeInstanceOf(z.ZodString);
-  expect(requiredObject.shape.age).toBeInstanceOf(z.ZodNumber);
-  expect(requiredObject.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(requiredObject.shape.country).toBeInstanceOf(z.ZodOptional);
-});
-
-test("partial with mask", async () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string(),
-  });
-
-  const masked = object.partial({ age: true, field: true, name: true }).strict();
-
-  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.field).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
-
-  masked.parse({ country: "US" });
-  await masked.parseAsync({ country: "US" });
-});
-
-test("partial with mask -- ignore falsy values", async () => {
-  const object = z.object({
-    name: z.string(),
-    age: z.number().optional(),
-    field: z.string().optional().default("asdf"),
-    country: z.string(),
-  });
-
-  // @ts-expect-error
-  const masked = object.partial({ name: true, country: false }).strict();
-
-  expect(masked.shape.name).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.age).toBeInstanceOf(z.ZodOptional);
-  expect(masked.shape.field).toBeInstanceOf(z.ZodDefault);
-  expect(masked.shape.country).toBeInstanceOf(z.ZodString);
-
-  masked.parse({ country: "US" });
-  await masked.parseAsync({ country: "US" });
-});
-
-test("deeppartial array", () => {
-  const schema = z.object({ array: z.string().array().min(42) }).deepPartial();
-
-  // works as expected
-  schema.parse({});
-
-  // should be false, but is true
-  expect(schema.safeParse({ array: [] }).success).toBe(false);
-});

package/node_modules/zod/src/v3/tests/pickomit.test.ts

@@ -1,111 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const fish = z.object({
-  name: z.string(),
-  age: z.number(),
-  nested: z.object({}),
-});
-
-test("pick type inference", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  type nameonlyFish = z.infer<typeof nameonlyFish>;
-  util.assertEqual<nameonlyFish, { name: string }>(true);
-});
-
-test("pick parse - success", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  nameonlyFish.parse({ name: "bob" });
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false });
-  anotherNameonlyFish.parse({ name: "bob" });
-});
-
-test("pick parse - fail", () => {
-  fish.pick({ name: true }).parse({ name: "12" } as any);
-  fish.pick({ name: true }).parse({ name: "bob", age: 12 } as any);
-  fish.pick({ age: true }).parse({ age: 12 } as any);
-
-  const nameonlyFish = fish.pick({ name: true }).strict();
-  const bad1 = () => nameonlyFish.parse({ name: 12 } as any);
-  const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 } as any);
-  const bad3 = () => nameonlyFish.parse({ age: 12 } as any);
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
-  const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("omit type inference", () => {
-  const nonameFish = fish.omit({ name: true });
-  type nonameFish = z.infer<typeof nonameFish>;
-  util.assertEqual<nonameFish, { age: number; nested: {} }>(true);
-});
-
-test("omit parse - success", () => {
-  const nonameFish = fish.omit({ name: true });
-  nonameFish.parse({ age: 12, nested: {} });
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  anotherNonameFish.parse({ age: 12, nested: {} });
-});
-
-test("omit parse - fail", () => {
-  const nonameFish = fish.omit({ name: true });
-  const bad1 = () => nonameFish.parse({ name: 12 } as any);
-  const bad2 = () => nonameFish.parse({ age: 12 } as any);
-  const bad3 = () => nonameFish.parse({} as any);
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  const bad4 = () => anotherNonameFish.parse({ nested: {} } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("nonstrict inference", () => {
-  const laxfish = fish.pick({ name: true }).catchall(z.any());
-  type laxfish = z.infer<typeof laxfish>;
-  util.assertEqual<laxfish, { name: string } & { [k: string]: any }>(true);
-});
-
-test("nonstrict parsing - pass", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  laxfish.parse({ name: "asdf", whatever: "asdf" });
-  laxfish.parse({ name: "asdf", age: 12, nested: {} });
-});
-
-test("nonstrict parsing - fail", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  const bad = () => laxfish.parse({ whatever: "asdf" } as any);
-  expect(bad).toThrow();
-});
-
-test("pick/omit/required/partial - do not allow unknown keys", () => {
-  const schema = z.object({
-    name: z.string(),
-    age: z.number(),
-  });
-
-  // @ts-expect-error
-  schema.pick({ $unknown: true });
-  // @ts-expect-error
-  schema.omit({ $unknown: true });
-  // @ts-expect-error
-  schema.required({ $unknown: true });
-  // @ts-expect-error
-  schema.partial({ $unknown: true });
-});

package/node_modules/zod/src/v3/tests/pipeline.test.ts

@@ -1,29 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("string to number pipeline", () => {
-  const schema = z.string().transform(Number).pipe(z.number());
-  expect(schema.parse("1234")).toEqual(1234);
-});
-
-test("string to number pipeline async", async () => {
-  const schema = z
-    .string()
-    .transform(async (val) => Number(val))
-    .pipe(z.number());
-  expect(await schema.parseAsync("1234")).toEqual(1234);
-});
-
-test("break if dirty", () => {
-  const schema = z
-    .string()
-    .refine((c) => c === "1234")
-    .transform(async (val) => Number(val))
-    .pipe(z.number().refine((v) => v < 100));
-  const r1: any = schema.safeParse("12345");
-  expect(r1.error.issues.length).toBe(1);
-  const r2: any = schema.safeParse("3");
-  expect(r2.error.issues.length).toBe(1);
-});

package/node_modules/zod/src/v3/tests/preprocess.test.ts

@@ -1,186 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-test("preprocess", () => {
-  const schema = z.preprocess((data) => [data], z.string().array());
-
-  const value = schema.parse("asdf");
-  expect(value).toEqual(["asdf"]);
-  util.assertEqual<(typeof schema)["_input"], unknown>(true);
-});
-
-test("async preprocess", async () => {
-  const schema = z.preprocess(async (data) => [data], z.string().array());
-
-  const value = await schema.parseAsync("asdf");
-  expect(value).toEqual(["asdf"]);
-});
-
-test("preprocess ctx.addIssue with parse", () => {
-  expect(() => {
-    z.preprocess((data, ctx) => {
-      ctx.addIssue({
-        code: "custom",
-        message: `${data} is not one of our allowed strings`,
-      });
-      return data;
-    }, z.string()).parse("asdf");
-  }).toThrow(
-    JSON.stringify(
-      [
-        {
-          code: "custom",
-          message: "asdf is not one of our allowed strings",
-          path: [],
-        },
-      ],
-      null,
-      2
-    )
-  );
-});
-
-test("preprocess ctx.addIssue non-fatal by default", () => {
-  try {
-    z.preprocess((data, ctx) => {
-      ctx.addIssue({
-        code: "custom",
-        message: `custom error`,
-      });
-      return data;
-    }, z.string()).parse(1234);
-  } catch (err) {
-    z.ZodError.assert(err);
-    expect(err.issues.length).toEqual(2);
-  }
-});
-
-test("preprocess ctx.addIssue fatal true", () => {
-  try {
-    z.preprocess((data, ctx) => {
-      ctx.addIssue({
-        code: "custom",
-        message: `custom error`,
-        fatal: true,
-      });
-      return data;
-    }, z.string()).parse(1234);
-  } catch (err) {
-    z.ZodError.assert(err);
-    expect(err.issues.length).toEqual(1);
-  }
-});
-
-test("async preprocess ctx.addIssue with parse", async () => {
-  const schema = z.preprocess(async (data, ctx) => {
-    ctx.addIssue({
-      code: "custom",
-      message: `custom error`,
-    });
-    return data;
-  }, z.string());
-
-  expect(await schema.safeParseAsync("asdf")).toMatchInlineSnapshot(`
-    {
-      "error": [ZodError: [
-      {
-        "code": "custom",
-        "message": "custom error",
-        "path": []
-      }
-    ]],
-      "success": false,
-    }
-  `);
-});
-
-test("preprocess ctx.addIssue with parseAsync", async () => {
-  const result = await z
-    .preprocess(async (data, ctx) => {
-      ctx.addIssue({
-        code: "custom",
-        message: `${data} is not one of our allowed strings`,
-      });
-      return data;
-    }, z.string())
-    .safeParseAsync("asdf");
-
-  expect(JSON.parse(JSON.stringify(result))).toEqual({
-    success: false,
-    error: {
-      issues: [
-        {
-          code: "custom",
-          message: "asdf is not one of our allowed strings",
-          path: [],
-        },
-      ],
-      name: "ZodError",
-    },
-  });
-});
-
-test("z.NEVER in preprocess", () => {
-  const foo = z.preprocess((val, ctx) => {
-    if (!val) {
-      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "bad" });
-      return z.NEVER;
-    }
-    return val;
-  }, z.number());
-
-  type foo = z.infer<typeof foo>;
-  util.assertEqual<foo, number>(true);
-  const arg = foo.safeParse(undefined);
-  expect(arg.error!.issues).toHaveLength(2);
-  expect(arg.error!.issues[0].message).toEqual("bad");
-});
-test("preprocess as the second property of object", () => {
-  const schema = z.object({
-    nonEmptyStr: z.string().min(1),
-    positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
-  });
-  const result = schema.safeParse({
-    nonEmptyStr: "",
-    positiveNum: "",
-  });
-  expect(result.success).toEqual(false);
-  if (!result.success) {
-    expect(result.error.issues.length).toEqual(2);
-    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.too_small);
-    expect(result.error.issues[1].code).toEqual(z.ZodIssueCode.too_small);
-  }
-});
-
-test("preprocess validates with sibling errors", () => {
-  expect(() => {
-    z.object({
-      // Must be first
-      missing: z.string().refine(() => false),
-      preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
-    }).parse({ preprocess: " asdf" });
-  }).toThrow(
-    JSON.stringify(
-      [
-        {
-          code: "invalid_type",
-          expected: "string",
-          received: "undefined",
-          path: ["missing"],
-          message: "Required",
-        },
-        {
-          validation: "regex",
-          code: "invalid_string",
-          message: "Invalid",
-          path: ["preprocess"],
-        },
-      ],
-      null,
-      2
-    )
-  );
-});