@willaimg/yatsp 4.3.6

package/src/v4/mini/tests/apply.test.ts

@@ -0,0 +1,57 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("basic apply (number)", () => {
+  const setCommonNumberChecks = <T extends z.YatspMiniNumber>(schema: T) => {
+    return schema.check(z.minimum(0), z.maximum(100));
+  };
+
+  const schema = z.nullable(z.number().apply(setCommonNumberChecks));
+
+  expect(() => z.parse(schema, -1)).toThrowError();
+  expect(() => z.parse(schema, 101)).toThrowError();
+  expect(z.parse(schema, 0)).toBe(0);
+  expect(z.parse(schema, null)).toBe(null);
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<number | null>();
+});
+
+test("The callback's return value becomes the apply's return value.", () => {
+  const symbol = Symbol();
+  const result = z.number().apply(() => symbol);
+
+  expect(result).toBe(symbol);
+  expectTypeOf<typeof result>().toEqualTypeOf<symbol>();
+});
+
+test("apply forwards extra args to the callback", () => {
+  const calls: unknown[] = [];
+  const capture = (schema: z.YatspMiniString, ...args: unknown[]) => {
+    calls.push(schema, ...args);
+    return schema;
+  };
+
+  const schema = z.string();
+  const result = schema.apply(capture, "id", 42);
+
+  expect(calls[0]).toBe(schema);
+  expect(calls[1]).toBe("id");
+  expect(calls[2]).toBe(42);
+  expect(z.parse(result, "value")).toBe("value");
+  expectTypeOf<z.infer<typeof result>>().toEqualTypeOf<string>();
+});
+
+test("apply type-checks the extra args", () => {
+  const withMin = (schema: z.YatspMiniString, n: number) => schema.check(z.minLength(n));
+
+  expect(z.parse(z.string().apply(withMin, 3), "abcd")).toBe("abcd");
+  expectTypeOf(
+    z.number().apply<z.YatspMiniNumber>((schema) => schema.check(z.minimum(0)))
+  ).toEqualTypeOf<z.YatspMiniNumber>();
+
+  // @ts-expect-error wrong arg type
+  z.string().apply(withMin, "3");
+  // @ts-expect-error missing arg
+  z.string().apply(withMin);
+  // @ts-expect-error extra arg for a single-parameter callback
+  z.string().apply((schema: z.YatspMiniString) => schema, 3);
+});

package/src/v4/mini/tests/assignability.test.ts

