anyvali 0.3.1

package/tests/unit/defaults.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { string, int, object, optional } from "../../src/index.js";
+
+describe("Defaults", () => {
+  it("applies default when value is absent", () => {
+    const s = string().default("fallback");
+    expect(s.parse(undefined)).toBe("fallback");
+  });
+
+  it("does not apply default when value is present", () => {
+    const s = string().default("fallback");
+    expect(s.parse("provided")).toBe("provided");
+  });
+
+  it("validates the defaulted value", () => {
+    const s = string().minLength(5).default("hi");
+    // default "hi" is only 2 chars, should fail validation with default_invalid
+    const result = s.safeParse(undefined);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("default_invalid");
+    }
+  });
+
+  it("applies defaults in object fields", () => {
+    const s = object({
+      name: string(),
+      role: string().default("user"),
+    });
+    const result = s.parse({ name: "Alice" });
+    expect(result.role).toBe("user");
+  });
+
+  it("does not override present object field with default", () => {
+    const s = object({
+      role: string().default("user"),
+    });
+    const result = s.parse({ role: "admin" });
+    expect(result.role).toBe("admin");
+  });
+
+  it("default on optional field", () => {
+    const s = object({
+      count: optional(int().default(0)),
+    });
+    const result = s.parse({});
+    expect(result).toEqual({ count: 0 });
+  });
+});

package/tests/unit/errors.test.ts

@@ -0,0 +1,53 @@
+import { describe, it, expect } from "vitest";
+import { ValidationError } from "../../src/errors.js";
+import type { ValidationIssue } from "../../src/types.js";
+
+describe("ValidationError", () => {
+  it("constructs with issues and formats message", () => {
+    const issues: ValidationIssue[] = [
+      {
+        code: "invalid_type",
+        message: "Expected string, received number",
+        path: ["name"],
+        expected: "string",
+        received: "number",
+      },
+    ];
+    const err = new ValidationError(issues);
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("ValidationError");
+    expect(err.issues).toBe(issues);
+    expect(err.message).toBe("[invalid_type] name: Expected string, received number");
+  });
+
+  it("formats message for root path (empty path)", () => {
+    const issues: ValidationIssue[] = [
+      {
+        code: "invalid_type",
+        message: "Expected string",
+        path: [],
+      },
+    ];
+    const err = new ValidationError(issues);
+    expect(err.message).toBe("[invalid_type] Expected string");
+  });
+
+  it("formats multiple issues joined by newline", () => {
+    const issues: ValidationIssue[] = [
+      { code: "invalid_type", message: "bad type", path: ["a"] },
+      { code: "too_small", message: "too short", path: ["b", "c"] },
+    ];
+    const err = new ValidationError(issues);
+    expect(err.message).toBe(
+      "[invalid_type] a: bad type\n[too_small] b.c: too short"
+    );
+  });
+
+  it("formats nested path with dot notation", () => {
+    const issues: ValidationIssue[] = [
+      { code: "required", message: "required", path: ["x", 0, "y"] },
+    ];
+    const err = new ValidationError(issues);
+    expect(err.message).toBe("[required] x.0.y: required");
+  });
+});

package/tests/unit/export.test.ts

