anyvali 0.3.1

package/tests/unit/parser.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect } from "vitest";
+import { parse, safeParse } from "../../src/parse/parser.js";
+import { applyDefault } from "../../src/parse/defaults.js";
+import { ABSENT } from "../../src/schemas/base.js";
+import {
+  createDocument,
+  ANYVALI_VERSION,
+  SCHEMA_VERSION,
+} from "../../src/interchange/document.js";
+import { StringSchema } from "../../src/schemas/string.js";
+import { IntSchema } from "../../src/schemas/int.js";
+import { importSchema } from "../../src/interchange/importer.js";
+
+describe("parse/parser.ts - standalone parse", () => {
+  it("parse returns validated value", () => {
+    const s = new StringSchema();
+    expect(parse(s, "hello")).toBe("hello");
+  });
+
+  it("parse throws on invalid input", () => {
+    const s = new StringSchema();
+    expect(() => parse(s, 42)).toThrow();
+  });
+
+  it("safeParse returns success result", () => {
+    const s = new StringSchema();
+    const result = safeParse(s, "hi");
+    expect(result.success).toBe(true);
+    if (result.success) expect(result.data).toBe("hi");
+  });
+
+  it("safeParse returns failure result", () => {
+    const s = new StringSchema();
+    const result = safeParse(s, 123);
+    expect(result.success).toBe(false);
+    if (!result.success) expect(result.issues.length).toBeGreaterThan(0);
+  });
+});
+
+describe("parse/defaults.ts - applyDefault", () => {
+  it("returns default when input is undefined", () => {
+    expect(applyDefault(undefined, "fallback")).toBe("fallback");
+  });
+
+  it("returns default when input is ABSENT", () => {
+    expect(applyDefault(ABSENT, "fallback")).toBe("fallback");
+  });
+
+  it("returns input when it has a value", () => {
+    expect(applyDefault("hello", "fallback")).toBe("hello");
+  });
+
+  it("returns input when default is ABSENT", () => {
+    expect(applyDefault(undefined, ABSENT)).toBe(undefined);
+  });
+
+  it("returns input (even falsy) when present", () => {
+    expect(applyDefault(0, "fallback")).toBe(0);
+    expect(applyDefault("", "fallback")).toBe("");
+    expect(applyDefault(null, "fallback")).toBe(null);
+    expect(applyDefault(false, "fallback")).toBe(false);
+  });
+});
+
+describe("interchange/document.ts", () => {
+  it("exports constants", () => {
+    expect(ANYVALI_VERSION).toBe("1.0");
+    expect(SCHEMA_VERSION).toBe("1");
+  });
+
+  it("createDocument creates a valid document", () => {
+    const root = { kind: "string" as const };
+    const doc = createDocument(root as any);
+    expect(doc.anyvaliVersion).toBe("1.0");
+    expect(doc.schemaVersion).toBe("1");
+    expect(doc.root).toBe(root);
+    expect(doc.definitions).toEqual({});
+    expect(doc.extensions).toEqual({});
+  });
+
+  it("createDocument with definitions and extensions", () => {
+    const root = { kind: "ref" as const, ref: "#/definitions/Foo" };
+    const defs = { Foo: { kind: "string" as const } };
+    const exts = { myExt: { foo: "bar" } };
+    const doc = createDocument(root as any, defs as any, exts);
+    expect(doc.definitions).toBe(defs);
+    expect(doc.extensions).toBe(exts);
+  });
+});
+
+describe("importer.ts edge cases", () => {
+  it("throws on unsupported schema kind", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "foobar" },
+      definitions: {},
+      extensions: {},
+    };
+    expect(() => importSchema(doc as any)).toThrow("Unsupported schema kind: foobar");
+  });
+
+  it("throws on unresolved ref definition", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "ref", ref: "#/definitions/Missing" },
+      definitions: {},
+      extensions: {},
+    };
+    const imported = importSchema(doc as any);
+    // The ref is lazy, so it only throws when we try to parse
+    expect(() => imported.parse("anything")).toThrow("Unresolved definition: Missing");
+  });
+
+  it("imports ref that resolves to a definition", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "ref", ref: "#/definitions/Name" },
+      definitions: { Name: { kind: "string" } },
+      extensions: {},
+    };
+    const imported = importSchema(doc as any);
+    expect(imported.parse("hello")).toBe("hello");
+  });
+
+  it("imports with coerce as string format", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "int", coerce: "string->int" },
+      definitions: {},
+      extensions: {},
+    };
+    const imported = importSchema(doc as any);
+    expect(imported.parse("42")).toBe(42);
+  });
+
+  it("imports with coerce as array format", () => {
+    const doc = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "string", coerce: ["trim", "lower"] },
+      definitions: {},
+      extensions: {},
+    };
+    const imported = importSchema(doc as any);
+    expect(imported.parse("  HELLO  ")).toBe("hello");
+  });
+});

