@voidhash/mimic 0.0.3 → 0.0.5

package/tests/primitives/Tree.test.ts

@@ -54,11 +54,18 @@ describe("TreePrimitive", () => {
     });
 
     it("default() returns a new TreePrimitive with default value", () => {
-      const defaultState: Primitive.TreeState<typeof FolderNode> = [
-        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
-      ];
-      const withDefault = fileSystemTree.default(defaultState);
-      expect(withDefault._internal.getInitialState()).toEqual(defaultState);
+      const defaultInput = {
+        type: "folder" as const,
+        id: "root",
+        name: "Root",
+        children: [],
+      };
+      const withDefault = fileSystemTree.default(defaultInput);
+      const initialState = withDefault._internal.getInitialState();
+      expect(initialState).toHaveLength(1);
+      expect(initialState![0]!.id).toBe("root");
+      expect(initialState![0]!.type).toBe("folder");
+      expect(initialState![0]!.data).toEqual({ name: "Root" });
     });
   });
 
@@ -70,18 +77,26 @@ describe("TreePrimitive", () => {
       expect(proxy.get()).toEqual([]);
     });
 
-    it("set() generates tree.set operation", () => {
+    it("set() generates tree.set operation with nested input converted to flat", () => {
       const { env, operations } = createEnvWithState();
       const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
 
-      const nodes: Primitive.TreeState<typeof FolderNode> = [
-        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
-      ];
-      proxy.set(nodes);
+      const nestedInput = {
+        type: "folder" as const,
+        name: "Root",
+        children: [],
+      };
+      proxy.set(nestedInput);
 
       expect(operations).toHaveLength(1);
       expect(operations[0]!.kind).toBe("tree.set");
-      expect(operations[0]!.payload).toEqual(nodes);
+      // The payload should be flat format
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      expect(payload).toHaveLength(1);
+      expect(payload[0]!.type).toBe("folder");
+      expect(payload[0]!.data).toEqual({ name: "Root" });
+      expect(payload[0]!.parentId).toBe(null);
+      expect(payload[0]!.id).toBe("node-1"); // Generated by env.generateId
     });
 
     it("root() returns the root node", () => {
@@ -452,12 +467,20 @@ describe("TreePrimitive", () => {
       expect(typeof initialState![0]!.pos).toBe("string");
     });
 
-    it("returns the default value when set", () => {
-      const defaultState: Primitive.TreeState<typeof FolderNode> = [
-        { id: "root", type: "folder", parentId: null, pos: "a0", data: { name: "Root" } },
-      ];
-      const withDefault = fileSystemTree.default(defaultState);
-      expect(withDefault._internal.getInitialState()).toEqual(defaultState);
+    it("returns the default value when set (converted from nested)", () => {
+      const defaultInput = {
+        type: "folder" as const,
+        id: "root",
+        name: "Root",
+        children: [],
+      };
+      const withDefault = fileSystemTree.default(defaultInput);
+      const initialState = withDefault._internal.getInitialState();
+      expect(initialState).toHaveLength(1);
+      expect(initialState![0]!.id).toBe("root");
+      expect(initialState![0]!.type).toBe("folder");
+      expect(initialState![0]!.parentId).toBe(null);
+      expect(initialState![0]!.data).toEqual({ name: "Root" });
     });
   });
 
@@ -712,6 +735,257 @@ describe("TreePrimitive", () => {
   });
 });
 
+describe("TreePrimitive - nested input for set() and default()", () => {
+  // Define node types using the new TreeNode API
+  // Using TreeNodeSelf for self-referential nodes preserves type safety
+  const FileNode = Primitive.TreeNode("file", {
+    data: Primitive.Struct({ name: Primitive.String(), size: Primitive.Number().default(0) }),
+    children: [] as const,
+  });
+
+  const FolderNode = Primitive.TreeNode("folder", {
+    data: Primitive.Struct({ name: Primitive.String() }),
+    children: [Primitive.TreeNodeSelf, FileNode],
+  });
+
+  const fileSystemTree = Primitive.Tree({
+    root: FolderNode,
+  });
+
+  // Helper to create a mock environment with state access
+  const createEnvWithState = (
+    state: Primitive.TreeState<typeof FolderNode> = []
+  ): { 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 FolderNode>;
+    let idCounter = 0;
+
+    const env = ProxyEnvironment.make({
+      onOperation: (op) => {
+        operations.push(op);
+        // Apply operation to keep state in sync
+        currentState = fileSystemTree._internal.applyOperation(currentState, op);
+      },
+      getState: () => currentState,
+      generateId: () => `node-${++idCounter}`,
+    });
+
+    return { env, operations };
+  };
+
+  describe("set() with nested input", () => {
+    it("converts nested input to flat TreeState", () => {
+      const { env, operations } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({
+        type: "folder",
+        name: "Root",
+        children: [
+          { type: "file", name: "file1.txt", children: [] },
+          { type: "file", name: "file2.txt", children: [] },
+        ],
+      });
+
+      expect(operations).toHaveLength(1);
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      expect(payload).toHaveLength(3);
+
+      // Root
+      expect(payload[0]!.type).toBe("folder");
+      expect(payload[0]!.parentId).toBe(null);
+      expect(payload[0]!.data).toEqual({ name: "Root" });
+
+      // First file child
+      expect(payload[1]!.type).toBe("file");
+      expect(payload[1]!.parentId).toBe(payload[0]!.id);
+      expect(payload[1]!.data).toEqual({ name: "file1.txt", size: 0 }); // size has default
+
+      // Second file child
+      expect(payload[2]!.type).toBe("file");
+      expect(payload[2]!.parentId).toBe(payload[0]!.id);
+      expect(payload[2]!.data).toEqual({ name: "file2.txt", size: 0 });
+
+      // Positions should be in order
+      expect(payload[1]!.pos < payload[2]!.pos).toBe(true);
+    });
+
+    it("allows explicit IDs in nested input", () => {
+      const { env, operations } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({
+        type: "folder",
+        id: "my-root",
+        name: "Root",
+        children: [
+          { type: "file", id: "my-file", name: "file.txt", children: [] },
+        ],
+      });
+
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      expect(payload[0]!.id).toBe("my-root");
+      expect(payload[1]!.id).toBe("my-file");
+    });
+
+    it("throws on duplicate IDs", () => {
+      const { env } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      expect(() =>
+        proxy.set({
+          type: "folder",
+          id: "dup",
+          name: "Root",
+          children: [
+            { type: "file", id: "dup", name: "file.txt", children: [] },
+          ],
+        })
+      ).toThrow(Primitive.ValidationError);
+    });
+
+    it("validates child types against schema", () => {
+      const { env } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      // File nodes cannot have children with type "folder"
+      // But since we can't test FileNode as root (wrong type), let's test folder with wrong child
+      // Actually FolderNode accepts both FolderNode and FileNode, so this won't fail on types
+      // Let's test wrong root type instead - but the input is typed, so this is caught at compile time
+      // We can test runtime by forcing wrong type
+      const invalidInput = {
+        type: "file" as "folder", // Cast to bypass type check
+        name: "WrongRoot",
+        children: [],
+      };
+
+      expect(() => proxy.set(invalidInput as any)).toThrow(Primitive.ValidationError);
+    });
+
+    it("handles deeply nested structures", () => {
+      const { env, operations } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({
+        type: "folder",
+        name: "Root",
+        children: [
+          {
+            type: "folder" as const,
+            name: "Level1",
+            children: [
+              {
+                type: "folder",
+                name: "Level2",
+                children: [
+                  { type: "file", name: "deep.txt", children: [] },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      expect(payload).toHaveLength(4);
+
+      // Verify parent chain (cast data to access name since TreeNodeState.data is unknown)
+      const root = payload.find(n => (n.data as { name: string }).name === "Root");
+      const level1 = payload.find(n => (n.data as { name: string }).name === "Level1");
+      const level2 = payload.find(n => (n.data as { name: string }).name === "Level2");
+      const deep = payload.find(n => (n.data as { name: string }).name === "deep.txt");
+
+      expect(root!.parentId).toBe(null);
+      expect(level1!.parentId).toBe(root!.id);
+      expect(level2!.parentId).toBe(level1!.id);
+      expect(deep!.parentId).toBe(level2!.id);
+    });
+
+    it("applies data defaults to nested input", () => {
+      const { env, operations } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({
+        type: "folder",
+        name: "Root",
+        children: [
+          { type: "file", name: "file.txt", children: [] }, // size omitted, should use default
+        ],
+      });
+
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      const fileNode = payload.find(n => n.type === "file");
+      expect((fileNode!.data as any).size).toBe(0); // Default value
+    });
+  });
+
+  describe("default() with nested input", () => {
+    it("creates initial state from nested default", () => {
+      const treeWithDefault = fileSystemTree.default({
+        type: "folder",
+        id: "default-root",
+        name: "Default Root",
+        children: [
+          { type: "file", id: "default-file", name: "readme.txt", children: [] },
+        ],
+      });
+
+      const initialState = treeWithDefault._internal.getInitialState();
+      expect(initialState).toHaveLength(2);
+
+      const root = initialState!.find(n => n.id === "default-root");
+      const file = initialState!.find(n => n.id === "default-file");
+
+      expect(root!.type).toBe("folder");
+      expect(root!.parentId).toBe(null);
+      expect(root!.data).toEqual({ name: "Default Root" });
+
+      expect(file!.type).toBe("file");
+      expect(file!.parentId).toBe("default-root");
+      expect((file!.data as any).size).toBe(0); // Default applied
+    });
+
+    it("generates IDs for default when not provided", () => {
+      const treeWithDefault = fileSystemTree.default({
+        type: "folder",
+        name: "Root",
+        children: [],
+      });
+
+      const initialState = treeWithDefault._internal.getInitialState();
+      expect(initialState).toHaveLength(1);
+      expect(typeof initialState![0]!.id).toBe("string");
+      expect(initialState![0]!.id.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("sibling ordering", () => {
+    it("maintains children order with correct positions", () => {
+      const { env, operations } = createEnvWithState();
+      const proxy = fileSystemTree._internal.createProxy(env, OperationPath.make(""));
+
+      proxy.set({
+        type: "folder",
+        name: "Root",
+        children: [
+          { type: "file", id: "first", name: "a.txt", children: [] },
+          { type: "file", id: "second", name: "b.txt", children: [] },
+          { type: "file", id: "third", name: "c.txt", children: [] },
+        ],
+      });
+
+      const payload = operations[0]!.payload as Primitive.TreeState<typeof FolderNode>;
+      const first = payload.find(n => n.id === "first")!;
+      const second = payload.find(n => n.id === "second")!;
+      const third = payload.find(n => n.id === "third")!;
+
+      // Positions should be in ascending order
+      expect(first.pos < second.pos).toBe(true);
+      expect(second.pos < third.pos).toBe(true);
+    });
+  });
+});
+
 // =============================================================================
 // Integration Tests - Tree with Complex Structures
 // =============================================================================

package/tests/server/ServerDocument.test.ts

@@ -41,7 +41,7 @@ const createTransactionFromDoc = <TSchema extends Primitive.AnyPrimitive>(
   initialState: Primitive.InferState<TSchema> | undefined,
   fn: (root: Primitive.InferProxy<TSchema>) => void
 ): Transaction.Transaction => {
-  const doc = Document.make(schema, { initial: initialState });
+  const doc = Document.make(schema, { initialState: initialState });
   doc.transaction(fn);
   return doc.flush();
 };

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.build.json",
-  "include": ["src", "test"],
+  "include": ["src", "tests"],
   "compilerOptions": {
     "allowJs": false,
     "strictNullChecks": true