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

package/tests/primitives/Struct.test.ts

@@ -66,6 +66,46 @@ describe("StructPrimitive", () => {
       expect(operations[0]!.payload).toEqual({ name: "Alice", age: "30" });
     });
 
+    it("set() only requires fields that are required and without defaults", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().required().default("John Doe"),
+        age: Primitive.Number().required(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+      proxy.set({ age: 30 });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("struct.set");
+      expect(operations[0]!.payload).toEqual({ name: "John Doe", age: 30, email: undefined });
+    });
+
+    it("set() only requires fields that are required and without defaults", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String().required().default("John Doe"),
+        age: Primitive.Number().required(),
+        email: Primitive.String(),
+      }).default({ age: 30 });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+      proxy.set({ age: 30 });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("struct.set");
+      expect(operations[0]!.payload).toEqual({ name: "John Doe", age: 30, email: undefined });
+    });
+
     it("multiple field sets generate separate operations", () => {
       const operations: Operation.Operation<any, any, any>[] = [];
       const env = ProxyEnvironment.make((op) => {
@@ -304,6 +344,216 @@ describe("StructPrimitive", () => {
       expect(typeof proxy.set).toBe("function");
     });
   });
+
+  describe("update", () => {
+    it("update() generates individual field operations", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({ name: "John" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("John");
+      expect(operations[0]!.path.toTokens()).toEqual(["name"]);
+    });
+
+    it("update() with multiple fields generates multiple operations", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        firstName: Primitive.String(),
+        lastName: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({ firstName: "John", lastName: "Doe" });
+
+      expect(operations).toHaveLength(2);
+      expect(operations.map((op) => op.payload)).toContain("John");
+      expect(operations.map((op) => op.payload)).toContain("Doe");
+    });
+
+    it("update() skips undefined values", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({ name: "John", email: undefined });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.payload).toBe("John");
+    });
+
+    it("update() recursively updates nested structs", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const addressPrimitive = Primitive.Struct({
+        street: Primitive.String(),
+        city: Primitive.String(),
+        zip: Primitive.String(),
+      });
+
+      const personPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        address: addressPrimitive,
+      });
+
+      const proxy = personPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      // Partial update of nested struct - only city should be updated
+      proxy.update({ address: { city: "New York" } });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("New York");
+      expect(operations[0]!.path.toTokens()).toEqual(["address", "city"]);
+    });
+
+    it("update() handles deeply nested structs", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const coordsPrimitive = Primitive.Struct({
+        lat: Primitive.String(),
+        lng: Primitive.String(),
+      });
+
+      const locationPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        coords: coordsPrimitive,
+      });
+
+      const personPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        location: locationPrimitive,
+      });
+
+      const proxy = personPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({ location: { coords: { lat: "40.7128" } } });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.payload).toBe("40.7128");
+      expect(operations[0]!.path.toTokens()).toEqual(["location", "coords", "lat"]);
+    });
+
+    it("update() can update both nested and top-level fields", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const addressPrimitive = Primitive.Struct({
+        city: Primitive.String(),
+        zip: Primitive.String(),
+      });
+
+      const personPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        address: addressPrimitive,
+      });
+
+      const proxy = personPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({ name: "Jane", address: { city: "Boston" } });
+
+      expect(operations).toHaveLength(2);
+
+      const nameOp = operations.find((op) => op.path.toTokens().join("/") === "name");
+      const cityOp = operations.find((op) => op.path.toTokens().join("/") === "address/city");
+
+      expect(nameOp).toBeDefined();
+      expect(nameOp!.payload).toBe("Jane");
+
+      expect(cityOp).toBeDefined();
+      expect(cityOp!.payload).toBe("Boston");
+    });
+
+    it("update() with empty object generates no operations", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.update({});
+
+      expect(operations).toHaveLength(0);
+    });
+
+    it("update() ignores unknown fields", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make(""));
+
+      // Cast to any to bypass type checking for testing unknown fields
+      (proxy as any).update({ name: "John", unknownField: "value" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.payload).toBe("John");
+    });
+
+    it("update() with nested path prefix", () => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      const env = ProxyEnvironment.make((op) => {
+        operations.push(op);
+      });
+
+      const structPrimitive = Primitive.Struct({
+        name: Primitive.String(),
+        email: Primitive.String(),
+      });
+
+      const proxy = structPrimitive._internal.createProxy(env, OperationPath.make("users/0"));
+
+      proxy.update({ name: "Updated" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.path.toTokens()).toEqual(["users", "0", "name"]);
+    });
+  });
 });
 
 // =============================================================================

