anyvali 0.3.1

package/tests/unit/interchange.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect } from "vitest";
+import {
+  string,
+  int,
+  object,
+  array,
+  optional,
+  nullable,
+  bool,
+  exportSchema,
+  importSchema,
+} from "../../src/index.js";
+
+describe("Export", () => {
+  it("exports a simple string schema", () => {
+    const doc = exportSchema(string().minLength(1).maxLength(100));
+    expect(doc.anyvaliVersion).toBe("1.0");
+    expect(doc.schemaVersion).toBe("1.1");
+    expect(doc.root.kind).toBe("string");
+    expect((doc.root as any).minLength).toBe(1);
+    expect((doc.root as any).maxLength).toBe(100);
+  });
+
+  it("exports an object schema", () => {
+    const s = object({
+      name: string(),
+      age: optional(int()),
+    });
+    const doc = exportSchema(s);
+    expect(doc.root.kind).toBe("object");
+    const root = doc.root as any;
+    expect(root.properties.name.kind).toBe("string");
+    expect(root.required).toContain("name");
+    expect(root.required).not.toContain("age");
+  });
+
+  it("exports defaults", () => {
+    const s = string().default("hello");
+    const doc = exportSchema(s);
+    expect(doc.root.default).toBe("hello");
+  });
+
+  it("exports coercion config", () => {
+    const s = int().coerce({ from: "string" });
+    const doc = exportSchema(s);
+    expect(doc.root.coerce).toEqual({ from: "string" });
+  });
+});
+
+describe("Import", () => {
+  it("round-trips a string schema", () => {
+    const original = string().minLength(1).maxLength(100);
+    const doc = exportSchema(original);
+    const imported = importSchema(doc);
+    expect(imported.parse("hello")).toBe("hello");
+    expect(imported.safeParse("").success).toBe(false);
+  });
+
+  it("round-trips an object schema", () => {
+    const original = object({
+      name: string(),
+      active: bool().default(true),
+    });
+    const doc = exportSchema(original);
+    const imported = importSchema(doc);
+    const result = imported.parse({ name: "Alice" });
+    expect(result).toEqual({ name: "Alice", active: true });
+  });
+
+  it("round-trips an array schema", () => {
+    const original = array(int()).minItems(1);
+    const doc = exportSchema(original);
+    const imported = importSchema(doc);
+    expect(imported.parse([1, 2, 3])).toEqual([1, 2, 3]);
+    expect(imported.safeParse([]).success).toBe(false);
+  });
+
+  it("round-trips nullable", () => {
+    const original = nullable(string());
+    const doc = exportSchema(original);
+    const imported = importSchema(doc);
+    expect(imported.parse(null)).toBe(null);
+    expect(imported.parse("hello")).toBe("hello");
+  });
+
+  it("round-trips coercion", () => {
+    const original = int().coerce({ from: "string" });
+    const doc = exportSchema(original);
+    const imported = importSchema(doc);
+    expect(imported.parse("42")).toBe(42);
+  });
+
+  it("throws on missing kind field", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: {},
+      definitions: {},
+      extensions: {},
+    };
+    expect(() => importSchema(doc as any)).toThrow();
+  });
+
+  it("throws on null/empty root", () => {
+    expect(() =>
+      importSchema({ anyvaliVersion: "1.0", schemaVersion: "1", root: null } as any)
+    ).toThrow();
+    expect(() =>
+      importSchema({ anyvaliVersion: "1.0", schemaVersion: "1" } as any)
+    ).toThrow();
+  });
+
+  it("imports invalid regex patterns without throwing", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1.1",
+      root: { kind: "string", pattern: "(" },
+      definitions: {},
+      extensions: {},
+    };
+
+    const imported = importSchema(doc as any);
+
+    expect(() => imported.safeParse("abc")).not.toThrow();
+    expect(imported.safeParse("abc").success).toBe(false);
+  });
+
+  it("imports array schemas with canonical items keys", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1.1",
+      root: {
+        kind: "array",
+        items: { kind: "int" },
+      },
+      definitions: {},
+      extensions: {},
+    };
+
+    const imported = importSchema(doc as any);
+    expect(imported.parse([1, 2, 3])).toEqual([1, 2, 3]);
+    expect(imported.safeParse(["a"]).success).toBe(false);
+  });
+
+  it("imports union schemas with canonical variants keys", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1.1",
+      root: {
+        kind: "union",
+        variants: [{ kind: "string" }, { kind: "int" }],
+      },
+      definitions: {},
+      extensions: {},
+    };
+
+    const imported = importSchema(doc as any);
+    expect(imported.parse("hello")).toBe("hello");
+    expect(imported.parse(42)).toBe(42);
+    expect(imported.safeParse(true).success).toBe(false);
+  });
+
+  it("imports __proto__ property names without prototype pollution", () => {
+    const doc = JSON.parse(`{
+      "anyvaliVersion": "1.0",
+      "schemaVersion": "1.1",
+      "root": {
+        "kind": "object",
+        "properties": {
+          "__proto__": { "kind": "string" }
+        },
+        "required": ["__proto__"],
+        "unknownKeys": "reject"
+      },
+      "definitions": {},
+      "extensions": {}
+    }`);
+    const input = JSON.parse('{"__proto__":"safe"}') as Record<string, unknown>;
+
+    const imported = importSchema(doc as any);
+
+    expect(() => imported.parse(input)).not.toThrow();
+    const result = imported.parse(input) as Record<string, unknown>;
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(true);
+    expect(Object.getOwnPropertyDescriptor(result, "__proto__")?.value).toBe(
+      "safe"
+    );
+    expect(({} as Record<string, unknown>).safe).toBeUndefined();
+  });
+});

