anyvali 0.3.1 → 0.3.4

package/tests/unit/shared-ref-falsepos.test.ts

@@ -1,33 +1,33 @@
-import { describe, it, expect } from "vitest";
-import { object, int, array } from "../../src/index.js";
-
-// A shared (but NON-circular) object reference appearing in sibling positions
-// must validate. The circular-reference guard must only trip on true cycles
-// (an ancestor reappearing), not on a DAG / repeated sibling.
-describe("Shared non-circular references (false-positive guard)", () => {
-  it("same object used in two object fields validates", () => {
-    const inner = object({ a: int() });
-    const s = object({ x: inner, y: inner });
-    const shared = { a: 1 };
-    const r = s.safeParse({ x: shared, y: shared });
-    expect(r.success).toBe(true);
-  });
-
-  it("same object repeated in an array validates", () => {
-    const s = array(object({ a: int() }));
-    const shared = { a: 1 };
-    const r = s.safeParse([shared, shared, shared]);
-    expect(r.success).toBe(true);
-  });
-
-  it("a genuinely circular input is still rejected (not an infinite loop)", () => {
-    const s = object({ self: object({ a: int() }) });
-    const cyclic: any = {};
-    cyclic.self = cyclic; // true cycle
-    let r: ReturnType<typeof s.safeParse>;
-    expect(() => {
-      r = s.safeParse(cyclic);
-    }).not.toThrow();
-    expect(r!.success).toBe(false);
-  });
-});
+import { describe, it, expect } from "vitest";
+import { object, int, array } from "../../src/index.js";
+
+// A shared (but NON-circular) object reference appearing in sibling positions
+// must validate. The circular-reference guard must only trip on true cycles
+// (an ancestor reappearing), not on a DAG / repeated sibling.
+describe("Shared non-circular references (false-positive guard)", () => {
+  it("same object used in two object fields validates", () => {
+    const inner = object({ a: int() });
+    const s = object({ x: inner, y: inner });
+    const shared = { a: 1 };
+    const r = s.safeParse({ x: shared, y: shared });
+    expect(r.success).toBe(true);
+  });
+
+  it("same object repeated in an array validates", () => {
+    const s = array(object({ a: int() }));
+    const shared = { a: 1 };
+    const r = s.safeParse([shared, shared, shared]);
+    expect(r.success).toBe(true);
+  });
+
+  it("a genuinely circular input is still rejected (not an infinite loop)", () => {
+    const s = object({ self: object({ a: int() }) });
+    const cyclic: any = {};
+    cyclic.self = cyclic; // true cycle
+    let r: ReturnType<typeof s.safeParse>;
+    expect(() => {
+      r = s.safeParse(cyclic);
+    }).not.toThrow();
+    expect(r!.success).toBe(false);
+  });
+});

package/tests/unit/string-pattern-redos.test.ts

@@ -1,46 +1,46 @@
-import { describe, it, expect } from "vitest";
-import { string, array } from "../../src/index.js";
-
-describe("String pattern: caching + ReDoS defense-in-depth", () => {
-  it("matches and rejects correctly (behavior preserved by caching)", () => {
-    const s = string().pattern("^[a-z]+$");
-    expect(s.safeParse("abc").success).toBe(true);
-    const bad = s.safeParse("ABC");
-    expect(bad.success).toBe(false);
-    if (!bad.success) expect(bad.issues[0].code).toBe("invalid_string");
-  });
-
-  it("cached regex stays correct when reused across many values", () => {
-    const s = array(string().pattern("^\\d{3}$"));
-    const r = s.safeParse(["123", "456", "789"]);
-    expect(r.success).toBe(true);
-    const r2 = s.safeParse(["123", "xx", "789"]);
-    expect(r2.success).toBe(false);
-  });
-
-  it("invalid pattern is reported as invalid_string", () => {
-    const s = string().pattern("(");
-    const r = s.safeParse("anything");
-    expect(r.success).toBe(false);
-    if (!r.success) {
-      expect(r.issues[0].code).toBe("invalid_string");
-      expect(r.issues[0].message).toContain("Invalid regex pattern");
-    }
-  });
-
-  it("re-patterning resets the compiled cache", () => {
-    const base = string().pattern("^a$");
-    const repat = base.pattern("^b$");
-    expect(base.safeParse("a").success).toBe(true);
-    expect(repat.safeParse("b").success).toBe(true);
-    expect(repat.safeParse("a").success).toBe(false);
-  });
-
-  it("long input with a safe (linear) pattern still validates", () => {
-    // Caching must not change behavior for legitimate large inputs.
-    const s = string().pattern("^x+$");
-    const big = "x".repeat(1_000_000);
-    const r = s.safeParse(big);
-    expect(r.success).toBe(true);
-  });
-});
+import { describe, it, expect } from "vitest";
+import { string, array } from "../../src/index.js";
+
+describe("String pattern: caching + ReDoS defense-in-depth", () => {
+  it("matches and rejects correctly (behavior preserved by caching)", () => {
+    const s = string().pattern("^[a-z]+$");
+    expect(s.safeParse("abc").success).toBe(true);
+    const bad = s.safeParse("ABC");
+    expect(bad.success).toBe(false);
+    if (!bad.success) expect(bad.issues[0].code).toBe("invalid_string");
+  });
+
+  it("cached regex stays correct when reused across many values", () => {
+    const s = array(string().pattern("^\\d{3}$"));
+    const r = s.safeParse(["123", "456", "789"]);
+    expect(r.success).toBe(true);
+    const r2 = s.safeParse(["123", "xx", "789"]);
+    expect(r2.success).toBe(false);
+  });
+
+  it("invalid pattern is reported as invalid_string", () => {
+    const s = string().pattern("(");
+    const r = s.safeParse("anything");
+    expect(r.success).toBe(false);
+    if (!r.success) {
+      expect(r.issues[0].code).toBe("invalid_string");
+      expect(r.issues[0].message).toContain("Invalid regex pattern");
+    }
+  });
+
+  it("re-patterning resets the compiled cache", () => {
+    const base = string().pattern("^a$");
+    const repat = base.pattern("^b$");
+    expect(base.safeParse("a").success).toBe(true);
+    expect(repat.safeParse("b").success).toBe(true);
+    expect(repat.safeParse("a").success).toBe(false);
+  });
+
+  it("long input with a safe (linear) pattern still validates", () => {
+    // Caching must not change behavior for legitimate large inputs.
+    const s = string().pattern("^x+$");
+    const big = "x".repeat(1_000_000);
+    const r = s.safeParse(big);
+    expect(r.success).toBe(true);
+  });
+});