@@ -0,0 +1,270 @@
+import { describe, it, expect } from "vitest";
+import {
+  any,
+  unknown,
+  never,
+  null_,
+  literal,
+  enum_,
+  string,
+  int,
+  bool,
+  array,
+  tuple,
+  object,
+  record,
+  union,
+  intersection,
+  optional,
+  nullable,
+  exportSchema,
+  parse,
+  safeParse,
+} from "../../src/index.js";
+import { RefSchema } from "../../src/schemas/ref.js";
+import { NullableSchema } from "../../src/schemas/nullable.js";
+import { OptionalSchema } from "../../src/schemas/optional.js";
+import { StringSchema } from "../../src/schemas/string.js";
+import { ABSENT } from "../../src/schemas/base.js";
+
+describe("_toNode / export for all schema types", () => {
+  it("any", () => {
+    const doc = exportSchema(any());
+    expect(doc.root.kind).toBe("any");
+  });
+
+  it("any with default", () => {
+    const doc = exportSchema(any().default(42));
+    expect(doc.root.kind).toBe("any");
+    expect(doc.root.default).toBe(42);
+  });
+
+  it("unknown", () => {
+    const doc = exportSchema(unknown());
+    expect(doc.root.kind).toBe("unknown");
+  });
+
+  it("unknown with default", () => {
+    const doc = exportSchema(unknown().default("x"));
+    expect(doc.root.kind).toBe("unknown");
+    expect(doc.root.default).toBe("x");
+  });
+
+  it("never", () => {
+    const doc = exportSchema(never());
+    expect(doc.root.kind).toBe("never");
+  });
+
+  it("null", () => {
+    const doc = exportSchema(null_());
+    expect(doc.root.kind).toBe("null");
+  });
+
+  it("null with default", () => {
+    const doc = exportSchema(null_().default(null));
+    expect(doc.root.kind).toBe("null");
+    expect(doc.root.default).toBe(null);
+  });
+
+  it("literal", () => {
+    const doc = exportSchema(literal("hello"));
+    expect(doc.root.kind).toBe("literal");
+    expect((doc.root as any).value).toBe("hello");
+  });
+
+  it("literal with default", () => {
+    const doc = exportSchema(literal(42).default(42));
+    expect(doc.root.default).toBe(42);
+  });
+
+  it("enum", () => {
+    const doc = exportSchema(enum_(["a", "b", 1]));
+    expect(doc.root.kind).toBe("enum");
+    expect((doc.root as any).values).toEqual(["a", "b", 1]);
+  });
+
+  it("enum with default", () => {
+    const doc = exportSchema(enum_(["x", "y"]).default("x"));
+    expect(doc.root.default).toBe("x");
+  });
+
+  it("tuple", () => {
+    const doc = exportSchema(tuple([string(), int()]));
+    expect(doc.root.kind).toBe("tuple");
+    expect((doc.root as any).elements).toHaveLength(2);
+    expect((doc.root as any).elements[0].kind).toBe("string");
+    expect((doc.root as any).elements[1].kind).toBe("int");
+  });
+
+  it("tuple with default", () => {
+    const doc = exportSchema(tuple([string()]).default(["hi"] as any));
+    expect(doc.root.default).toEqual(["hi"]);
+  });
+
+  it("record", () => {
+    const doc = exportSchema(record(int()));
+    expect(doc.root.kind).toBe("record");
+    expect((doc.root as any).valueSchema.kind).toBe("int");
+  });
+
+  it("record with default", () => {
+    const doc = exportSchema(record(int()).default({} as any));
+    expect(doc.root.default).toEqual({});
+  });
+
+  it("union", () => {
+    const doc = exportSchema(union([string(), int()]));
+    expect(doc.root.kind).toBe("union");
+    expect((doc.root as any).variants).toHaveLength(2);
+  });
+
+  it("union with default", () => {
+    const doc = exportSchema(union([string(), int()]).default("x" as any));
+    expect(doc.root.default).toBe("x");
+  });
+
+  it("intersection", () => {
+    const doc = exportSchema(
+      intersection([object({ a: string() }), object({ b: int() })])
+    );
+    expect(doc.root.kind).toBe("intersection");
+    expect((doc.root as any).allOf).toHaveLength(2);
+  });
+
+  it("intersection with default", () => {
+    const doc = exportSchema(
+      intersection([object({ a: string() })]).default({ a: "x" } as any)
+    );
+    expect(doc.root.default).toEqual({ a: "x" });
+  });
+
+  it("optional", () => {
+    const doc = exportSchema(optional(string()));
+    expect(doc.root.kind).toBe("optional");
+    expect((doc.root as any).inner.kind).toBe("string");
+  });
+
+  it("optional with default", () => {
+    const doc = exportSchema(optional(string().default("hi")));
+    expect(doc.root.kind).toBe("optional");
+  });
+
+  it("nullable", () => {
+    const doc = exportSchema(nullable(string()));
+    expect(doc.root.kind).toBe("nullable");
+    expect((doc.root as any).inner.kind).toBe("string");
+  });
+
+  it("nullable with default", () => {
+    const doc = exportSchema(nullable(string()).default(null as any));
+    expect(doc.root.default).toBe(null);
+  });
+
+  it("ref", () => {
+    const ref = new RefSchema("#/definitions/User");
+    const node = ref._toNode();
+    expect(node.kind).toBe("ref");
+    expect((node as any).ref).toBe("#/definitions/User");
+  });
+
+  it("ref _validate without resolver adds issue", () => {
+    const ref = new RefSchema("#/definitions/Missing");
+    const result = ref.safeParse("anything");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("unsupported_schema_kind");
+    }
+  });
+
+  it("ref _validate with resolver delegates", () => {
+    const ref = new RefSchema("#/definitions/Name", () => string());
+    expect(ref.parse("hello")).toBe("hello");
+  });
+});
+
+describe("Top-level parse/safeParse functions", () => {
+  it("parse delegates to schema.parse", () => {
+    expect(parse(string(), "hello")).toBe("hello");
+  });
+
+  it("parse throws on failure", () => {
+    expect(() => parse(string(), 42)).toThrow();
+  });
+
+  it("safeParse returns result", () => {
+    const r = safeParse(string(), "hi");
+    expect(r.success).toBe(true);
+    if (r.success) expect(r.data).toBe("hi");
+  });
+
+  it("safeParse returns failure", () => {
+    const r = safeParse(string(), 42);
+    expect(r.success).toBe(false);
+  });
+});
+
+describe("base.ts edge cases", () => {
+  it("_getCoercionTarget returns 'unknown' by default", () => {
+    const s = any();
+    expect((s as any)._getCoercionTarget()).toBe("unknown");
+  });
+
+  it("export throws in portable mode when not portable", () => {
+    const s = any();
+    (s as any)._isPortable = false;
+    expect(() => s.export("portable")).toThrow(
+      "Cannot export in portable mode"
+    );
+  });
+
+  it("export works in extended mode even if not portable", () => {
+    const s = any();
+    (s as any)._isPortable = false;
+    const doc = s.export("extended");
+    expect(doc.root.kind).toBe("any");
+  });
+});
+
+describe("nullable._validate direct calls", () => {
+  it("returns null when input is null", () => {
+    const s = new NullableSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    expect(s._validate(null, ctx)).toBe(null);
+    expect(ctx.issues).toHaveLength(0);
+  });
+
+  it("delegates to inner when input is not null", () => {
+    const s = new NullableSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    expect(s._validate("hello", ctx)).toBe("hello");
+  });
+
+  it("inner validation failure propagates", () => {
+    const s = new NullableSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    s._validate(42, ctx);
+    expect(ctx.issues.length).toBeGreaterThan(0);
+  });
+});
+
+describe("optional._validate direct calls", () => {
+  it("returns undefined when input is undefined", () => {
+    const s = new OptionalSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    expect(s._validate(undefined, ctx)).toBe(undefined);
+    expect(ctx.issues).toHaveLength(0);
+  });
+
+  it("returns undefined when input is ABSENT", () => {
+    const s = new OptionalSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    expect(s._validate(ABSENT, ctx)).toBe(undefined);
+    expect(ctx.issues).toHaveLength(0);
+  });
+
+  it("delegates to inner when input is present", () => {
+    const s = new OptionalSchema(new StringSchema());
+    const ctx = { path: [], issues: [] };
+    expect(s._validate("hello", ctx)).toBe("hello");
+  });
+});

