@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.10

package/tests/EffectSchema.test.ts

@@ -0,0 +1,546 @@
+import { describe, expect, it } from "@effect/vitest";
+import { Schema } from "effect";
+import * as EffectSchema from "../src/EffectSchema";
+import * as Primitive from "../src/Primitive";
+
+// =============================================================================
+// Simple Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Simple Primitives", () => {
+  describe("toSetSchema", () => {
+    it("converts StringPrimitive to Schema.String", () => {
+      const primitive = Primitive.String();
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Verify it accepts valid strings
+      expect(Schema.decodeUnknownSync(schema)("hello")).toBe("hello");
+    });
+
+    it("converts NumberPrimitive to Schema.Number", () => {
+      const primitive = Primitive.Number();
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      expect(Schema.decodeUnknownSync(schema)(42)).toBe(42);
+    });
+
+    it("converts BooleanPrimitive to Schema.Boolean", () => {
+      const primitive = Primitive.Boolean();
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      expect(Schema.decodeUnknownSync(schema)(true)).toBe(true);
+      expect(Schema.decodeUnknownSync(schema)(false)).toBe(false);
+    });
+
+    it("converts LiteralPrimitive to Schema.Literal", () => {
+      const primitive = Primitive.Literal("active");
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      expect(Schema.decodeUnknownSync(schema)("active")).toBe("active");
+      
+      // Should reject non-matching literals
+      expect(() => Schema.decodeUnknownSync(schema)("inactive")).toThrow();
+    });
+  });
+
+  describe("toUpdateSchema", () => {
+    it("update schema for simple primitives is same as set schema", () => {
+      const stringPrimitive = Primitive.String();
+      const setSchema = EffectSchema.toSetSchema(stringPrimitive);
+      const updateSchema = EffectSchema.toUpdateSchema(stringPrimitive);
+      
+      // Both should accept strings
+      expect(Schema.decodeUnknownSync(setSchema)("test")).toBe("test");
+      expect(Schema.decodeUnknownSync(updateSchema)("test")).toBe("test");
+    });
+  });
+});
+
+// =============================================================================
+// Struct Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Struct Primitives", () => {
+  describe("toSetSchema", () => {
+    it("required fields are non-optional", () => {
+      const primitive = Primitive.Struct({
+        name: Primitive.String().required(),
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept object with required field
+      expect(Schema.decodeUnknownSync(schema)({ name: "Alice" })).toEqual({ name: "Alice" });
+      
+      // Should reject missing required field
+      expect(() => Schema.decodeUnknownSync(schema)({})).toThrow();
+    });
+
+    it("fields with defaults are optional", () => {
+      const primitive = Primitive.Struct({
+        name: Primitive.String().default("default"),
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept object with field
+      expect(Schema.decodeUnknownSync(schema)({ name: "Alice" })).toEqual({ name: "Alice" });
+      
+      // Should accept object without field (field is optional)
+      expect(Schema.decodeUnknownSync(schema)({})).toEqual({});
+    });
+
+    it("non-required fields are optional", () => {
+      const primitive = Primitive.Struct({
+        email: Primitive.String(),
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept object with field
+      expect(Schema.decodeUnknownSync(schema)({ email: "test@example.com" })).toEqual({ email: "test@example.com" });
+      
+      // Should accept object without field
+      expect(Schema.decodeUnknownSync(schema)({})).toEqual({});
+    });
+
+    it("handles mixed required/optional fields", () => {
+      const primitive = Primitive.Struct({
+        name: Primitive.String().required(),
+        age: Primitive.Number().default(0),
+        email: Primitive.String(),
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept with only required field
+      expect(Schema.decodeUnknownSync(schema)({ name: "Alice" })).toEqual({ name: "Alice" });
+      
+      // Should accept with all fields
+      expect(Schema.decodeUnknownSync(schema)({ 
+        name: "Alice", 
+        age: 30, 
+        email: "alice@example.com" 
+      })).toEqual({ 
+        name: "Alice", 
+        age: 30, 
+        email: "alice@example.com" 
+      });
+      
+      // Should reject missing required field
+      expect(() => Schema.decodeUnknownSync(schema)({ age: 30 })).toThrow();
+    });
+  });
+
+  describe("toUpdateSchema", () => {
+    it("all fields are optional for updates", () => {
+      const primitive = Primitive.Struct({
+        name: Primitive.String().required(),
+        age: Primitive.Number().default(0),
+        email: Primitive.String(),
+      });
+      
+      const schema = EffectSchema.toUpdateSchema(primitive);
+      
+      // Should accept empty object
+      expect(Schema.decodeUnknownSync(schema)({})).toEqual({});
+      
+      // Should accept partial updates
+      expect(Schema.decodeUnknownSync(schema)({ name: "Alice" })).toEqual({ name: "Alice" });
+      expect(Schema.decodeUnknownSync(schema)({ age: 30 })).toEqual({ age: 30 });
+      
+      // Should accept full object
+      expect(Schema.decodeUnknownSync(schema)({ 
+        name: "Alice", 
+        age: 30, 
+        email: "alice@example.com" 
+      })).toEqual({ 
+        name: "Alice", 
+        age: 30, 
+        email: "alice@example.com" 
+      });
+    });
+  });
+});
+
+// =============================================================================
+// Nested Struct Tests
+// =============================================================================
+
+describe("EffectSchema - Nested Structs", () => {
+  describe("toSetSchema", () => {
+    it("handles nested struct with required fields", () => {
+      const primitive = Primitive.Struct({
+        user: Primitive.Struct({
+          name: Primitive.String().required(),
+          age: Primitive.Number(),
+        }),
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept valid nested structure
+      expect(Schema.decodeUnknownSync(schema)({ 
+        user: { name: "Alice" } 
+      })).toEqual({ 
+        user: { name: "Alice" } 
+      });
+      
+      // Should reject missing required nested field
+      expect(() => Schema.decodeUnknownSync(schema)({ user: {} })).toThrow();
+    });
+  });
+
+  describe("toUpdateSchema", () => {
+    it("nested struct fields are also optional for updates", () => {
+      const primitive = Primitive.Struct({
+        user: Primitive.Struct({
+          name: Primitive.String().required(),
+          age: Primitive.Number(),
+        }),
+      });
+      
+      const schema = EffectSchema.toUpdateSchema(primitive);
+      
+      // Should accept empty object
+      expect(Schema.decodeUnknownSync(schema)({})).toEqual({});
+      
+      // Should accept partial nested update
+      expect(Schema.decodeUnknownSync(schema)({ 
+        user: { name: "Alice" } 
+      })).toEqual({ 
+        user: { name: "Alice" } 
+      });
+      
+      // Should accept nested struct with empty object (all fields optional)
+      expect(Schema.decodeUnknownSync(schema)({ user: {} })).toEqual({ user: {} });
+    });
+  });
+});
+
+// =============================================================================
+// Array Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Array Primitives", () => {
+  describe("toSetSchema", () => {
+    it("converts simple array to Schema.Array", () => {
+      const primitive = Primitive.Array(Primitive.String());
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      expect(Schema.decodeUnknownSync(schema)(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+    });
+
+    it("converts array of structs with proper field handling", () => {
+      const primitive = Primitive.Array(
+        Primitive.Struct({
+          name: Primitive.String().required(),
+          age: Primitive.Number(),
+        })
+      );
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept array with valid elements
+      expect(Schema.decodeUnknownSync(schema)([
+        { name: "Alice" },
+        { name: "Bob", age: 30 },
+      ])).toEqual([
+        { name: "Alice" },
+        { name: "Bob", age: 30 },
+      ]);
+      
+      // Should reject element missing required field
+      expect(() => Schema.decodeUnknownSync(schema)([{ age: 30 }])).toThrow();
+    });
+  });
+});
+
+// =============================================================================
+// Union Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Union Primitives", () => {
+  describe("toSetSchema", () => {
+    it("creates union schema for variants", () => {
+      const primitive = Primitive.Union({
+        variants: {
+          text: Primitive.Struct({
+            type: Primitive.Literal("text"),
+            content: Primitive.String().required(),
+          }),
+          image: Primitive.Struct({
+            type: Primitive.Literal("image"),
+            url: Primitive.String().required(),
+          }),
+        },
+      });
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept text variant
+      expect(Schema.decodeUnknownSync(schema)({ 
+        type: "text", 
+        content: "Hello" 
+      })).toEqual({ 
+        type: "text", 
+        content: "Hello" 
+      });
+      
+      // Should accept image variant
+      expect(Schema.decodeUnknownSync(schema)({ 
+        type: "image", 
+        url: "https://example.com/image.png" 
+      })).toEqual({ 
+        type: "image", 
+        url: "https://example.com/image.png" 
+      });
+    });
+  });
+
+  describe("toUpdateSchema", () => {
+    it("all variant fields are optional for updates", () => {
+      const primitive = Primitive.Union({
+        variants: {
+          text: Primitive.Struct({
+            type: Primitive.Literal("text"),
+            content: Primitive.String().required(),
+          }),
+        },
+      });
+      
+      const schema = EffectSchema.toUpdateSchema(primitive);
+      
+      // Should accept partial variant
+      expect(Schema.decodeUnknownSync(schema)({ type: "text" })).toEqual({ type: "text" });
+    });
+  });
+});
+
+// =============================================================================
+// Either Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Either Primitives", () => {
+  describe("toSetSchema", () => {
+    it("creates union of scalar types", () => {
+      const primitive = Primitive.Either(
+        Primitive.String(),
+        Primitive.Number()
+      );
+      
+      const schema = EffectSchema.toSetSchema(primitive);
+      
+      // Should accept string
+      expect(Schema.decodeUnknownSync(schema)("hello")).toBe("hello");
+      
+      // Should accept number
+      expect(Schema.decodeUnknownSync(schema)(42)).toBe(42);
+      
+      // Should reject non-matching types
+      expect(() => Schema.decodeUnknownSync(schema)(true)).toThrow();
+    });
+  });
+});
+
+// =============================================================================
+// TreeNode Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - TreeNode Primitives", () => {
+  describe("toSetSchema", () => {
+    it("delegates to data struct for set schema", () => {
+      const CardNode = Primitive.TreeNode("card", {
+        data: Primitive.Struct({
+          title: Primitive.String().required(),
+          description: Primitive.String(),
+        }),
+        children: [Primitive.TreeNodeSelf],
+      });
+      
+      const schema = EffectSchema.toSetSchema(CardNode);
+      
+      // Should accept valid data with required field
+      expect(Schema.decodeUnknownSync(schema)({ 
+        title: "My Card" 
+      })).toEqual({ 
+        title: "My Card" 
+      });
+      
+      // Should accept valid data with all fields
+      expect(Schema.decodeUnknownSync(schema)({ 
+        title: "My Card", 
+        description: "Card description" 
+      })).toEqual({ 
+        title: "My Card", 
+        description: "Card description" 
+      });
+      
+      // Should reject missing required field
+      expect(() => Schema.decodeUnknownSync(schema)({})).toThrow();
+      expect(() => Schema.decodeUnknownSync(schema)({ description: "no title" })).toThrow();
+    });
+  });
+
+  describe("toUpdateSchema", () => {
+    it("all data fields are optional for updates", () => {
+      const CardNode = Primitive.TreeNode("card", {
+        data: Primitive.Struct({
+          title: Primitive.String().required(),
+          description: Primitive.String(),
+        }),
+        children: [Primitive.TreeNodeSelf],
+      });
+      
+      const schema = EffectSchema.toUpdateSchema(CardNode);
+      
+      // Should accept empty update
+      expect(Schema.decodeUnknownSync(schema)({})).toEqual({});
+      
+      // Should accept partial update
+      expect(Schema.decodeUnknownSync(schema)({ 
+        title: "Updated Title" 
+      })).toEqual({ 
+        title: "Updated Title" 
+      });
+      
+      // Should accept update with only optional field
+      expect(Schema.decodeUnknownSync(schema)({ 
+        description: "New description" 
+      })).toEqual({ 
+        description: "New description" 
+      });
+    });
+  });
+});
+
+// =============================================================================
+// Tree Primitive Tests
+// =============================================================================
+
+describe("EffectSchema - Tree Primitives", () => {
+  describe("toSetSchema", () => {
+    it("returns array of TreeNodeState schema", () => {
+      const FolderNode = Primitive.TreeNode("folder", {
+        data: Primitive.Struct({
+          name: Primitive.String().required(),
+        }),
+        children: [Primitive.TreeNodeSelf],
+      });
+      
+      const treePrimitive = Primitive.Tree({
+        root: FolderNode,
+      });
+      
+      const schema = EffectSchema.toSetSchema(treePrimitive);
+      
+      // Should accept valid tree state
+      expect(Schema.decodeUnknownSync(schema)([
+        {
+          id: "node-1",
+          type: "folder",
+          parentId: null,
+          pos: "a0",
+          data: { name: "Root" },
+        },
+      ])).toEqual([
+        {
+          id: "node-1",
+          type: "folder",
+          parentId: null,
+          pos: "a0",
+          data: { name: "Root" },
+        },
+      ]);
+    });
+  });
+});
+
+// =============================================================================
+// TreeNodeStateSchema Export Tests
+// =============================================================================
+
+describe("EffectSchema - TreeNodeStateSchema", () => {
+  it("validates tree node state structure", () => {
+    const validNodeState = {
+      id: "node-123",
+      type: "card",
+      parentId: "parent-456",
+      pos: "a0",
+      data: { title: "Test" },
+    };
+    
+    expect(Schema.decodeUnknownSync(EffectSchema.TreeNodeStateSchema)(validNodeState)).toEqual(validNodeState);
+  });
+
+  it("accepts null parentId for root nodes", () => {
+    const rootNodeState = {
+      id: "root-1",
+      type: "folder",
+      parentId: null,
+      pos: "a0",
+      data: { name: "Root" },
+    };
+    
+    expect(Schema.decodeUnknownSync(EffectSchema.TreeNodeStateSchema)(rootNodeState)).toEqual(rootNodeState);
+  });
+
+  it("rejects invalid node state", () => {
+    const invalidNodeState = {
+      id: 123, // should be string
+      type: "card",
+      parentId: null,
+      pos: "a0",
+      data: {},
+    };
+    
+    expect(() => Schema.decodeUnknownSync(EffectSchema.TreeNodeStateSchema)(invalidNodeState)).toThrow();
+  });
+});
+
+// =============================================================================
+// Complex Example Tests
+// =============================================================================
+
+describe("EffectSchema - Complex Examples", () => {
+  it("handles the example schema from the plan", () => {
+    const UserSchema = Primitive.Struct({
+      name: Primitive.String().required(),
+      age: Primitive.Number().default(0),
+      email: Primitive.String(),
+    });
+    
+    const setSchema = EffectSchema.toSetSchema(UserSchema);
+    const updateSchema = EffectSchema.toUpdateSchema(UserSchema);
+    
+    // Set schema: name required, others optional
+    expect(Schema.decodeUnknownSync(setSchema)({ name: "Alice" })).toEqual({ name: "Alice" });
+    expect(() => Schema.decodeUnknownSync(setSchema)({})).toThrow();
+    
+    // Update schema: all optional
+    expect(Schema.decodeUnknownSync(updateSchema)({})).toEqual({});
+    expect(Schema.decodeUnknownSync(updateSchema)({ age: 30 })).toEqual({ age: 30 });
+  });
+
+  it("handles the TreeNode example from the plan", () => {
+    const CardNode = Primitive.TreeNode("card", {
+      data: Primitive.Struct({
+        title: Primitive.String().required(),
+        description: Primitive.String(),
+      }),
+      children: [Primitive.TreeNodeSelf],
+    });
+    
+    const setSchema = EffectSchema.toSetSchema(CardNode);
+    const updateSchema = EffectSchema.toUpdateSchema(CardNode);
+    
+    // Set schema: title required, description optional
+    expect(Schema.decodeUnknownSync(setSchema)({ title: "Test" })).toEqual({ title: "Test" });
+    expect(() => Schema.decodeUnknownSync(setSchema)({})).toThrow();
+    
+    // Update schema: all optional
+    expect(Schema.decodeUnknownSync(updateSchema)({})).toEqual({});
+    expect(Schema.decodeUnknownSync(updateSchema)({ description: "Updated" })).toEqual({ description: "Updated" });
+  });
+});
+

package/tests/primitives/Array.test.ts

@@ -411,6 +411,114 @@ describe("ArrayPrimitive", () => {
       expect(positions[1]! < positions[2]!).toBe(true);
     });
   });