@@ -0,0 +1,190 @@
+import { expectTypeOf, test } from "vitest";
+
+import * as z from "yatsp/mini";
+
+test("assignability", () => {
+  // $YatspString
+  z.string() satisfies z.core.$YatspString;
+
+  // $YatspNumber
+  z.number() satisfies z.core.$YatspNumber;
+
+  // $YatspBigInt
+  z.bigint() satisfies z.core.$YatspBigInt;
+
+  // $YatspBoolean
+  z.boolean() satisfies z.core.$YatspBoolean;
+
+  // $YatspDate
+  z.date() satisfies z.core.$YatspDate;
+
+  // $YatspSymbol
+  z.symbol() satisfies z.core.$YatspSymbol;
+
+  // $YatspUndefined
+  z.undefined() satisfies z.core.$YatspUndefined;
+
+  // $YatspNullable
+  z.nullable(z.string()) satisfies z.core.$YatspNullable;
+
+  // $YatspNull
+  z.null() satisfies z.core.$YatspNull;
+
+  // $YatspAny
+  z.any() satisfies z.core.$YatspAny;
+
+  // $YatspUnknown
+  z.unknown() satisfies z.core.$YatspUnknown;
+
+  // $YatspNever
+  z.never() satisfies z.core.$YatspNever;
+
+  // $YatspVoid
+  z.void() satisfies z.core.$YatspVoid;
+
+  // $YatspArray
+  z.array(z.string()) satisfies z.core.$YatspArray;
+
+  // $YatspObject
+  z.object({ key: z.string() }) satisfies z.core.$YatspObject;
+
+  // $YatspUnion
+  z.union([z.string(), z.number()]) satisfies z.core.$YatspUnion;
+
+  // $YatspIntersection
+  z.intersection(z.string(), z.number()) satisfies z.core.$YatspIntersection;
+
+  // $YatspTuple
+  z.tuple([z.string(), z.number()]) satisfies z.core.$YatspTuple;
+
+  // $YatspRecord
+  z.record(z.string(), z.number()) satisfies z.core.$YatspRecord;
+
+  // $YatspMap
+  z.map(z.string(), z.number()) satisfies z.core.$YatspMap;
+
+  // $YatspSet
+  z.set(z.string()) satisfies z.core.$YatspSet;
+
+  // $YatspLiteral
+  z.literal("example") satisfies z.core.$YatspLiteral;
+
+  // $YatspEnum
+  z.enum(["a", "b", "c"]) satisfies z.core.$YatspEnum;
+
+  // $YatspPromise
+  z.promise(z.string()) satisfies z.core.$YatspPromise;
+
+  // $YatspLazy
+  const lazySchema = z.lazy(() => z.string());
+  lazySchema satisfies z.core.$YatspLazy;
+
+  // $YatspOptional
+  z.optional(z.string()) satisfies z.core.$YatspOptional;
+
+  // $YatspDefault
+  z._default(z.string(), "default") satisfies z.core.$YatspDefault;
+
+  // $YatspTemplateLiteral
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$YatspTemplateLiteral;
+
+  // $YatspCustom
+  z.custom<string>((val) => typeof val === "string") satisfies z.core.$YatspCustom;
+
+  // $YatspTransform
+  z.transform((val) => val as string) satisfies z.core.$YatspTransform;
+
+  // $YatspNonOptional
+  z.nonoptional(z.optional(z.string())) satisfies z.core.$YatspNonOptional;
+
+  // $YatspReadonly
+  z.readonly(z.object({ key: z.string() })) satisfies z.core.$YatspReadonly;
+
+  // $YatspNaN
+  z.nan() satisfies z.core.$YatspNaN;
+
+  // $YatspPipe
+  z.pipe(z.unknown(), z.number()) satisfies z.core.$YatspPipe;
+
+  // $YatspSuccess
+  z.success(z.string()) satisfies z.core.$YatspSuccess;
+
+  // $YatspCatch
+  z.catch(z.string(), "fallback") satisfies z.core.$YatspCatch;
+
+  // $YatspFile
+  z.file() satisfies z.core.$YatspFile;
+});
+
+test("toYatsp", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.nullable(z.string()),
+  });
+  const Company = z.toYatsp<Company>()(CompanySchema);
+
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = z.core.toYatsp<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toYatsp<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  const Transformed = z.toYatsp<{ count: number }>()(
+    z.object({
+      count: z.pipe(
+        z.string(),
+        z.transform((value) => value.length)
+      ),
+    })
+  );
+  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
+  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
+
+  z.toYatsp<Company>()(
+    // @ts-expect-error missing optional keys still fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+    })
+  );
+
+  z.toYatsp<Company>()(
+    // @ts-expect-error extra keys fail exact output matching
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+      extra: z.string(),
+    })
+  );
+
+  z.toYatsp<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.nullable(z.string()),
+    })
+  );
+});
+
+test("assignability with type narrowing", () => {
+  type _RefinedSchema<T extends z.YatspMiniType<object> | z.YatspMiniUnion> = T extends z.YatspMiniUnion
+    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
+    : T extends z.YatspMiniType<object>
+      ? RefinedTypeSchema<z.output<T>> // <-- Type instantiation is excessively deep and possibly infinite.
+      : never;
+
+  type RefinedTypeSchema<T extends object> = T;
+
+  type RefinedUnionSchema<T extends z.YatspMiniUnion> = T;
+});

package/src/v4/mini/tests/brand.test.ts