package/tests/unit/string.test.ts

@@ -1,147 +1,147 @@
-import { describe, it, expect } from "vitest";
-import { string } from "../../src/index.js";
-
-describe("StringSchema", () => {
-  it("accepts valid strings", () => {
-    const s = string();
-    expect(s.parse("hello")).toBe("hello");
-    expect(s.parse("")).toBe("");
-  });
-
-  it("rejects non-strings", () => {
-    const s = string();
-    const result = s.safeParse(42);
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].code).toBe("invalid_type");
-    }
-  });
-
-  it("validates minLength", () => {
-    const s = string().minLength(3);
-    expect(s.parse("abc")).toBe("abc");
-    const result = s.safeParse("ab");
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].code).toBe("too_small");
-    }
-  });
-
-  it("validates maxLength", () => {
-    const s = string().maxLength(3);
-    expect(s.parse("abc")).toBe("abc");
-    const result = s.safeParse("abcd");
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].code).toBe("too_large");
-    }
-  });
-
-  it("validates pattern", () => {
-    const s = string().pattern("^[a-z]+$");
-    expect(s.parse("abc")).toBe("abc");
-    const result = s.safeParse("ABC");
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].code).toBe("invalid_string");
-    }
-  });
-
-  it("fails invalid regex patterns without throwing", () => {
-    const s = string().pattern("(");
-    expect(() => s.safeParse("abc")).not.toThrow();
-    const result = s.safeParse("abc");
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.issues[0].code).toBe("invalid_string");
-    }
-  });
-
-  it("validates startsWith", () => {
-    const s = string().startsWith("hello");
-    expect(s.parse("hello world")).toBe("hello world");
-    const result = s.safeParse("world hello");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates endsWith", () => {
-    const s = string().endsWith("world");
-    expect(s.parse("hello world")).toBe("hello world");
-    const result = s.safeParse("world hello");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates includes", () => {
-    const s = string().includes("mid");
-    expect(s.parse("a mid b")).toBe("a mid b");
-    const result = s.safeParse("no match");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates email format", () => {
-    const s = string().format("email");
-    expect(s.parse("user@example.com")).toBe("user@example.com");
-    const result = s.safeParse("notanemail");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates uuid format", () => {
-    const s = string().format("uuid");
-    expect(s.parse("550e8400-e29b-41d4-a716-446655440000")).toBe(
-      "550e8400-e29b-41d4-a716-446655440000"
-    );
-    const result = s.safeParse("not-a-uuid");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates url format", () => {
-    const s = string().format("url");
-    expect(s.parse("https://example.com")).toBe("https://example.com");
-    const result = s.safeParse("not a url");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates ipv4 format", () => {
-    const s = string().format("ipv4");
-    expect(s.parse("192.168.1.1")).toBe("192.168.1.1");
-    const result = s.safeParse("999.999.999.999");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates date format", () => {
-    const s = string().format("date");
-    expect(s.parse("2024-01-15")).toBe("2024-01-15");
-    const result = s.safeParse("2024-13-01");
-    expect(result.success).toBe(false);
-  });
-
-  it("validates date-time format", () => {
-    const s = string().format("date-time");
-    expect(s.parse("2024-01-15T10:30:00Z")).toBe("2024-01-15T10:30:00Z");
-    const result = s.safeParse("not-a-date-time");
-    expect(result.success).toBe(false);
-  });
-
-  it("chains constraints immutably", () => {
-    const base = string();
-    const constrained = base.minLength(1).maxLength(10);
-    // base should not be affected
-    expect(base.safeParse("").success).toBe(true);
-    expect(constrained.safeParse("").success).toBe(false);
-  });
-
-  it("applies coercion: trim", () => {
-    const s = string().coerce({ trim: true });
-    expect(s.parse("  hello  ")).toBe("hello");
-  });
-
-  it("applies coercion: lower", () => {
-    const s = string().coerce({ lower: true });
-    expect(s.parse("HELLO")).toBe("hello");
-  });
-
-  it("applies coercion: upper", () => {
-    const s = string().coerce({ upper: true });
-    expect(s.parse("hello")).toBe("HELLO");
-  });
-});
+import { describe, it, expect } from "vitest";
+import { string } from "../../src/index.js";
+
+describe("StringSchema", () => {
+  it("accepts valid strings", () => {
+    const s = string();
+    expect(s.parse("hello")).toBe("hello");
+    expect(s.parse("")).toBe("");
+  });
+
+  it("rejects non-strings", () => {
+    const s = string();
+    const result = s.safeParse(42);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("invalid_type");
+    }
+  });
+
+  it("validates minLength", () => {
+    const s = string().minLength(3);
+    expect(s.parse("abc")).toBe("abc");
+    const result = s.safeParse("ab");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("too_small");
+    }
+  });
+
+  it("validates maxLength", () => {
+    const s = string().maxLength(3);
+    expect(s.parse("abc")).toBe("abc");
+    const result = s.safeParse("abcd");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("too_large");
+    }
+  });
+
+  it("validates pattern", () => {
+    const s = string().pattern("^[a-z]+$");
+    expect(s.parse("abc")).toBe("abc");
+    const result = s.safeParse("ABC");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("invalid_string");
+    }
+  });
+
+  it("fails invalid regex patterns without throwing", () => {
+    const s = string().pattern("(");
+    expect(() => s.safeParse("abc")).not.toThrow();
+    const result = s.safeParse("abc");
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("invalid_string");
+    }
+  });
+
+  it("validates startsWith", () => {
+    const s = string().startsWith("hello");
+    expect(s.parse("hello world")).toBe("hello world");
+    const result = s.safeParse("world hello");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates endsWith", () => {
+    const s = string().endsWith("world");
+    expect(s.parse("hello world")).toBe("hello world");
+    const result = s.safeParse("world hello");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates includes", () => {
+    const s = string().includes("mid");
+    expect(s.parse("a mid b")).toBe("a mid b");
+    const result = s.safeParse("no match");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates email format", () => {
+    const s = string().format("email");
+    expect(s.parse("user@example.com")).toBe("user@example.com");
+    const result = s.safeParse("notanemail");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates uuid format", () => {
+    const s = string().format("uuid");
+    expect(s.parse("550e8400-e29b-41d4-a716-446655440000")).toBe(
+      "550e8400-e29b-41d4-a716-446655440000"
+    );
+    const result = s.safeParse("not-a-uuid");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates url format", () => {
+    const s = string().format("url");
+    expect(s.parse("https://example.com")).toBe("https://example.com");
+    const result = s.safeParse("not a url");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates ipv4 format", () => {
+    const s = string().format("ipv4");
+    expect(s.parse("192.168.1.1")).toBe("192.168.1.1");
+    const result = s.safeParse("999.999.999.999");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates date format", () => {
+    const s = string().format("date");
+    expect(s.parse("2024-01-15")).toBe("2024-01-15");
+    const result = s.safeParse("2024-13-01");
+    expect(result.success).toBe(false);
+  });
+
+  it("validates date-time format", () => {
+    const s = string().format("date-time");
+    expect(s.parse("2024-01-15T10:30:00Z")).toBe("2024-01-15T10:30:00Z");
+    const result = s.safeParse("not-a-date-time");
+    expect(result.success).toBe(false);
+  });
+
+  it("chains constraints immutably", () => {
+    const base = string();
+    const constrained = base.minLength(1).maxLength(10);
+    // base should not be affected
+    expect(base.safeParse("").success).toBe(true);
+    expect(constrained.safeParse("").success).toBe(false);
+  });
+
+  it("applies coercion: trim", () => {
+    const s = string().coerce({ trim: true });
+    expect(s.parse("  hello  ")).toBe("hello");
+  });
+
+  it("applies coercion: lower", () => {
+    const s = string().coerce({ lower: true });
+    expect(s.parse("HELLO")).toBe("hello");
+  });
+
+  it("applies coercion: upper", () => {
+    const s = string().coerce({ upper: true });
+    expect(s.parse("hello")).toBe("HELLO");
+  });
+});