@voidhash/mimic 0.0.1-alpha.5 → 0.0.1-alpha.7

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(),
+        age: Primitive.Number().required(),
+        email: Primitive.String(),
+      }).default({ name: "John Doe" });
+
+      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,128 @@ 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"]);
+    });
+  });
 });
 
 // =============================================================================