@@ -0,0 +1,94 @@
+import { expectTypeOf, test } from "vitest";
+import * as z from "../index.js";
+
+test("branded types", () => {
+  const mySchema = z
+    .object({
+      name: z.string(),
+    })
+    .brand<"superschema">();
+
+  // simple branding
+  type MySchema = z.infer<typeof mySchema>;
+  // Using true for type equality assertion
+  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
+
+  const doStuff = (arg: MySchema) => arg;
+  doStuff(z.parse(mySchema, { name: "hello there" }));
+
+  // inheritance
+  const extendedSchema = mySchema.brand<"subschema">();
+  type ExtendedSchema = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema"> & z.$brand<"subschema">>();
+
+  doStuff(z.parse(extendedSchema, { name: "hello again" }));
+
+  // number branding
+  const numberSchema = z.number().brand<42>();
+  type NumberSchema = z.infer<typeof numberSchema>;
+  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
+
+  // symbol branding
+  const MyBrand: unique symbol = Symbol("hello");
+  type MyBrand = typeof MyBrand;
+  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
+  type SymbolBrand = z.infer<typeof symbolBrand>;
+  // number & { [z.$brand]: { sup: true, [MyBrand]: true } }
+  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.$brand<"sup"> & z.$brand<MyBrand>>();
+
+  // keeping brands out of input types
+  const age = z.number().brand<"age">();
+  type Age1 = z.infer<typeof age>;
+  type AgeInput1 = z.input<typeof age>;
+
+  // Using not for type inequality assertion
+  expectTypeOf<AgeInput1>().not.toEqualTypeOf<Age1>();
+  expectTypeOf<number>().toEqualTypeOf<AgeInput1>();
+  expectTypeOf<number & z.$brand<"age">>().toEqualTypeOf<Age1>();
+
+  // @ts-expect-error
+  doStuff({ name: "hello there!" });
+});
+
+test("brand direction: out (default)", () => {
+  const schema = z.string().brand<"A">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded (default behavior)
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: out (explicit)", () => {
+  const schema = z.string().brand<"A", "out">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // output is branded
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+  // input is NOT branded
+  expectTypeOf<Input>().toEqualTypeOf<string>();
+});
+
+test("brand direction: in", () => {
+  const schema = z.string().brand<"A", "in">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // input is branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  // output is NOT branded
+  expectTypeOf<Output>().toEqualTypeOf<string>();
+});
+
+test("brand direction: inout", () => {
+  const schema = z.string().brand<"A", "inout">();
+  type Input = z.input<typeof schema>;
+  type Output = z.output<typeof schema>;
+
+  // both are branded
+  expectTypeOf<Input>().toEqualTypeOf<string & z.$brand<"A">>();
+  expectTypeOf<Output>().toEqualTypeOf<string & z.$brand<"A">>();
+});

package/src/v4/mini/tests/checks.test.ts

