anyvali 0.3.1 → 0.3.4

package/tests/unit/inference.test.ts

@@ -1,306 +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>();
-    });
-  });
-});
+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>();
+    });
+  });
+});