@willaimg/yatsp 4.3.6

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

@@ -0,0 +1,402 @@
+import { expectTypeOf, test } from "vitest";
+
+import * as z from "yatsp/v4";
+import * as core from "yatsp/v4/core";
+
+test("assignability", () => {
+  // $YatspString
+  z.string() satisfies z.core.$YatspString;
+  z.string() satisfies z.YatspString;
+
+  // $YatspNumber
+  z.number() satisfies z.core.$YatspNumber;
+  z.number() satisfies z.YatspNumber;
+
+  // $YatspBigInt
+  z.bigint() satisfies z.core.$YatspBigInt;
+  z.bigint() satisfies z.YatspBigInt;
+
+  // $YatspBoolean
+  z.boolean() satisfies z.core.$YatspBoolean;
+  z.boolean() satisfies z.YatspBoolean;
+
+  // $YatspDate
+  z.date() satisfies z.core.$YatspDate;
+  z.date() satisfies z.YatspDate;
+
+  // $YatspSymbol
+  z.symbol() satisfies z.core.$YatspSymbol;
+  z.symbol() satisfies z.YatspSymbol;
+
+  // $YatspUndefined
+  z.undefined() satisfies z.core.$YatspUndefined;
+  z.undefined() satisfies z.YatspUndefined;
+
+  // $YatspNullable
+  z.string().nullable() satisfies z.core.$YatspNullable;
+  z.string().nullable() satisfies z.YatspNullable;
+
+  // $YatspNull
+  z.null() satisfies z.core.$YatspNull;
+  z.null() satisfies z.YatspNull;
+
+  // $YatspAny
+  z.any() satisfies z.core.$YatspAny;
+  z.any() satisfies z.YatspAny;
+
+  // $YatspUnknown
+  z.unknown() satisfies z.core.$YatspUnknown;
+  z.unknown() satisfies z.YatspUnknown;
+
+  // $YatspNever
+  z.never() satisfies z.core.$YatspNever;
+  z.never() satisfies z.YatspNever;
+
+  // $YatspVoid
+  z.void() satisfies z.core.$YatspVoid;
+  z.void() satisfies z.YatspVoid;
+
+  // $YatspArray
+  z.array(z.string()) satisfies z.core.$YatspArray;
+  z.array(z.string()) satisfies z.YatspArray;
+  z.array(z.string()) satisfies z.YatspType<Array<unknown>>;
+
+  // $YatspObject
+  z.object({ key: z.string() }) satisfies z.core.$YatspObject;
+  z.object({ key: z.string() }) satisfies z.YatspObject<{ key: z.YatspType }>;
+  z.object({ key: z.string() }) satisfies z.YatspType<{ key: string }>;
+
+  // $YatspUnion
+  z.union([z.string(), z.number()]) satisfies z.core.$YatspUnion;
+  z.union([z.string(), z.number()]) satisfies z.YatspUnion;
+  z.union([z.string(), z.number()]) satisfies z.YatspType<string | number>;
+
+  // $YatspIntersection
+  z.intersection(z.string(), z.number()) satisfies z.core.$YatspIntersection;
+  z.intersection(z.string(), z.number()) satisfies z.YatspIntersection;
+
+  // $YatspTuple
+  z.tuple([z.string(), z.number()]) satisfies z.core.$YatspTuple;
+  z.tuple([z.string(), z.number()]) satisfies z.YatspTuple;
+
+  // $YatspRecord
+  z.record(z.string(), z.number()) satisfies z.core.$YatspRecord;
+  z.record(z.string(), z.number()) satisfies z.YatspRecord;
+
+  // $YatspMap
+  z.map(z.string(), z.number()) satisfies z.core.$YatspMap;
+  z.map(z.string(), z.number()) satisfies z.YatspMap;
+
+  // $YatspSet
+  z.set(z.string()) satisfies z.core.$YatspSet;
+  z.set(z.string()) satisfies z.YatspSet;
+
+  // $YatspLiteral
+  z.literal("example") satisfies z.core.$YatspLiteral;
+  z.literal("example") satisfies z.YatspLiteral;
+
+  // $YatspEnum
+  z.enum(["a", "b", "c"]) satisfies z.core.$YatspEnum;
+  z.enum(["a", "b", "c"]) satisfies z.YatspEnum;
+
+  // $YatspPromise
+  z.promise(z.string()) satisfies z.core.$YatspPromise;
+  z.promise(z.string()) satisfies z.YatspPromise;
+
+  // $YatspLazy
+  const lazySchema = z.lazy(() => z.string());
+  lazySchema satisfies z.core.$YatspLazy;
+  lazySchema satisfies z.YatspLazy;
+
+  // $YatspOptional
+  z.string().optional() satisfies z.core.$YatspOptional;
+  z.string().optional() satisfies z.YatspOptional;
+
+  // $YatspDefault
+  z.string().default("default") satisfies z.core.$YatspDefault;
+  z.string().default("default") satisfies z.YatspDefault;
+
+  // $YatspTemplateLiteral
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.core.$YatspTemplateLiteral;
+  z.templateLiteral([z.literal("a"), z.literal("b")]) satisfies z.YatspTemplateLiteral;
+
+  // $YatspCustom
+  z.custom<string>((val) => typeof val === "string") satisfies z.core.$YatspCustom;
+  z.custom<string>((val) => typeof val === "string") satisfies z.YatspCustom;
+
+  // $YatspTransform
+  z.transform((val) => val as string) satisfies z.core.$YatspTransform;
+  z.transform((val) => val as string) satisfies z.YatspTransform;
+
+  // $YatspNonOptional
+  z.string().optional().nonoptional() satisfies z.core.$YatspNonOptional;
+  z.string().optional().nonoptional() satisfies z.YatspNonOptional;
+
+  // $YatspReadonly
+  z.object({ key: z.string() }).readonly() satisfies z.core.$YatspReadonly;
+  z.object({ key: z.string() }).readonly() satisfies z.YatspReadonly;
+
+  // $YatspNaN
+  z.nan() satisfies z.core.$YatspNaN;
+  z.nan() satisfies z.YatspNaN;
+
+  // $YatspPipe
+  z.unknown().pipe(z.number()) satisfies z.core.$YatspPipe;
+  z.unknown().pipe(z.number()) satisfies z.YatspPipe;
+
+  // $YatspPreprocess
+  z.preprocess((v) => v, z.number()) satisfies z.core.$YatspPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.YatspPreprocess;
+  z.preprocess((v) => v, z.number()) satisfies z.core.$YatspPipe<z.core.$YatspTransform, z.YatspNumber>;
+  z.preprocess((v) => v, z.number()) satisfies z.YatspPipe<z.core.$YatspTransform, z.YatspNumber>;
+
+  // $YatspSuccess
+  z.success(z.string()) satisfies z.core.$YatspSuccess;
+  z.success(z.string()) satisfies z.YatspSuccess;
+
+  // $YatspCatch
+  z.string().catch("fallback") satisfies z.core.$YatspCatch;
+  z.string().catch("fallback") satisfies z.YatspCatch;
+
+  // $YatspFile
+  z.file() satisfies z.core.$YatspFile;
+  z.file() satisfies z.YatspFile;
+});
+
+test("toYatsp", () => {
+  type Company = {
+    id: string;
+    name: string;
+    webAddress: string | null;
+  };
+
+  const CompanySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    webAddress: z.string().url().nullable(),
+  });
+  const Company = z.toYatsp<Company>()(CompanySchema);
+
+  Company.shape.id.min(1);
+  expectTypeOf<z.output<typeof Company>>().toEqualTypeOf<Company>();
+
+  const CoreCompany = core.toYatsp<Company>()(CompanySchema);
+  expectTypeOf<core.output<typeof CoreCompany>>().toEqualTypeOf<Company>();
+
+  const UtilCompany = z.core.util.toYatsp<Company>()(CompanySchema);
+  expectTypeOf<z.output<typeof UtilCompany>>().toEqualTypeOf<Company>();
+
+  type Complex = {
+    kind: "company";
+    nested: {
+      founded: Date;
+      tags: string[];
+    };
+    scores: Record<"a" | "b", number>;
+    tuple: [string, number];
+    status: "active" | "inactive";
+  };
+
+  const Complex = z.toYatsp<Complex>()(
+    z.object({
+      kind: z.literal("company"),
+      nested: z.object({
+        founded: z.date(),
+        tags: z.array(z.string()),
+      }),
+      scores: z.record(z.enum(["a", "b"]), z.number()),
+      tuple: z.tuple([z.string(), z.number()]),
+      status: z.union([z.literal("active"), z.literal("inactive")]),
+    })
+  );
+  expectTypeOf<z.output<typeof Complex>>().toEqualTypeOf<Complex>();
+
+  type Items = {
+    items: { value: string }[];
+  };
+
+  const Items = z.toYatsp<Items>()(
+    z.object({
+      items: z.array(z.object({ value: z.string() })),
+    })
+  );
+  expectTypeOf<z.output<typeof Items>>().toEqualTypeOf<Items>();
+
+  type ReadonlyItem = Readonly<{
+    id: string;
+  }>;
+
+  const ReadonlyItem = z.toYatsp<ReadonlyItem>()(z.object({ id: z.string() }).readonly());
+  expectTypeOf<z.output<typeof ReadonlyItem>>().toEqualTypeOf<ReadonlyItem>();
+
+  const Transformed = z.toYatsp<{ count: number }>()(
+    z.object({
+      count: z.string().transform((value) => value.length),
+    })
+  );
+  expectTypeOf<z.input<typeof Transformed>>().toEqualTypeOf<{ count: string }>();
+  expectTypeOf<z.output<typeof Transformed>>().toEqualTypeOf<{ count: number }>();
+
+  // An enum target matches z.enum(...) even though the enum reference is not identical to the union of its members (#6524)
+  enum SkillLevel {
+    Noob = "noob",
+    Pro = "pro",
+  }
+  enum Rank {
+    First = 1,
+    Second = 2,
+  }
+
+  z.toYatsp<SkillLevel>()(z.enum(SkillLevel));
+  const Enums = z.toYatsp<{
+    skill: SkillLevel;
+    members: SkillLevel.Noob | SkillLevel.Pro;
+    rank: Rank;
+    maybe: SkillLevel | null;
+    list: SkillLevel[];
+    nested: { skill: SkillLevel };
+  }>()(
+    z.object({
+      skill: z.enum(SkillLevel),
+      members: z.enum(SkillLevel),
+      rank: z.enum(Rank),
+      maybe: z.enum(SkillLevel).nullable(),
+      list: z.array(z.enum(SkillLevel)),
+      nested: z.object({ skill: z.enum(SkillLevel) }),
+    })
+  );
+  expectTypeOf<z.output<typeof Enums>["skill"]>().toEqualTypeOf<SkillLevel>();
+
+  // @ts-expect-error a member subset is not the enum
+  z.toYatsp<{ skill: SkillLevel }>()(z.object({ skill: z.literal(SkillLevel.Noob) }));
+
+  // @ts-expect-error plain literals do not match a nominal enum target
+  z.toYatsp<{ skill: SkillLevel }>()(z.object({ skill: z.enum(["noob", "pro"]) }));
+
+  // @ts-expect-error an enum schema does not match a plain literal-union target
+  z.toYatsp<{ skill: "noob" | "pro" }>()(z.object({ skill: z.enum(SkillLevel) }));
+
+  // @ts-expect-error plain numeric literals do not match a numeric enum target either
+  z.toYatsp<{ rank: Rank }>()(z.object({ rank: z.union([z.literal(1), z.literal(2)]) }));
+
+  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.string().url().nullable(),
+      extra: z.string(),
+    })
+  );
+
+  z.toYatsp<Company>()(
+    // @ts-expect-error wrong property output fails matching
+    z.object({
+      id: z.number(),
+      name: z.string(),
+      webAddress: z.string().url().nullable(),
+    })
+  );
+
+  z.toYatsp<ReadonlyItem>()(
+    // @ts-expect-error readonly output is required
+    z.object({
+      id: z.string(),
+    })
+  );
+
+  // @ts-expect-error any is only an exact match for any
+  z.toYatsp<string>()(z.any());
+
+  // @ts-expect-error toYatsp checks output, not input
+  z.toYatsp<string>()(z.string().transform((value) => value.length));
+
+  // Exact equality is deliberately the only mode. A bidirectional-assignability mode would accept both of the two cases above — `any` is assignable in both directions by construction, and `readonly` is not part of assignability — so it would silently drop the guarantees the rest of this test pins.
+
+  // An intersection and the flat object with the same keys are interchangeable as targets, since the normalizer flattens both.
+  type Intersected = { a: number } & { b: string };
+  const viaAnd = z.object({ a: z.number() }).and(z.object({ b: z.string() }));
+  const viaExtend = z.object({ a: z.number() }).safeExtend({ b: z.string() });
+
+  z.toYatsp<Intersected>()(viaAnd);
+  z.toYatsp<Intersected>()(viaExtend);
+  z.toYatsp<{ a: number; b: string }>()(viaAnd);
+  z.toYatsp<{ a: number; b: string }>()(viaExtend);
+
+  // @ts-expect-error a missing key is still a missing key
+  z.toYatsp<Intersected>()(z.object({ a: z.number() }));
+
+  // `keyof` a function is `never`, so the normalizer must not walk into one — mapping it would erase the signature and make every callable compare equal
+  z.toYatsp<() => string>()(z.custom<() => string>());
+
+  // @ts-expect-error an incompatible callable output is still rejected
+  z.toYatsp<() => string>()(z.custom<() => number>());
+
+  // @ts-expect-error and so is an incompatible function-valued property
+  z.toYatsp<{ cb: (x: number) => void }>()(z.object({ cb: z.custom<(x: string) => void>() }));
+
+  // @ts-expect-error a method-bearing generic keeps its type arguments
+  z.toYatsp<{ m: Map<string, number> }>()(z.object({ m: z.custom<Map<string, string>>() }));
+});
+
+test("checks", () => {
+  const _a: z.core.$YatspCheck = {} as any as z.core.$YatspChecks;
+  const _b: z.core.$YatspCheck = {} as any as z.core.$YatspStringFormatChecks;
+  const _c: z.core.$YatspType = {} as any as z.core.$YatspTypes;
+  const _d: z.core.$YatspType = {} as any as z.core.$YatspStringFormatTypes;
+  z.currencyCode() satisfies z.core.$YatspStringFormatTypes;
+});
+
+test("assignability to $YatspType", () => {
+  z.string() satisfies z.YatspType;
+  z.number() satisfies z.YatspType;
+  z.boolean() satisfies z.YatspType;
+  z.object({ key: z.string() }) satisfies z.YatspType;
+  z.object({ key: z.string() }) satisfies z.YatspType<{ key: string }>;
+  z.array(z.string()) satisfies z.YatspType;
+  z.union([z.string(), z.number()]) satisfies z.YatspType;
+  z.intersection(z.string(), z.number()) satisfies z.YatspType;
+  z.tuple([z.string(), z.number()]) satisfies z.YatspType;
+  z.record(z.string(), z.number()) satisfies z.YatspType;
+  z.map(z.string(), z.number()) satisfies z.YatspType;
+  z.set(z.string()) satisfies z.YatspType;
+  z.literal("example") satisfies z.YatspType;
+
+  expectTypeOf<z.YatspType extends z.core.$YatspType ? true : false>().toEqualTypeOf<true>();
+});
+
+test("assignability with narrowing", () => {
+  type _RefinedSchema<T extends z.YatspType<object> | z.YatspUnion> = T extends z.YatspUnion
+    ? RefinedUnionSchema<T> // <-- Type instantiation is excessively deep and possibly infinite.
+    : T extends z.YatspType<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.YatspUnion> = T;
+});
+
+test("generic assignability in objects", () => {
+  interface SortItem<T extends string> {
+    key: T;
+    order: string;
+  }
+
+  const createSortItemSchema = <T extends z.YatspType<string>>(sortKeySchema: T) =>
+    z.object({
+      key: sortKeySchema,
+      order: z.string(),
+    });
+
+  <T extends z.YatspType<string>>(sortKeySchema: T, defaultSortBy: SortItem<z.output<T>>[] = []) =>
+    createSortItemSchema(sortKeySchema).array().default(defaultSortBy);
+});