@@ -0,0 +1,158 @@
+import { expect, test } from "vitest";
+import * as z from "../index.js";
+
+// lt;
+test("z.lt", () => {
+  const a = z.number().check(z.lt(10));
+  expect(z.safeParse(a, 9).success).toEqual(true);
+  expect(z.safeParse(a, 9).data).toEqual(9);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// lte;
+test("z.lte", () => {
+  const a = z.number().check(z.lte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// min;
+test("z.max", () => {
+  const a = z.number().check(z.maximum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 11).success).toEqual(false);
+});
+
+// gt;
+test("z.gt", () => {
+  const a = z.number().check(z.gt(10));
+  expect(z.safeParse(a, 11).success).toEqual(true);
+  expect(z.safeParse(a, 11).data).toEqual(11);
+  expect(z.safeParse(a, 10).success).toEqual(false);
+});
+
+// gte;
+test("z.gte", () => {
+  const a = z.number().check(z.gte(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+test("z.gte/z.lte origin on a date schema with a numeric bound", () => {
+  const bound = new Date(Date.UTC(2022, 10, 5)).getTime();
+  const tooSmall = z.safeParse(z.date().check(z.gte(bound)), new Date(Date.UTC(2022, 10, 4)));
+  const tooBig = z.safeParse(z.date().check(z.lte(bound)), new Date(Date.UTC(2022, 10, 6)));
+  expect(tooSmall.error!.issues[0]).toMatchObject({ code: "too_small", origin: "date" });
+  expect(tooBig.error!.issues[0]).toMatchObject({ code: "too_big", origin: "date" });
+});
+
+// min;
+test("z.min", () => {
+  const a = z.number().check(z.minimum(10));
+  expect(z.safeParse(a, 10).success).toEqual(true);
+  expect(z.safeParse(a, 10).data).toEqual(10);
+  expect(z.safeParse(a, 9).success).toEqual(false);
+});
+
+// maxSize;
+test("z.maxLength", () => {
+  const a = z.array(z.string()).check(z.maxLength(3));
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// minSize;
+test("z.minLength", () => {
+  const a = z.array(z.string()).check(z.minLength(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+});
+
+// size;
+test("z.length", () => {
+  const a = z.array(z.string()).check(z.length(3));
+  expect(z.safeParse(a, ["a", "b"]).success).toEqual(false);
+  expect(z.safeParse(a, ["a", "b", "c"]).success).toEqual(true);
+  expect(z.safeParse(a, ["a", "b", "c", "d"]).success).toEqual(false);
+});
+
+// regex;
+test("z.regex", () => {
+  const a = z.string().check(z.regex(/^aaa$/));
+  expect(z.safeParse(a, "aaa")).toMatchObject({ success: true, data: "aaa" });
+  expect(z.safeParse(a, "aa")).toMatchObject({ success: false });
+});
+
+// includes;
+test("z.includes", () => {
+  const a = z.string().check(z.includes("asdf"));
+  z.parse(a, "qqqasdfqqq");
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// startsWith;
+test("z.startsWith", () => {
+  const a = z.string().check(z.startsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "asdfqqq");
+  expect(z.safeParse(a, "qqq")).toMatchObject({ success: false });
+});
+
+// endsWith;
+test("z.endsWith", () => {
+  const a = z.string().check(z.endsWith("asdf"));
+  z.parse(a, "asdf");
+  z.parse(a, "qqqasdf");
+  expect(z.safeParse(a, "asdfqqq")).toMatchObject({ success: false });
+});
+
+// lowercase;
+test("z.lowercase", () => {
+  const a = z.string().check(z.lowercase());
+  z.parse(a, "asdf");
+  expect(z.safeParse(a, "ASDF")).toMatchObject({ success: false });
+});
+
+// uppercase;
+test("z.uppercase", () => {
+  const a = z.string().check(z.uppercase());
+  z.parse(a, "ASDF");
+  expect(z.safeParse(a, "asdf")).toMatchObject({ success: false });
+});
+
+// filename;
+// fileType;
+// overwrite;
+test("z.overwrite", () => {
+  const a = z.string().check(z.overwrite((val) => val.toUpperCase()));
+  expect(z.safeParse(a, "asdf")).toMatchObject({ data: "ASDF" });
+});
+
+// normalize;
+// trim;
+// toLowerCase;
+// toUpperCase;
+// property
+
+test("z.properties", () => {
+  const a = z.instanceof(URL).check(...z.properties({ protocol: z.literal("https:"), hostname: z.string() }));
+  expect(z.safeParse(a, new URL("https://example.com")).success).toEqual(true);
+  expect(z.safeParse(a, new URL("http://example.com")).error!.issues.map((i) => i.path)).toEqual([["protocol"]]);
+});
+
+test("abort early", () => {
+  const schema = z.string().check(
+    z.refine((val) => val.length > 1),
+    z.refine((val) => val.length > 2, { abort: true }),
+    z.refine((val) => val.length > 3)
+  );
+  const data = "";
+  const result = z.safeParse(schema, data);
+  expect(result.error!.issues.length).toEqual(2);
+});