package/tests/unit/primitives.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest";
+import {
+  bool,
+  null_,
+  any,
+  unknown,
+  never,
+  literal,
+  enum_,
+} from "../../src/index.js";
+
+describe("BoolSchema", () => {
+  it("accepts booleans", () => {
+    expect(bool().parse(true)).toBe(true);
+    expect(bool().parse(false)).toBe(false);
+  });
+
+  it("rejects non-booleans", () => {
+    expect(bool().safeParse("true").success).toBe(false);
+    expect(bool().safeParse(1).success).toBe(false);
+    expect(bool().safeParse(null).success).toBe(false);
+  });
+
+  it("coerces string to bool", () => {
+    const s = bool().coerce({ from: "string" });
+    expect(s.parse("true")).toBe(true);
+    expect(s.parse("false")).toBe(false);
+    expect(s.parse("1")).toBe(true);
+    expect(s.parse("0")).toBe(false);
+  });
+
+  it("coercion failure for invalid string", () => {
+    const s = bool().coerce({ from: "string" });
+    const result = s.safeParse("maybe");
+    expect(result.success).toBe(false);
+    if (!result.success) expect(result.issues[0].code).toBe("coercion_failed");
+  });
+});
+
+describe("NullSchema", () => {
+  it("accepts null", () => {
+    expect(null_().parse(null)).toBe(null);
+  });
+
+  it("rejects non-null", () => {
+    expect(null_().safeParse(undefined).success).toBe(false);
+    expect(null_().safeParse(0).success).toBe(false);
+    expect(null_().safeParse("").success).toBe(false);
+  });
+});
+
+describe("AnySchema", () => {
+  it("accepts anything", () => {
+    expect(any().parse(42)).toBe(42);
+    expect(any().parse("hello")).toBe("hello");
+    expect(any().parse(null)).toBe(null);
+    expect(any().parse(undefined)).toBe(undefined);
+  });
+});
+
+describe("UnknownSchema", () => {
+  it("accepts anything", () => {
+    expect(unknown().parse(42)).toBe(42);
+    expect(unknown().parse("hello")).toBe("hello");
+  });
+});
+
+describe("NeverSchema", () => {
+  it("rejects everything", () => {
+    expect(never().safeParse(42).success).toBe(false);
+    expect(never().safeParse(null).success).toBe(false);
+    expect(never().safeParse(undefined).success).toBe(false);
+  });
+});
+
+describe("LiteralSchema", () => {
+  it("accepts matching literal", () => {
+    expect(literal("hello").parse("hello")).toBe("hello");
+    expect(literal(42).parse(42)).toBe(42);
+    expect(literal(true).parse(true)).toBe(true);
+    expect(literal(null).parse(null)).toBe(null);
+  });
+
+  it("rejects non-matching values", () => {
+    expect(literal("hello").safeParse("world").success).toBe(false);
+    expect(literal(42).safeParse(43).success).toBe(false);
+    if (!literal(42).safeParse(43).success) {
+      expect((literal(42).safeParse(43) as any).issues[0].code).toBe("invalid_literal");
+    }
+  });
+});
+
+describe("EnumSchema", () => {
+  it("accepts values in the enum", () => {
+    const s = enum_(["a", "b", "c"]);
+    expect(s.parse("a")).toBe("a");
+    expect(s.parse("b")).toBe("b");
+  });
+
+  it("rejects values not in the enum", () => {
+    const s = enum_(["a", "b", "c"]);
+    expect(s.safeParse("d").success).toBe(false);
+    expect(s.safeParse(1).success).toBe(false);
+  });
+
+  it("works with numeric enums", () => {
+    const s = enum_([1, 2, 3]);
+    expect(s.parse(1)).toBe(1);
+    expect(s.safeParse(4).success).toBe(false);
+  });
+});