+  describe("struct elements with defaults", () => {
+    // Define a struct element with required and optional fields
+    const TaskStruct = Primitive.Struct({
+      title: Primitive.String().required(),       // Must provide
+      priority: Primitive.Number().default(0),     // Has default, optional
+      completed: Primitive.Boolean().default(false), // Has default, optional
+    });
+
+    const taskArray = Primitive.Array(TaskStruct);
+
+    // Helper to create environment for task array
+    const createTaskEnv = (
+      state: Primitive.ArrayEntry<{ title: string; priority: number; completed: boolean }>[] = []
+    ): { env: ReturnType<typeof ProxyEnvironment.make>; operations: Operation.Operation<any, any, any>[] } => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      let currentState = [...state];
+      let idCounter = 0;
+
+      const env = ProxyEnvironment.make({
+        onOperation: (op) => {
+          operations.push(op);
+          if (op.kind === "array.insert") {
+            currentState.push(op.payload);
+          } else if (op.kind === "array.set") {
+            currentState = op.payload;
+          }
+        },
+        getState: () => currentState,
+        generateId: () => `task-${++idCounter}`,
+      });
+
+      return { env, operations };
+    };
+
+    it("push() only requires fields without defaults", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required 'title', priority and completed should use defaults
+      proxy.push({ title: "New Task" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("array.insert");
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("New Task");
+      expect(payload.value.priority).toBe(0); // Default value
+      expect(payload.value.completed).toBe(false); // Default value
+    });
+
+    it("push() allows overriding defaults", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Provide title and override priority, let completed use default
+      proxy.push({ title: "Important Task", priority: 10 });
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("Important Task");
+      expect(payload.value.priority).toBe(10); // Overridden
+      expect(payload.value.completed).toBe(false); // Default value
+    });
+
+    it("insertAt() applies defaults for omitted fields", () => {
+      const existingEntry = {
+        id: "existing",
+        pos: "a0",
+        value: { title: "Existing", priority: 5, completed: true },
+      };
+      const { env, operations } = createTaskEnv([existingEntry]);
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert with only required field
+      proxy.insertAt(0, { title: "First Task" });
+
+      const payload = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } };
+      expect(payload.value.title).toBe("First Task");
+      expect(payload.value.priority).toBe(0); // Default
+      expect(payload.value.completed).toBe(false); // Default
+    });
+
+    it("set() applies defaults to each element", () => {
+      const { env, operations } = createTaskEnv();
+      const proxy = taskArray._internal.createProxy(env, OperationPath.make(""));
+
+      // Set array with items that only have required fields
+      proxy.set([
+        { title: "Task 1" },
+        { title: "Task 2", priority: 5 },
+        { title: "Task 3", completed: true },
+      ]);
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("array.set");
+
+      const entries = operations[0]!.payload as { value: { title: string; priority: number; completed: boolean } }[];
+      expect(entries).toHaveLength(3);
+
+      // First item: only title, defaults for others
+      expect(entries[0]!.value).toEqual({ title: "Task 1", priority: 0, completed: false });
+
+      // Second item: title and priority, default for completed
+      expect(entries[1]!.value).toEqual({ title: "Task 2", priority: 5, completed: false });
+
+      // Third item: title and completed, default for priority
+      expect(entries[2]!.value).toEqual({ title: "Task 3", priority: 0, completed: true });
+    });
+  });
 });
 
 // =============================================================================