package/tests/primitives/Tree.test.ts

@@ -460,6 +460,256 @@ describe("TreePrimitive", () => {
       expect(withDefault._internal.getInitialState()).toEqual(defaultState);
     });
   });
+
+  describe("proxy - partial update", () => {
+    it("update() on TypedNodeProxy updates only specified fields", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "file1", type: "file", parentId: "root", pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env, operations } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // Use the update method via as()
+      const fileProxy = proxy.node("file1")!.as(FileNode);
+      fileProxy.update({ name: "UpdatedName" });
+
+      // Should generate only a string.set operation for the name field
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.path.toTokens()).toEqual(["file1", "name"]);
+      expect(operations[0]!.payload).toBe("UpdatedName");
+    });
+
+    it("update() preserves other fields when updating partial data", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "file1", type: "file", parentId: "root", pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env, operations } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // Update only the size field
+      proxy.node("file1")!.as(FileNode).update({ size: 200 });
+
+      // Should generate only a number.set operation for the size field
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("number.set");
+      expect(operations[0]!.path.toTokens()).toEqual(["file1", "size"]);
+      expect(operations[0]!.payload).toBe(200);
+
+      // The name should remain unchanged in the state
+      const updatedState = proxy.get();
+      const file1 = updatedState.find(n => n.id === "file1");
+      expect(file1!.data).toEqual({ name: "File1", size: 200 });
+    });
+
+    it("update() handles multiple fields at once", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "file1", type: "file", parentId: "root", pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env, operations } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // Update both name and size
+      proxy.node("file1")!.as(FileNode).update({ name: "NewFile", size: 500 });
+
+      // Should generate two operations
+      expect(operations).toHaveLength(2);
+      
+      // Verify both fields were updated
+      const updatedState = proxy.get();
+      const file1 = updatedState.find(n => n.id === "file1");
+      expect(file1!.data).toEqual({ name: "NewFile", size: 500 });
+    });
+
+    it("updateAt() provides convenient partial update by node id", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "file1", type: "file", parentId: "root", pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env, operations } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // Use updateAt for convenience
+      proxy.updateAt("file1", FileNode, { name: "QuickUpdate" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("string.set");
+      expect(operations[0]!.path.toTokens()).toEqual(["file1", "name"]);
+      expect(operations[0]!.payload).toBe("QuickUpdate");
+    });
+
+    it("updateAt() throws for wrong node type", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "file1", type: "file", parentId: null, pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // Trying to update a file node as a folder should throw
+      expect(() => proxy.updateAt("file1", FolderNode, { name: "NewName" })).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("updateAt() throws for non-existent node", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      expect(() => proxy.updateAt("nonexistent", FileNode, { name: "Name" })).toThrow(
+        Primitive.ValidationError
+      );
+    });
+
+    it("data.update() on at() proxy also works for partial updates", () => {
+      const initialState: Primitive.TreeState<typeof FolderNode> = [
+        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "file1", type: "file", parentId: "root", pos: "a0", data: { name: "File1", size: 100 } },
+      ];
+      const { env, operations } = createEnvWithState(initialState);
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // The at() method returns the data proxy which has update()
+      proxy.at("file1", FileNode).update({ size: 999 });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("number.set");
+      expect(operations[0]!.path.toTokens()).toEqual(["file1", "size"]);
+    });
+  });
+
+  describe("proxy - insert with defaults", () => {
+    // Define node types with defaults
+    const ItemNodeWithDefaults = Primitive.TreeNode("item", {
+      data: Primitive.Struct({ 
+        title: Primitive.String().required(), // Must provide
+        count: Primitive.Number().default(0), // Has default, optional
+        active: Primitive.Boolean().default(true), // Has default, optional
+      }),
+      children: [] as const,
+    });
+
+    const ContainerNodeWithDefaults = Primitive.TreeNode("container", {
+      data: Primitive.Struct({ 
+        name: Primitive.String().required(), // Must provide
+      }),
+      children: (): readonly Primitive.AnyTreeNodePrimitive[] => [ContainerNodeWithDefaults, ItemNodeWithDefaults],
+    });
+
+    const treeWithDefaults = Primitive.Tree({
+      root: ContainerNodeWithDefaults,
+    });
+
+    // Helper to create a mock environment
+    const createEnvWithDefaultsTree = (
+      state: Primitive.TreeState<typeof ContainerNodeWithDefaults> = []
+    ): { env: ReturnType<typeof ProxyEnvironment.make>; operations: Operation.Operation<any, any, any>[] } => {
+      const operations: Operation.Operation<any, any, any>[] = [];
+      let currentState = [...state] as Primitive.TreeState<typeof ContainerNodeWithDefaults>;
+      let idCounter = 0;
+
+      const env = ProxyEnvironment.make({
+        onOperation: (op) => {
+          operations.push(op);
+          currentState = treeWithDefaults._internal.applyOperation(currentState, op);
+        },
+        getState: () => currentState,
+        generateId: () => `node-${++idCounter}`,
+      });
+
+      return { env, operations };
+    };
+
+    it("insertFirst() only requires fields without defaults", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required field 'title', count and active should use defaults
+      const newId = proxy.insertFirst("root", ItemNodeWithDefaults, { title: "New Item" });
+
+      expect(operations).toHaveLength(1);
+      expect(operations[0]!.kind).toBe("tree.insert");
+      expect(newId).toBe("node-1");
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("New Item");
+      expect(payload.data.count).toBe(0); // Default value
+      expect(payload.data.active).toBe(true); // Default value
+    });
+
+    it("insertLast() applies defaults for omitted fields", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Provide title and override count, let active use default
+      proxy.insertLast("root", ItemNodeWithDefaults, { title: "Item", count: 42 });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Item");
+      expect(payload.data.count).toBe(42); // Overridden
+      expect(payload.data.active).toBe(true); // Default value
+    });
+
+    it("insertAt() allows omitting all optional fields with defaults", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Only provide required 'name' for container
+      proxy.insertAt("root", 0, ContainerNodeWithDefaults, { name: "Subfolder" });
+
+      const payload = operations[0]!.payload as { type: string; data: { name: string } };
+      expect(payload.type).toBe("container");
+      expect(payload.data.name).toBe("Subfolder");
+    });
+
+    it("insertAfter() uses defaults when fields are omitted", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "item1", type: "item", parentId: "root", pos: "a0", data: { title: "First", count: 1, active: false } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert after sibling with only required field
+      proxy.insertAfter("item1", ItemNodeWithDefaults, { title: "Second" });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Second");
+      expect(payload.data.count).toBe(0); // Default
+      expect(payload.data.active).toBe(true); // Default
+    });
+
+    it("insertBefore() uses defaults when fields are omitted", () => {
+      const initialState: Primitive.TreeState<typeof ContainerNodeWithDefaults> = [
+        { id: "root", type: "container", parentId: null, pos: "a0", data: { name: "Root" } },
+        { id: "item1", type: "item", parentId: "root", pos: "a0", data: { title: "First", count: 1, active: false } },
+      ];
+      const { env, operations } = createEnvWithDefaultsTree(initialState);
+      const proxy = treeWithDefaults._internal.createProxy(env, OperationPath.make(""));
+
+      // Insert before sibling with only required field, override active
+      proxy.insertBefore("item1", ItemNodeWithDefaults, { title: "Zeroth", active: false });
+
+      const payload = operations[0]!.payload as { data: { title: string; count: number; active: boolean } };
+      expect(payload.data.title).toBe("Zeroth");
+      expect(payload.data.count).toBe(0); // Default
+      expect(payload.data.active).toBe(false); // Overridden
+    });
+  });
 });
 
 // =============================================================================

package/tsdown.config.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from "tsdown";
 
-export const input = ["./src/index.ts"];
+export const input = ["./src/index.ts", "./src/server/index.ts", "./src/client/index.ts"];
 
 export default defineConfig({
 	target: ["es2017"],