package/tests/unit/inference.test.ts

@@ -0,0 +1,306 @@
+import { describe, it, expect, expectTypeOf } from "vitest";
+import {
+  object,
+  string,
+  int,
+  int64,
+  number,
+  bool,
+  null_,
+  array,
+  tuple,
+  record,
+  union,
+  intersection,
+  optional,
+  nullable,
+  literal,
+  enum_,
+  type Infer,
+} from "../../src/index.js";
+
+describe("Type Inference", () => {
+  describe("Infer<T> utility type", () => {
+    it("infers string", () => {
+      const schema = string();
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string>();
+    });
+
+    it("infers number", () => {
+      const schema = number();
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<number>();
+    });
+
+    it("infers int as number", () => {
+      const schema = int();
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<number>();
+    });
+
+    it("infers boolean", () => {
+      const schema = bool();
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<boolean>();
+    });
+
+    it("infers null", () => {
+      const schema = null_();
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<null>();
+    });
+
+    it("infers literal string", () => {
+      const schema = literal("hello");
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<"hello">();
+    });
+
+    it("infers literal number", () => {
+      const schema = literal(42);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<42>();
+    });
+  });
+
+  describe("Object type inference", () => {
+    it("infers flat object shape", () => {
+      const schema = object({
+        name: string(),
+        age: int(),
+      });
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<{ name: string; age: number }>();
+    });
+
+    it("infers object with optional fields", () => {
+      const schema = object({
+        name: string(),
+        nick: optional(string()),
+      });
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<{
+        name: string;
+        nick?: string | undefined;
+      }>();
+    });
+
+    it("infers object with nullable fields", () => {
+      const schema = object({
+        name: string(),
+        bio: nullable(string()),
+      });
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<{
+        name: string;
+        bio: string | null;
+      }>();
+    });
+
+    it("infers nested objects", () => {
+      const schema = object({
+        user: object({
+          name: string(),
+          age: int(),
+        }),
+      });
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<{
+        user: { name: string; age: number };
+      }>();
+    });
+
+    it("parse returns typed value, not Record<string, unknown>", () => {
+      const schema = object({
+        a: string(),
+      });
+      const result = schema.parse({ a: "hello" });
+      expectTypeOf(result).toEqualTypeOf<{ a: string }>();
+
+      // This should be accessible:
+      expectTypeOf(result.a).toEqualTypeOf<string>();
+    });
+
+    it("safeParse data is typed on success", () => {
+      const schema = object({
+        a: string(),
+        b: int(),
+      });
+      const result = schema.safeParse({ a: "hello", b: 1 });
+      if (result.success) {
+        expectTypeOf(result.data).toEqualTypeOf<{
+          a: string;
+          b: number;
+        }>();
+      }
+    });
+
+    it("rejects accessing unknown properties at type level", () => {
+      const schema = object({ a: string() });
+      type T = Infer<typeof schema>;
+      // T should have 'a' but not 'b'
+      expectTypeOf<T>().toHaveProperty("a");
+      expectTypeOf<T>().not.toHaveProperty("b");
+    });
+  });
+
+  describe("Array type inference", () => {
+    it("infers array of strings", () => {
+      const schema = array(string());
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string[]>();
+    });
+
+    it("infers array of objects", () => {
+      const schema = array(
+        object({
+          id: int64(),
+          name: string(),
+        }),
+      );
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<
+        { id: number; name: string }[]
+      >();
+    });
+  });
+
+  describe("Tuple type inference", () => {
+    it("infers tuple element types", () => {
+      const schema = tuple([string(), int(), bool()]);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<[string, number, boolean]>();
+    });
+  });
+
+  describe("Record type inference", () => {
+    it("infers record value type", () => {
+      const schema = record(number());
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<Record<string, number>>();
+    });
+  });
+
+  describe("Union type inference", () => {
+    it("infers union of types", () => {
+      const schema = union([string(), int()]);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string | number>();
+    });
+
+    it("infers union of literals", () => {
+      const schema = union([literal("a"), literal("b")]);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<"a" | "b">();
+    });
+  });
+
+  describe("Intersection type inference", () => {
+    it("infers intersection of object types", () => {
+      const schema = intersection([
+        object({ name: string() }),
+        object({ age: int() }),
+      ]);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<{
+        name: string;
+        age: number;
+      }>();
+    });
+  });
+
+  describe("Enum type inference", () => {
+    it("infers enum values as union", () => {
+      const schema = enum_(["free", "pro", "enterprise"] as const);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<"free" | "pro" | "enterprise">();
+    });
+  });
+
+  describe("Modifier type inference", () => {
+    it("optional adds undefined", () => {
+      const schema = optional(string());
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string | undefined>();
+    });
+
+    it("nullable adds null", () => {
+      const schema = nullable(string());
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string | null>();
+    });
+
+    it("optional nullable adds both", () => {
+      const schema = optional(nullable(string()));
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string | null | undefined>();
+    });
+  });
+
+  describe("Method chaining preserves types", () => {
+    it("string with constraints stays string", () => {
+      const schema = string().minLength(1).maxLength(100).format("email");
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string>();
+    });
+
+    it("int with constraints stays number", () => {
+      const schema = int().min(0).max(100);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<number>();
+    });
+
+    it("array with constraints preserves element type", () => {
+      const schema = array(string()).minItems(1).maxItems(10);
+      type T = Infer<typeof schema>;
+      expectTypeOf<T>().toEqualTypeOf<string[]>();
+    });
+  });
+
+  describe("Runtime behavior unchanged", () => {
+    it("object parse still works correctly", () => {
+      const schema = object({ a: string() });
+      const result = schema.parse({ a: "hello" });
+      expect(result).toEqual({ a: "hello" });
+      expect(result.a).toBe("hello");
+    });
+
+    it("object safeParse still works correctly", () => {
+      const schema = object({ a: string(), b: int() });
+      const result = schema.safeParse({ a: "hello", b: 42 });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.a).toBe("hello");
+        expect(result.data.b).toBe(42);
+      }
+    });
+
+    it("object safeParse strips unknown properties by default", () => {
+      const schema = object({ a: string() });
+      const result = schema.safeParse({ a: "hello", b: "extra" });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toEqual({ a: "hello" });
+        expect("b" in result.data).toBe(false);
+      }
+    });
+
+    it("object safeParse rejects unknown properties when unknownKeys('reject')", () => {
+      const schema = object({ a: string() }).unknownKeys("reject");
+      const result = schema.safeParse({ a: "hello", b: "extra" });
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.issues[0].code).toBe("unknown_key");
+      }
+    });
+
+    it("typed parse result correctly narrows - accessing known property is ok", () => {
+      const schema = object({ a: string() });
+      const res = schema.parse({ a: "a" });
+      // res.a should work fine at runtime and type level
+      expect(res.a).toBe("a");
+      expectTypeOf(res.a).toEqualTypeOf<string>();
+    });
+  });
+});