package/tests/unit/number.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect } from "vitest";
+import { number, float32, float64, int, int8, int16, int32, int64, uint8, uint16, uint32, uint64 } from "../../src/index.js";
+
+describe("NumberSchema", () => {
+  it("accepts valid numbers", () => {
+    expect(number().parse(42)).toBe(42);
+    expect(number().parse(3.14)).toBe(3.14);
+    expect(number().parse(-0.5)).toBe(-0.5);
+  });
+
+  it("rejects non-numbers", () => {
+    const result = number().safeParse("42");
+    expect(result.success).toBe(false);
+    if (!result.success) expect(result.issues[0].code).toBe("invalid_type");
+  });
+
+  it("rejects NaN and Infinity", () => {
+    expect(number().safeParse(NaN).success).toBe(false);
+    expect(number().safeParse(Infinity).success).toBe(false);
+    expect(number().safeParse(-Infinity).success).toBe(false);
+  });
+
+  it("validates min", () => {
+    const s = number().min(5);
+    expect(s.parse(5)).toBe(5);
+    expect(s.safeParse(4).success).toBe(false);
+  });
+
+  it("validates max", () => {
+    const s = number().max(10);
+    expect(s.parse(10)).toBe(10);
+    expect(s.safeParse(11).success).toBe(false);
+  });
+
+  it("validates exclusiveMin", () => {
+    const s = number().exclusiveMin(5);
+    expect(s.parse(6)).toBe(6);
+    expect(s.safeParse(5).success).toBe(false);
+  });
+
+  it("validates exclusiveMax", () => {
+    const s = number().exclusiveMax(10);
+    expect(s.parse(9)).toBe(9);
+    expect(s.safeParse(10).success).toBe(false);
+  });
+
+  it("validates multipleOf", () => {
+    const s = number().multipleOf(3);
+    expect(s.parse(9)).toBe(9);
+    expect(s.safeParse(10).success).toBe(false);
+  });
+
+  it("coerces string to number", () => {
+    const s = number().coerce({ from: "string" });
+    expect(s.parse("3.14")).toBe(3.14);
+  });
+
+  it("coercion failure", () => {
+    const s = number().coerce({ from: "string" });
+    const result = s.safeParse("abc");
+    expect(result.success).toBe(false);
+    if (!result.success) expect(result.issues[0].code).toBe("coercion_failed");
+  });
+});
+
+describe("Float32Schema", () => {
+  it("accepts valid numbers", () => {
+    expect(float32().parse(1.5)).toBe(1.5);
+  });
+});
+
+describe("Float64Schema", () => {
+  it("accepts valid numbers", () => {
+    expect(float64().parse(1.5)).toBe(1.5);
+  });
+});
+
+describe("IntSchema", () => {
+  it("accepts integers", () => {
+    expect(int().parse(42)).toBe(42);
+    expect(int().parse(-10)).toBe(-10);
+    expect(int().parse(0)).toBe(0);
+  });
+
+  it("rejects floats", () => {
+    const result = int().safeParse(3.14);
+    expect(result.success).toBe(false);
+    if (!result.success) expect(result.issues[0].code).toBe("invalid_type");
+  });
+
+  it("rejects non-numbers", () => {
+    expect(int().safeParse("42").success).toBe(false);
+  });
+
+  it("coerces string to int", () => {
+    const s = int().coerce({ from: "string" });
+    expect(s.parse("42")).toBe(42);
+  });
+
+  it("rejects float strings when coercing to int", () => {
+    const s = int().coerce({ from: "string" });
+    const result = s.safeParse("3.14");
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("Int8Schema", () => {
+  it("accepts values in range [-128, 127]", () => {
+    expect(int8().parse(0)).toBe(0);
+    expect(int8().parse(-128)).toBe(-128);
+    expect(int8().parse(127)).toBe(127);
+  });
+
+  it("rejects out-of-range values", () => {
+    expect(int8().safeParse(128).success).toBe(false);
+    expect(int8().safeParse(-129).success).toBe(false);
+  });
+});
+
+describe("Int16Schema", () => {
+  it("accepts values in range", () => {
+    expect(int16().parse(0)).toBe(0);
+    expect(int16().parse(-32768)).toBe(-32768);
+    expect(int16().parse(32767)).toBe(32767);
+  });
+
+  it("rejects out-of-range values", () => {
+    expect(int16().safeParse(32768).success).toBe(false);
+  });
+});
+
+describe("Int32Schema", () => {
+  it("accepts values in range", () => {
+    expect(int32().parse(0)).toBe(0);
+    expect(int32().parse(2147483647)).toBe(2147483647);
+    expect(int32().parse(-2147483648)).toBe(-2147483648);
+  });
+
+  it("rejects out-of-range values", () => {
+    expect(int32().safeParse(2147483648).success).toBe(false);
+  });
+});
+
+describe("Int64Schema", () => {
+  it("accepts safe integers", () => {
+    expect(int64().parse(0)).toBe(0);
+    expect(int64().parse(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+    expect(int64().parse(Number.MIN_SAFE_INTEGER)).toBe(Number.MIN_SAFE_INTEGER);
+  });
+});
+
+describe("Uint8Schema", () => {
+  it("accepts values in range [0, 255]", () => {
+    expect(uint8().parse(0)).toBe(0);
+    expect(uint8().parse(255)).toBe(255);
+  });
+
+  it("rejects negative and out-of-range", () => {
+    expect(uint8().safeParse(-1).success).toBe(false);
+    expect(uint8().safeParse(256).success).toBe(false);
+  });
+});
+
+describe("Uint16Schema", () => {
+  it("accepts values in range [0, 65535]", () => {
+    expect(uint16().parse(0)).toBe(0);
+    expect(uint16().parse(65535)).toBe(65535);
+  });
+
+  it("rejects out-of-range", () => {
+    expect(uint16().safeParse(65536).success).toBe(false);
+  });
+});
+
+describe("Uint32Schema", () => {
+  it("accepts values in range [0, 4294967295]", () => {
+    expect(uint32().parse(0)).toBe(0);
+    expect(uint32().parse(4294967295)).toBe(4294967295);
+  });
+
+  it("rejects out-of-range", () => {
+    expect(uint32().safeParse(4294967296).success).toBe(false);
+  });
+});
+
+describe("Uint64Schema", () => {
+  it("accepts values in range [0, MAX_SAFE_INTEGER]", () => {
+    expect(uint64().parse(0)).toBe(0);
+    expect(uint64().parse(Number.MAX_SAFE_INTEGER)).toBe(Number.MAX_SAFE_INTEGER);
+  });
+
+  it("rejects negative values", () => {
+    expect(uint64().safeParse(-1).success).toBe(false);
+  });
+});

package/tests/unit/object.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from "vitest";
+import { object, string, int, optional, bool, RefSchema } from "../../src/index.js";
+
+describe("ObjectSchema", () => {
+  it("accepts valid objects", () => {
+    const s = object({
+      name: string(),
+      age: int(),
+    });
+    const result = s.parse({ name: "Alice", age: 30 });
+    expect(result).toEqual({ name: "Alice", age: 30 });
+  });
+
+  it("rejects missing required fields", () => {
+    const s = object({
+      name: string(),
+      age: int(),
+    });
+    const result = s.safeParse({ name: "Alice" });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("required");
+      expect(result.issues[0].path).toEqual(["age"]);
+    }
+  });
+
+  it("strips unknown keys by default", () => {
+    const s = object({ name: string() });
+    const result = s.parse({ name: "Alice", extra: true });
+    expect(result).toEqual({ name: "Alice" });
+  });
+
+  it("rejects unknown keys when configured", () => {
+    const s = object({ name: string() }).unknownKeys("reject");
+    const result = s.safeParse({ name: "Alice", extra: true });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("unknown_key");
+    }
+  });
+
+  it("allows unknown keys when configured", () => {
+    const s = object({ name: string() }).unknownKeys("allow");
+    const result = s.parse({ name: "Alice", extra: true });
+    expect(result).toEqual({ name: "Alice", extra: true });
+  });
+
+  it("handles optional fields", () => {
+    const s = object({
+      name: string(),
+      nickname: optional(string()),
+    });
+    const result = s.parse({ name: "Alice" });
+    expect(result).toEqual({ name: "Alice" });
+  });
+
+  it("keeps object modifiers immutable", () => {
+    const base = object({ name: string() });
+    const rejected = base.unknownKeys("reject");
+
+    expect(base.parse({ name: "Alice", extra: true })).toEqual({
+      name: "Alice",
+    });
+    expect(rejected.safeParse({ name: "Alice", extra: true }).success).toBe(
+      false
+    );
+  });
+
+  it("handles defaults on fields", () => {
+    const s = object({
+      name: string(),
+      role: string().default("user"),
+    });
+    const result = s.parse({ name: "Alice" });
+    expect(result).toEqual({ name: "Alice", role: "user" });
+  });
+
+  it("does not overwrite present values with defaults", () => {
+    const s = object({
+      role: string().default("user"),
+    });
+    const result = s.parse({ role: "admin" });
+    expect(result).toEqual({ role: "admin" });
+  });
+
+  it("validates nested objects", () => {
+    const s = object({
+      user: object({
+        name: string(),
+      }),
+    });
+    const result = s.safeParse({ user: { name: 42 } });
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].path).toEqual(["user", "name"]);
+    }
+  });
+
+  it("collects multiple nested issues with precise paths", () => {
+    const s = object({
+      user: object({
+        name: string().minLength(2),
+        age: int().min(18),
+      }),
+      active: bool(),
+    });
+
+    const result = s.safeParse({
+      user: { name: "", age: 12 },
+      active: "yes",
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues.map((issue) => issue.path)).toEqual(
+        expect.arrayContaining([
+          ["user", "name"],
+          ["user", "age"],
+          ["active"],
+        ])
+      );
+    }
+  });
+
+  it("treats inherited properties as absent", () => {
+    const base = { name: "Alice" };
+    const input = Object.create(base) as Record<string, unknown>;
+    input.age = 30;
+
+    const s = object({
+      name: string(),
+      age: int(),
+    });
+
+    const result = s.safeParse(input);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            code: "required",
+            path: ["name"],
+          }),
+        ])
+      );
+    }
+  });
+
+  it("returns a detached parsed object", () => {
+    const s = object({
+      user: object({
+        name: string(),
+      }),
+    });
+
+    const input = { user: { name: "Alice" } };
+    const result = s.parse(input);
+
+    expect(result).toEqual(input);
+    expect(result).not.toBe(input);
+    expect(result.user).not.toBe(input.user);
+  });
+
+  it("preserves __proto__ as data when unknown keys are allowed", () => {
+    const s = object({ name: string() }).unknownKeys("allow");
+    const input = JSON.parse(
+      '{"name":"Alice","__proto__":{"polluted":"yes"}}'
+    ) as Record<string, unknown>;
+
+    const result = s.parse(input) as Record<string, unknown>;
+
+    expect(result.name).toBe("Alice");
+    expect(Object.getPrototypeOf(result)).toBe(Object.prototype);
+    expect(Object.prototype.hasOwnProperty.call(result, "__proto__")).toBe(true);
+    expect(
+      Object.getOwnPropertyDescriptor(result, "__proto__")?.value
+    ).toEqual({ polluted: "yes" });
+    expect(({} as Record<string, unknown>).polluted).toBeUndefined();
+  });
+
+  it("fails closed on cyclic input for recursive schemas", () => {
+    let node!: ReturnType<typeof object>;
+    const next = optional(new RefSchema("#/definitions/Node", () => node));
+    node = object({
+      value: string(),
+      next,
+    });
+
+    const input: Record<string, unknown> = { value: "root" };
+    input.next = input;
+
+    let result:
+      | ReturnType<typeof node.safeParse>
+      | undefined;
+
+    expect(() => {
+      result = node.safeParse(input);
+    }).not.toThrow();
+    expect(result?.success).toBe(false);
+  });
+
+  it("rejects non-objects", () => {
+    const s = object({ name: string() });
+    expect(s.safeParse("string").success).toBe(false);
+    expect(s.safeParse(null).success).toBe(false);
+    expect(s.safeParse([]).success).toBe(false);
+  });
+});