package/tests/unit/security-recursion.test.ts

@@ -0,0 +1,105 @@
+import { describe, it, expect } from "vitest";
+import { importSchema } from "../../src/index.js";
+import type { AnyValiDocument } from "../../src/types.js";
+
+// Recursive schema: Node = object({ value: int, next: optional(ref Node) }).
+function recursiveSchemaDoc(): AnyValiDocument {
+  return {
+    anyvaliVersion: "1.0",
+    schemaVersion: "1",
+    root: { kind: "ref", ref: "#/definitions/Node" } as any,
+    definitions: {
+      Node: {
+        kind: "object",
+        properties: {
+          next: { kind: "ref", ref: "#/definitions/Node" },
+        },
+        required: [],
+        unknownKeys: "strip",
+      } as any,
+    },
+    extensions: {},
+  } as AnyValiDocument;
+}
+
+// Build deeply nested data: { next: { next: { ... } } }.
+function deepData(depth: number): unknown {
+  let cur: any = {};
+  for (let i = 0; i < depth; i++) cur = { next: cur };
+  return cur;
+}
+
+// Build a deeply nested schema document: array(array(array(...))).
+function deepArraySchemaDoc(depth: number): AnyValiDocument {
+  let node: any = { kind: "int" };
+  for (let i = 0; i < depth; i++) node = { kind: "array", items: node };
+  return {
+    anyvaliVersion: "1.0",
+    schemaVersion: "1",
+    root: node,
+    definitions: {},
+    extensions: {},
+  } as AnyValiDocument;
+}
+
+describe("Recursion DoS (AVV-002 / AVV-003)", () => {
+  it("safeParse must not throw on deeply nested recursive-schema input", () => {
+    const schema = importSchema(recursiveSchemaDoc());
+    const data = deepData(100_000);
+    // safeParse contract: never throws, always returns a result.
+    let result: ReturnType<typeof schema.safeParse>;
+    expect(() => {
+      result = schema.safeParse(data);
+    }).not.toThrow();
+    // Bounded: extremely deep input is rejected, not accepted blindly.
+    expect(result!.success).toBe(false);
+  });
+
+  it("depth guard is not bypassed by a union in the recursion path", () => {
+    // Node = object({ next: union(null, ref Node) }) -- the recursive ref is
+    // reached *through* a union variant. The union must propagate depth so the
+    // guard still bounds recursion.
+    const doc: AnyValiDocument = {
+      anyvaliVersion: "1.0",
+      schemaVersion: "1",
+      root: { kind: "ref", ref: "#/definitions/Node" } as any,
+      definitions: {
+        Node: {
+          kind: "object",
+          properties: {
+            next: {
+              kind: "union",
+              variants: [{ kind: "null" }, { kind: "ref", ref: "#/definitions/Node" }],
+            },
+          },
+          required: ["next"],
+          unknownKeys: "strip",
+        } as any,
+      },
+      extensions: {},
+    } as AnyValiDocument;
+    const schema = importSchema(doc);
+
+    let cur: any = { next: null };
+    for (let i = 0; i < 100_000; i++) cur = { next: cur };
+
+    let result: ReturnType<typeof schema.safeParse>;
+    expect(() => {
+      result = schema.safeParse(cur);
+    }).not.toThrow();
+    expect(result!.success).toBe(false);
+  });
+
+  it("importSchema must not stack-overflow on a deeply nested schema doc", () => {
+    const doc = deepArraySchemaDoc(100_000);
+    // Should fail in a controlled way, not throw RangeError (stack overflow).
+    let err: unknown;
+    try {
+      importSchema(doc);
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeInstanceOf(Error);
+    expect((err as Error) instanceof RangeError).toBe(false);
+  });
+});