@rljson/db 0.0.12 → 0.0.13

package/dist/README.trouble.md

@@ -6,9 +6,58 @@
 
 ## Table of contents <!-- omit in toc -->
 
+- [Tree INSERT operations failing with empty results](#tree-insert-operations-failing-with-empty-results)
 - [Vscode Windows: Debugging is not working](#vscode-windows-debugging-is-not-working)
 - [GitHub actions: Cannot find module @rollup/rollup-linux-x64-gnu](#github-actions-cannot-find-module-rolluprollup-linux-x64-gnu)
 
+## Tree INSERT operations failing with empty results
+
+Date: 2026-01-28
+
+### Symptoms
+
+- Tree INSERT operations complete without errors
+- GET queries after INSERT return empty results or only root node
+- Cell length is 1 instead of expected count
+- Navigation stops at root level
+
+### Root Cause
+
+The `treeFromObject` function from `@rljson/rljson` v0.0.74+ creates an explicit root node with `id='root'` at the end of the tree array. When inserting an already-isolated subtree (from `isolate()`), this created a double-root structure:
+
+```
+Auto-root (id='root')
+  └─ User-root (id='root')
+       └─ actual data nodes
+```
+
+When `TreeController` navigates the tree, it stops at the first node with `id='root'` (the auto-root), which has no meaningful data.
+
+### Solution
+
+✅ **Fixed in current version**: The `db.ts` file now calls `treeFromObject` with `skipRootCreation: true` parameter:
+
+```typescript
+const trees = treeFromObject(treeObject, true);
+```
+
+This prevents the automatic root wrapper from being created during INSERT operations.
+
+### Verification
+
+Run the tree INSERT tests:
+
+```bash
+pnpm test --run --grep "insert on tree"
+```
+
+All tree INSERT tests should pass:
+
+- "insert on tree root node"
+- "insert on tree deeper leaf"
+- "insert on tree simple branch"
+- "insert new child on branch"
+
 ## Vscode Windows: Debugging is not working
 
 Date: 2025-03-08

package/dist/db.js

@@ -984,6 +984,15 @@ class TreeController extends BaseController {
     if (treeId && treeId !== tree.id) {
       return { [this._tableKey]: { _data: [], _type: "trees" } };
     }
+    const shouldExpandChildren = path !== void 0;
+    if (!shouldExpandChildren) {
+      return {
+        [this._tableKey]: {
+          _data: [tree],
+          _type: "trees"
+        }
+      };
+    }
     const children = [];
     for (const childRef of tree.children ?? []) {
       const child = await this.get(
@@ -1005,21 +1014,47 @@ class TreeController extends BaseController {
     if (trees.length === 0) {
       return {};
     }
+    if (trees.length > 1e5) {
+      throw new Error(
+        `TreeController.buildTreeFromTrees: Tree size exceeds limit (${trees.length} > 100000 nodes). This may indicate a performance issue or data structure problem.`
+      );
+    }
     const treeMap = /* @__PURE__ */ new Map();
     for (const tree of trees) {
       treeMap.set(tree._hash, tree);
     }
-    const buildObject = (tree) => {
+    const memo = /* @__PURE__ */ new Map();
+    let buildObjectCallCount = 0;
+    const MAX_ITERATIONS = 1e6;
+    const buildObject = (tree, depth = 0) => {
+      buildObjectCallCount++;
+      if (buildObjectCallCount > MAX_ITERATIONS) {
+        throw new Error(
+          `TreeController.buildTreeFromTrees: Maximum iterations (${MAX_ITERATIONS}) exceeded. This likely indicates a bug. Processed ${buildObjectCallCount} nodes from ${trees.length} total.`
+        );
+      }
+      if (depth > 1e4) {
+        throw new Error(
+          `TreeController.buildTreeFromTrees: Tree depth exceeds limit (${depth} > 10000). This may indicate a circular reference or extremely deep structure.`
+        );
+      }
+      const hash = tree._hash;
+      if (memo.has(hash)) {
+        return memo.get(hash);
+      }
       if (!tree.isParent || !tree.children || tree.children.length === 0) {
-        return tree;
+        const result3 = tree;
+        memo.set(hash, result3);
+        return result3;
       }
       const result2 = {};
       for (const childHash of tree.children) {
         const childTree = treeMap.get(childHash);
         if (childTree && childTree.id) {
-          result2[childTree.id] = buildObject(childTree);
+          result2[childTree.id] = buildObject(childTree, depth + 1);
         }
       }
+      memo.set(hash, result2);
       return result2;
     };
     const referencedHashes = /* @__PURE__ */ new Set();
@@ -1105,6 +1140,9 @@ class TreeController extends BaseController {
     return cells;
   }
   async getChildRefs(where, filter) {
+    if (typeof where === "string") {
+      return [];
+    }
     const childRefs = [];
     const { [this._tableKey]: table } = await this.get(where, filter);
     const trees = table._data;
@@ -1241,7 +1279,11 @@ class Core {
   // ...........................................................................
   /** Reads a specific row from a database table */
   async readRow(table, rowHash) {
-    return await this._io.readRows({ table, where: { _hash: rowHash } });
+    const result = await this._io.readRows({
+      table,
+      where: { _hash: rowHash }
+    });
+    return result;
   }
   // ...........................................................................
   async readRows(table, where) {
@@ -2919,6 +2961,12 @@ class Db {
    * @returns - An Rljson object matching the route and filters
    */
   async _get(route, where, controllers, filter, sliceIds, routeAccumulator, options) {
+    const depth = routeAccumulator ? routeAccumulator.flat.split("/").length : 1;
+    if (depth > 100) {
+      throw new Error(
+        `Db._get: Maximum recursion depth (100) exceeded. This likely indicates a bug in route resolution or where clause construction. Current route: ${route.flat}, routeAccumulator: ${routeAccumulator?.flat}`
+      );
+    }
     const opts = options ?? {};
     const routeHasRefs = route.flat != route.flatWithoutRefs;
     const hasFilter = filter !== void 0 && filter.length > 0;
@@ -3738,7 +3786,7 @@ class Db {
             `Db._insert: No tree data found for table "${nodeTableKey}" in route "${route.flat}".`
           );
         }
-        const trees = treeFromObject(treeObject);
+        const trees = treeFromObject(treeObject, true);
         const writePromises = trees.map(
           (tree2) => runFn("add", tree2, "db.insert")
         );
@@ -3862,9 +3910,7 @@ class Db {
     const multiEditController = await this.getController(
       cakeKey + "MultiEdits"
     );
-    const { [cakeKey + "MultiEdits"]: result } = await multiEditController.get(
-      where
-    );
+    const { [cakeKey + "MultiEdits"]: result } = await multiEditController.get(where);
     return result._data;
   }
   // ...........................................................................
@@ -6091,6 +6137,10 @@ export {
   exampleEditActionRowSort,
   exampleEditActionSetValue,
   exampleEditSetValueReferenced,
+  inject,
+  isolate,
+  makeUnique,
+  mergeTrees,
   staticExample
 };
 //# sourceMappingURL=db.js.map