@willaimg/yatsp 4.3.6

package/src/v4/classic/tests/instance-footprint.test.ts

@@ -0,0 +1,319 @@
+import { expect, test } from "vitest";
+
+import * as zm from "yatsp/mini";
+import * as z from "yatsp/v4";
+import * as core from "yatsp/v4/core";
+
+// V8 sizes an instance's property backing store in steps, and schema instances get no in-object slots (their constructor assigns nothing itself): 12 own properties cost 128 bytes, 13 cost 848, 21 cost 1616. Methods therefore live on the prototype and materialize per instance on first read. These bounds are what keeps a schema graph small; crossing one silently multiplies its memory by 6x.
+const MAX_OWN_PROPS = 12;
+
+test("schema instances stay under V8's property-count step", () => {
+  const cases: Array<[string, object]> = [
+    ["string", z.string()],
+    ["number", z.number()],
+    ["bigint", z.bigint()],
+    ["boolean", z.boolean()],
+    ["date", z.date()],
+    ["enum", z.enum(["a", "b"])],
+    ["array", z.array(z.string())],
+    ["object", z.object({ a: z.string() })],
+    ["record", z.record(z.string(), z.string())],
+    ["map", z.map(z.string(), z.string())],
+    ["set", z.set(z.string())],
+    ["union", z.union([z.string(), z.number()])],
+    ["optional", z.string().optional()],
+    ["pipe", z.string().pipe(z.string())],
+    ["email", z.email()],
+    ["mini string", zm.string()],
+    ["mini object", zm.object({ a: zm.string() })],
+  ];
+
+  const over = cases
+    .map(([name, schema]) => [name, Reflect.ownKeys(schema).length] as const)
+    .filter(([, count]) => count > MAX_OWN_PROPS);
+
+  expect(over).toEqual([]);
+});
+
+test("prototype-installed members survive detaching", () => {
+  const schema = z.string();
+  const { parse, safeParse, spa } = schema;
+
+  expect(parse("hi")).toEqual("hi");
+  expect(safeParse("hi").success).toEqual(true);
+  expect(["a", "b"].map((v) => parse(v))).toEqual(["a", "b"]);
+  expect(spa).toBe(schema.safeParseAsync);
+
+  const email = schema.email;
+  expect(email().safeParse("a@b.co").success).toEqual(true);
+});
+
+test("prototype-installed members can be overwritten per instance", () => {
+  const schema: any = z.string();
+  schema.parse = () => "overridden";
+
+  expect(schema.parse("anything")).toEqual("overridden");
+  expect(z.string().parse("untouched")).toEqual("untouched");
+});
+
+test("~standard is lazy but complete", () => {
+  const schema = z.string();
+
+  expect(Object.prototype.hasOwnProperty.call(schema, "~standard")).toEqual(false);
+  expect(schema["~standard"].vendor).toEqual("yatsp");
+  expect(schema["~standard"].version).toEqual(1);
+  expect(schema["~standard"].validate("hi")).toEqual({ value: "hi" });
+  expect((schema["~standard"] as any).jsonSchema.input()).toMatchObject({ type: "string" });
+  // Reading it caches on the instance, so the getter runs once.
+  expect(Object.prototype.hasOwnProperty.call(schema, "~standard")).toEqual(true);
+});
+
+test("caching a lazy member preserves its original enumerability", () => {
+  const schema = z.string();
+
+  // Methods were enumerable own properties before they moved to the prototype, so touching one still surfaces it to `Object.keys`.
+  void schema.parse;
+  void schema.optional;
+  expect(Object.keys(schema)).toContain("parse");
+  expect(Object.keys(schema)).toContain("optional");
+
+  // `~standard` never was an own data property, so caching it must not add it to `Object.keys` or to `JSON.stringify` of a schema.
+  void schema["~standard"];
+  expect(Object.keys(schema)).not.toContain("~standard");
+  expect(JSON.stringify(schema)).not.toContain("~standard");
+
+  // An explicit assignment behaves like one, as before.
+  const other: any = z.string();
+  other["~standard"] = { vendor: "x" };
+  expect(Object.keys(other)).toContain("~standard");
+});
+
+test("_def stays read-only", () => {
+  expect(() => {
+    (z.string() as any)._def = {};
+  }).toThrow(TypeError);
+  expect(() => {
+    (z.function({ input: [z.string()], output: z.number() }) as any)._def = {};
+  }).toThrow(TypeError);
+  const schema = z.string();
+  expect(schema._def).toBe(schema._yatsp.def);
+  expect(z.object({ a: z.string() })._def.type).toEqual("object");
+});
+
+test("deferred initializers are released after construction", () => {
+  expect(z.string()._yatsp.deferred).toEqual(undefined);
+  expect(z.object({ a: z.string() })._yatsp.deferred).toEqual(undefined);
+});
+
+test("trait initializers run once per instance across repeated entry", () => {
+  const calls: string[] = [];
+  const Base: core.$constructor<any> = core.$constructor<any>("CountedBase", () => calls.push("base"));
+  const Child: core.$constructor<any> = core.$constructor<any>("CountedChild", (inst, def) => {
+    calls.push("child");
+    Base.init(inst, def);
+    Base.init(inst, def);
+  });
+  const constructed = new Child({});
+  Child.init(constructed, {});
+  const direct = Object.create({});
+  Child.init(direct, {});
+  Child.init(direct, {});
+  expect(calls).toEqual(["child", "base", "child", "base"]);
+  for (const inst of [constructed, direct]) {
+    expect([...inst._yatsp.traits]).toEqual(["CountedChild", "CountedBase"]);
+    expect(inst instanceof Base).toBe(true);
+    expect(inst instanceof Child).toBe(true);
+  }
+  expect(constructed._yatsp.traits).not.toBe(direct._yatsp.traits);
+});
+
+test("a trait initializer called directly still installs its members", () => {
+  // a direct `init` installs onto the receiver's own prototype, since it is not below the constructor's
+  z.string();
+
+  const proto = {};
+  const inst = Object.create(proto) as z.YatspString;
+  z.YatspString.init(inst, { type: "string" });
+
+  expect(typeof inst.email).toBe("function");
+  expect(typeof inst.optional).toBe("function");
+  expect(Object.prototype.hasOwnProperty.call(proto, "email")).toBe(true);
+});
+
+test("a nested init during a repeat construction still installs its members", () => {
+  // the install used to read a module-level flag the outer construction set, so a nested `init` on an unrelated receiver inherited an answer that was not about it
+  const seen: string[] = [];
+
+  // an assertion signature needs the call target explicitly annotated
+  const Nested: core.$constructor<any> = core.$constructor<any>("Nested", () => {}, {
+    tag() {
+      return "nested";
+    },
+  });
+  const Outer = core.$constructor<any>("Outer", (_inst, def) => {
+    if (!def.nest) return;
+    // not a plain `{}`: the install target would resolve to `Object.prototype` and leak `tag` into every object the worker touches
+    const plain: any = Object.create({});
+    Nested.init(plain, {});
+    seen.push(typeof plain.tag);
+  });
+
+  new Outer({ nest: false });
+  new Outer({ nest: true });
+
+  expect(seen).toEqual(["function"]);
+});
+
+test("a derived trait's members win over the ones it composes", () => {
+  // Classic installs a richer `~standard` over core's. Trait dedupe is what orders them: core's initializer runs once, at the first `init` that reaches it, so classic's always lands second.
+  expect(typeof (z.string()["~standard"] as any).jsonSchema.input).toBe("function");
+});
+
+test("a live member keeps the descriptor a prototype member had", () => {
+  // An object literal's getter is enumerable; the `defineProperty` it replaced was not. `for..in` over a schema is public surface, and the construction path walks the prototype with it.
+  const proto = Object.getPrototypeOf(z.string());
+  expect(Object.getOwnPropertyDescriptor(proto, "description")?.enumerable).toBe(false);
+  expect(Object.getOwnPropertyDescriptor(proto, "_def")?.enumerable).toBe(false);
+  // a derived member installs like a literal's accessor: not enumerable, still configurable
+  expect(Object.getOwnPropertyDescriptor(proto, "minLength")).toMatchObject({ enumerable: false, configurable: true });
+
+  // the derived metadata members live on the prototype and shadow as own data on first read
+  const schema = z.string();
+  const keys: string[] = [];
+  for (const k in schema) keys.push(k);
+  expect(keys).toEqual(["def", "type"]);
+  expect(schema.minLength).toBe(null);
+  expect(Object.keys(schema)).toContain("minLength");
+});
+
+test("a live member is not cached per instance", () => {
+  const schema = z.string();
+
+  expect(schema.description).toBe(undefined);
+  core.globalRegistry.add(schema, { description: "later" });
+  expect(schema.description).toBe("later");
+  expect(Object.prototype.hasOwnProperty.call(schema, "description")).toBe(false);
+});
+
+test("constructing through a subclass does not strip the base prototype", () => {
+  // `super(def)` gives `this` a prototype of `new.target.prototype`, so a constructor can complete a construction without having built its own prototype.
+  const MyString: new (def: { type: "string" }) => z.YatspString = class extends (z.YatspString as any) {} as any;
+  new MyString({ type: "string" });
+
+  const plain = z.string();
+  expect(plain.parse("x")).toBe("x");
+  expect(typeof plain.email).toBe("function");
+  expect(typeof new MyString({ type: "string" }).email).toBe("function");
+});
+
+test("a subclass's own members survive the install", () => {
+  // The members go on the prototype of the constructor that built the instance, so a subclass's own prototype keeps what it declared. `z.symbol()` is constructed nowhere else here, which puts the subclass before its base — the ordering the install has to get right. Asserted rather than assumed, so warming it elsewhere fails the test instead of hollowing it out.
+  expect(Object.prototype.hasOwnProperty.call((z.YatspSymbol as any).prototype, "parse")).toBe(false);
+  const First = class extends (z.YatspSymbol as any) {
+    parse() {
+      return "PARSE";
+    }
+    optional() {
+      return "OPTIONAL";
+    }
+  } as any;
+  const first = new First({ type: "symbol" });
+  expect(first.parse(Symbol())).toBe("PARSE");
+  expect(first.optional()).toBe("OPTIONAL");
+  const sym = Symbol();
+  expect(z.symbol().parse(sym)).toBe(sym);
+
+  // and the other way round, with the base prototype already built by one of the `z.number()` calls above. Asserted for the same reason: warm it nowhere and this block quietly becomes a second copy of the cold case.
+  expect(Object.prototype.hasOwnProperty.call((z.YatspNumber as any).prototype, "parse")).toBe(true);
+  const Second = class extends (z.YatspNumber as any) {
+    parse() {
+      return "SECOND";
+    }
+  } as any;
+  expect(new Second({ type: "number" }).parse(1)).toBe("SECOND");
+
+  // two levels deep: neither prototype takes a copy, so the inherited member is one function
+  const Third = class extends (Second as any) {} as any;
+  new Third({ type: "number" });
+  expect(Second.prototype.parse).toBe(Third.prototype.parse);
+});
+
+test("a hand-written getter member accepts assignment", () => {
+  // Every member was an accessor with a setter before they moved onto `proto`, so a getter written by hand needs one too.
+  const schema: any = z.string();
+  schema.spa = () => "SPA";
+  schema.toJSONSchema = () => "JSON";
+  expect(schema.spa()).toBe("SPA");
+  expect(schema.toJSONSchema()).toBe("JSON");
+
+  const mini: any = zm.string();
+  mini.with = () => "WITH";
+  expect(mini.with()).toBe("WITH");
+
+  // a derived metadata member accepts assignment before its first read, as it did as an own property
+  const derived = z.number().min(2);
+  derived.minValue = 99;
+  expect(derived.minValue).toBe(99);
+  expect(Object.keys(derived)).toContain("minValue");
+
+  // and, like every prototype member, recomputes after deletion rather than staying absent
+  delete (derived as any).minValue;
+  expect(derived.minValue).toBe(2);
+});
+
+test("shape is lazy and stays out of Object.keys", () => {
+  const schema = z.object({ a: z.string() });
+
+  expect(Object.prototype.hasOwnProperty.call(schema, "shape")).toEqual(false);
+  expect("shape" in schema).toEqual(true);
+  expect(Object.keys(schema)).not.toContain("shape");
+  expect({ ...schema }).not.toHaveProperty("shape");
+
+  expect(Object.keys(schema.shape)).toEqual(["a"]);
+
+  // Reading caches a non-enumerable own data property. An own accessor here would put every later object schema into V8 dictionary mode.
+  expect(Object.prototype.hasOwnProperty.call(schema, "shape")).toEqual(true);
+  expect(Object.getOwnPropertyDescriptor(schema, "shape")).toMatchObject({
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+  expect(Object.keys(schema)).not.toContain("shape");
+
+  const mini = zm.object({ a: zm.string() });
+  expect(Object.prototype.hasOwnProperty.call(mini, "shape")).toEqual(false);
+  expect(Object.keys(mini.shape)).toEqual(["a"]);
+  expect(Object.keys(mini)).not.toContain("shape");
+});
+
+test("shape accepts repeated assignment and recomputes after deletion", () => {
+  const schema: any = z.object({ a: z.string() });
+
+  schema.shape = { b: z.number() };
+  expect(Object.keys(schema.shape)).toEqual(["b"]);
+  // The cached property stays writable, so a second assignment does not throw in strict mode.
+  schema.shape = { c: z.boolean() };
+  expect(Object.keys(schema.shape)).toEqual(["c"]);
+
+  // Deleting clears the memo rather than removing the property, since the accessor lives on the prototype.
+  delete schema.shape;
+  expect(Object.keys(schema.shape)).toEqual(["a"]);
+});
+
+test("a self-referential shape getter breaks the cycle instead of recursing", () => {
+  const Self: any = z.object({
+    a: z.string(),
+    get b() {
+      return z.array(z.object(Self.shape));
+    },
+  });
+  expect(Object.keys(Self.shape)).toEqual(["a", "b"]);
+
+  const Mini: any = zm.object({
+    a: zm.string(),
+    get b() {
+      return zm.array(zm.object(Mini.shape));
+    },
+  });
+  expect(Object.keys(Mini.shape)).toEqual(["a", "b"]);
+});

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

@@ -0,0 +1,127 @@
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "yatsp/v4";
+
+test("instanceof", async () => {
+  class Test {}
+  class Subtest extends Test {}
+  abstract class AbstractBar {
+    constructor(public val: string) {}
+  }
+  class Bar extends AbstractBar {}
+
+  const TestSchema = z.instanceof(Test);
+  const SubtestSchema = z.instanceof(Subtest);
+  const AbstractSchema = z.instanceof(AbstractBar);
+  const BarSchema = z.instanceof(Bar);
+
+  TestSchema.parse(new Test());
+  TestSchema.parse(new Subtest());
+  SubtestSchema.parse(new Subtest());
+  AbstractSchema.parse(new Bar("asdf"));
+  const bar = BarSchema.parse(new Bar("asdf"));
+  expect(bar.val).toEqual("asdf");
+
+  await expect(() => SubtestSchema.parse(new Test())).toThrow();
+  await expect(() => TestSchema.parse(12)).toThrow();
+
+  expectTypeOf<Test>().toEqualTypeOf<z.infer<typeof TestSchema>>();
+});
+
+test("instanceof fatal", () => {
+  const schema = z.instanceof(Date).refine((d) => d.toString());
+  const res = schema.safeParse(null);
+  expect(res.success).toBe(false);
+});
+
+test("instanceof respects customError", () => {
+  class Test {
+    name!: string;
+  }
+
+  z.config({
+    customError: () => {
+      return "This is invalid!";
+    },
+  });
+
+  const TestSchema = z.instanceof(Test);
+  const result = TestSchema.safeParse("whatever");
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    expect(issue.code).toBe("invalid_type");
+    if (issue.code === "invalid_type") {
+      expect(issue.expected).toBe("Test");
+    }
+    expect(issue.message).toBe("This is invalid!");
+  }
+
+  z.config({ customError: undefined });
+});
+
+test("z.properties", () => {
+  const httpsUrl = z.instanceof(URL).check(
+    ...z.properties({
+      protocol: z.literal("https:"),
+      hostname: z.string().regex(z.regexes.domain),
+    })
+  );
+
+  expectTypeOf<URL>().toEqualTypeOf<z.infer<typeof httpsUrl>>();
+  expect(httpsUrl.safeParse(new URL("https://example.com")).success).toBe(true);
+
+  // One check iterates the whole shape, so every failing property reports — unlike the equivalent chain of z.property() calls, which aborts on the first.
+  const both = httpsUrl.safeParse(new URL("http://localhost"));
+  expect(both.error!.issues.map((i) => i.path)).toEqual([["protocol"], ["hostname"]]);
+
+  // A failing base schema yields its own issue and no property issues.
+  for (const input of ["not a url", null]) {
+    const issues = httpsUrl.safeParse(input).error!.issues;
+    expect(issues.map((i) => [i.code, i.path])).toEqual([["custom", []]]);
+  }
+
+  // Not specific to z.instanceof(). A base whose type mismatch aborts implicitly rather than explicitly must still not run the property checks against the rejected value.
+  const obj = z
+    .object({ a: z.string(), b: z.string() })
+    .check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
+  expect(obj.safeParse({ a: "x", b: "y" }).success).toBe(true);
+  expect(obj.safeParse({ a: "!", b: "!" }).error!.issues.map((i) => i.path)).toEqual([["a"], ["b"]]);
+  for (const input of [null, undefined, 5]) {
+    expect(obj.safeParse(input).error!.issues.map((i) => [i.code, i.path])).toEqual([["invalid_type", []]]);
+  }
+
+  // Known looseness versus the longhand, pinned so it stays deliberate: the check is typed over the whole shape, and `$YatspCheckInternals.check()` is a method, so TypeScript compares it bivariantly and accepts a check type that is a subtype of the target. Naming a key the target lacks therefore compiles here and fails at parse time, where the equivalent chain of `z.property()` calls rejects it outright.
+  z.object({ a: z.string() }).check(...z.properties({ a: z.literal("x"), b: z.literal("y") }));
+  expect(
+    z
+      .object({ a: z.string() })
+      .check(...z.properties({ a: z.string(), b: z.literal("y") }))
+      .safeParse({ a: "ok" })
+      .error!.issues.map((i) => [i.code, i.path])
+  ).toEqual([["invalid_value", ["b"]]]);
+
+  // literal and enum inputs widen to their primitive, so a `string`/`boolean` property accepts them without a cast, while a genuine type mismatch or an unknown key still fails to compile
+  z.instanceof(URL).check(z.property("protocol", z.literal("https:")));
+  z.instanceof(Request).check(...z.properties({ method: z.enum(["POST", "PUT"]), bodyUsed: z.literal(false) }));
+  // @ts-expect-error length is a number
+  z.string().check(z.property("length", z.string()));
+  // @ts-expect-error no such key
+  z.instanceof(URL).check(z.property("nope", z.string()));
+
+  // the check feeds the property value into its schema, so it is typed over the input side rather than the output
+  const stringToLength = z.property(
+    "a",
+    z.string().transform((s) => s.length)
+  );
+  z.object({ a: z.string() }).check(stringToLength);
+  // @ts-expect-error a is a number, the schema takes a string
+  z.object({ a: z.number() }).check(stringToLength);
+
+  // The properties check carries no `when`, so the schema stays on the compiled fast path.
+  const compiled = z.compile(httpsUrl);
+  expect(compiled.safeParse(new URL("https://example.com")).success).toBe(true);
+  expect(compiled.safeParse(new URL("http://localhost")).error!.issues.map((i) => i.path)).toEqual([
+    ["protocol"],
+    ["hostname"],
+  ]);
+});