anyvali 0.3.1 → 0.3.4

package/tests/unit/date-format.test.ts

@@ -1,18 +1,18 @@
-import { describe, it, expect } from "vitest";
-import { string } from "../../src/index.js";
-
-const date = () => string().format("date");
-
-describe("date format validation", () => {
-  it("accepts valid ISO dates including early years (0001-0099)", () => {
-    for (const d of ["0001-01-01", "0050-01-01", "0099-12-31", "2021-06-15", "9999-12-31"]) {
-      expect(date().safeParse(d).success).toBe(true);
-    }
-  });
-
-  it("rejects impossible calendar dates", () => {
-    for (const d of ["2021-02-30", "2021-04-31", "2021-13-01", "2021-00-10"]) {
-      expect(date().safeParse(d).success).toBe(false);
-    }
-  });
-});
+import { describe, it, expect } from "vitest";
+import { string } from "../../src/index.js";
+
+const date = () => string().format("date");
+
+describe("date format validation", () => {
+  it("accepts valid ISO dates including early years (0001-0099)", () => {
+    for (const d of ["0001-01-01", "0050-01-01", "0099-12-31", "2021-06-15", "9999-12-31"]) {
+      expect(date().safeParse(d).success).toBe(true);
+    }
+  });
+
+  it("rejects impossible calendar dates", () => {
+    for (const d of ["2021-02-30", "2021-04-31", "2021-13-01", "2021-00-10"]) {
+      expect(date().safeParse(d).success).toBe(false);
+    }
+  });
+});

package/tests/unit/default-mutation.test.ts

@@ -1,32 +1,32 @@
-import { describe, it, expect } from "vitest";
-import { any, unknown, object } from "../../src/index.js";
-
-// Repro for AVV-007: mutable default values shared between validations.
-// Pass-through schemas (any/unknown) return the default value by reference,
-// so mutating one parse result corrupts the default for the next parse.
-describe("Mutable default isolation (AVV-007)", () => {
-  it("any() array default is not shared between parses", () => {
-    const s = any().default([] as unknown[]);
-    const a = s.parse(undefined) as unknown[];
-    a.push("mutated");
-    const b = s.parse(undefined) as unknown[];
-    expect(b).toEqual([]);
-  });
-
-  it("unknown() object default is not shared between parses", () => {
-    const s = unknown().default({ tags: [] as string[] });
-    const a = s.parse(undefined) as { tags: string[] };
-    a.tags.push("x");
-    const b = s.parse(undefined) as { tags: string[] };
-    expect(b.tags).toEqual([]);
-  });
-
-  it("object field with any() default is not shared", () => {
-    const s = object({ meta: any().default({ count: 0, items: [] as number[] }) });
-    const a = s.parse({}) as { meta: { count: number; items: number[] } };
-    a.meta.items.push(1);
-    a.meta.count = 99;
-    const b = s.parse({}) as { meta: { count: number; items: number[] } };
-    expect(b.meta).toEqual({ count: 0, items: [] });
-  });
-});
+import { describe, it, expect } from "vitest";
+import { any, unknown, object } from "../../src/index.js";
+
+// Repro for AVV-007: mutable default values shared between validations.
+// Pass-through schemas (any/unknown) return the default value by reference,
+// so mutating one parse result corrupts the default for the next parse.
+describe("Mutable default isolation (AVV-007)", () => {
+  it("any() array default is not shared between parses", () => {
+    const s = any().default([] as unknown[]);
+    const a = s.parse(undefined) as unknown[];
+    a.push("mutated");
+    const b = s.parse(undefined) as unknown[];
+    expect(b).toEqual([]);
+  });
+
+  it("unknown() object default is not shared between parses", () => {
+    const s = unknown().default({ tags: [] as string[] });
+    const a = s.parse(undefined) as { tags: string[] };
+    a.tags.push("x");
+    const b = s.parse(undefined) as { tags: string[] };
+    expect(b.tags).toEqual([]);
+  });
+
+  it("object field with any() default is not shared", () => {
+    const s = object({ meta: any().default({ count: 0, items: [] as number[] }) });
+    const a = s.parse({}) as { meta: { count: number; items: number[] } };
+    a.meta.items.push(1);
+    a.meta.count = 99;
+    const b = s.parse({}) as { meta: { count: number; items: number[] } };
+    expect(b.meta).toEqual({ count: 0, items: [] });
+  });
+});

package/tests/unit/defaults.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { string, int, object, optional } from "../../src/index.js";
+import { any, string, int, object, optional, nullable, bool, exportSchema } from "../../src/index.js";
 
 describe("Defaults", () => {
   it("applies default when value is absent", () => {
@@ -46,4 +46,73 @@ describe("Defaults", () => {
     const result = s.parse({});
     expect(result).toEqual({ count: 0 });
   });
+
+  it("applies default on optional wrapper field", () => {
+    const s = object({
+      host: optional(string()).default("localhost"),
+    });
+    expect(s.parse({})).toEqual({ host: "localhost" });
+  });
+
+  it("does not override present optional wrapper field with default", () => {
+    const s = object({
+      host: optional(string()).default("localhost"),
+    });
+    expect(s.parse({ host: "example.com" })).toEqual({ host: "example.com" });
+  });
+
+  it("validates default on optional wrapper field", () => {
+    const s = object({
+      host: optional(string().minLength(5)).default("hi"),
+    });
+    const result = s.safeParse({});
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.issues[0].code).toBe("default_invalid");
+      expect(result.issues[0].path).toEqual(["host"]);
+    }
+  });
+
+  it("exports default on optional wrapper", () => {
+    const doc = exportSchema(optional(string()).default("localhost"));
+    expect(doc.root.kind).toBe("optional");
+    expect(doc.root.default).toBe("localhost");
+  });
+
+  it("clones mutable default on optional wrapper field", () => {
+    const s = object({
+      config: optional(any()).default({ tags: [] as string[] }),
+    });
+    const first = s.parse({}) as any;
+    first.config.tags.push("mutated");
+    expect(s.parse({})).toEqual({ config: { tags: [] } });
+  });
+
+  it("does not apply default when nullable field is null", () => {
+    const s = object({
+      value: nullable(string()).default("fallback"),
+    });
+    expect(s.parse({ value: null })).toEqual({ value: null });
+  });
+
+  it("applies falsy defaults", () => {
+    const s = object({
+      count: int().default(0),
+      name: string().default(""),
+      active: bool().default(false),
+    });
+    expect(s.parse({})).toEqual({ count: 0, name: "", active: false });
+  });
+
+  it("applies nested defaults", () => {
+    const s = object({
+      user: object({
+        name: string(),
+        role: string().default("guest"),
+      }),
+    });
+    expect(s.parse({ user: { name: "Bob" } })).toEqual({
+      user: { name: "Bob", role: "guest" },
+    });
+  });
 });