@rljson/db 0.0.11 → 0.0.13

package/dist/db.js

@@ -1,4 +1,4 @@
-import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, isTimeId, getTimeIdTimestamp, createSliceIdsTableCfg, createLayerTableCfg, createCakeTableCfg, createHeadsTableCfg } from "@rljson/rljson";
+import { timeId, Route, createInsertHistoryTableCfg, Validate, BaseValidator, treeFromObject, isTimeId, getTimeIdTimestamp, createSliceIdsTableCfg, createLayerTableCfg, createCakeTableCfg } from "@rljson/rljson";
 import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
 import { equals, merge } from "@rljson/json";
 import { IoMem } from "@rljson/io";
@@ -208,9 +208,6 @@ class CakeController extends BaseController {
     }
   }
   async getChildRefs(where, filter) {
-    if (!this._tableCfg) {
-      throw new Error(`Controller not initialized.`);
-    }
     const childRefs = [];
     const { [this._tableKey]: table } = await this.get(where, filter);
     const cakes = table._data;
@@ -291,7 +288,7 @@ class ComponentController extends BaseController {
     "edits",
     "editHistory",
     "multiEdits",
-    "head"
+    "insertHistory"
   ];
   _resolvedColumns = null;
   _refTableKeyToColumnKeyMap = null;
@@ -933,6 +930,237 @@ class LayerController extends BaseController {
     return false;
   }
 }
+class TreeController extends BaseController {
+  constructor(_core, _tableKey) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._contentType = "trees";
+  }
+  async init() {
+    if (this._tableKey.endsWith("Tree") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by TreeController.`
+      );
+    }
+    const contentType = await this._core.contentType(this._tableKey);
+    if (contentType !== "trees") {
+      throw new Error(`Table ${this._tableKey} is not of type trees.`);
+    }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+  }
+  async insert(command, value, origin) {
+    if (!command.startsWith("add") && !command.startsWith("remove")) {
+      throw new Error(`Command ${command} is not supported by TreeController.`);
+    }
+    const rlJson = { [this._tableKey]: { _data: [value] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(value)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return [result];
+  }
+  async get(where, filter, path) {
+    const {
+      [this._tableKey]: { _data: trees }
+    } = typeof where === "string" ? await this._getByHash(where, filter) : await this._getByWhere(where, filter);
+    if (trees.length === 0) {
+      return { [this._tableKey]: { _data: [], _type: "trees" } };
+    }
+    if (trees.length > 1) {
+      throw new Error(
+        `Multiple trees found for where clause. Please specify a more specific query.`
+      );
+    }
+    const treeRoute = Route.fromFlat(path || "");
+    const treeId = treeRoute.segments.length > 0 ? treeRoute.top.tableKey : null;
+    const tree = trees[0];
+    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(
+        childRef,
+        void 0,
+        treeRoute.deeper().flat
+      );
+      const childData = child[this._tableKey]._data;
+      children.push(...childData);
+    }
+    return {
+      [this._tableKey]: {
+        _data: [...children, tree],
+        _type: "trees"
+      }
+    };
+  }
+  async buildTreeFromTrees(trees) {
+    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 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) {
+        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, depth + 1);
+        }
+      }
+      memo.set(hash, result2);
+      return result2;
+    };
+    const referencedHashes = /* @__PURE__ */ new Set();
+    for (const tree of trees) {
+      if (tree.children) {
+        for (const childHash of tree.children) {
+          referencedHashes.add(childHash);
+        }
+      }
+    }
+    const rootTrees = trees.filter(
+      (tree) => !referencedHashes.has(tree._hash)
+    );
+    if (rootTrees.length === 0) {
+      return {};
+    }
+    if (rootTrees.length === 1) {
+      const rootTree = rootTrees[0];
+      if (rootTree.id) {
+        return { [rootTree.id]: buildObject(rootTree) };
+      }
+      return buildObject(rootTree);
+    }
+    const result = {};
+    for (const rootTree of rootTrees) {
+      if (rootTree.id) {
+        result[rootTree.id] = buildObject(rootTree);
+      }
+    }
+    return result;
+  }
+  async buildCellsFromTree(trees) {
+    const cells = [];
+    if (trees.length === 0) {
+      return cells;
+    }
+    const treeMap = /* @__PURE__ */ new Map();
+    const childToParentMap = /* @__PURE__ */ new Map();
+    for (const tree of trees) {
+      const treeHash = tree._hash;
+      treeMap.set(treeHash, tree);
+      if (tree.children) {
+        for (const childHash of tree.children) {
+          childToParentMap.set(childHash, treeHash);
+        }
+      }
+    }
+    const availableHashes = /* @__PURE__ */ new Set();
+    for (const tree of trees) {
+      availableHashes.add(tree._hash);
+    }
+    const leafNodes = trees.filter((tree) => {
+      if (!tree.children || tree.children.length === 0) {
+        return true;
+      }
+      const hasChildInTrees = tree.children.some(
+        (childHash) => availableHashes.has(childHash)
+      );
+      return !hasChildInTrees;
+    });
+    for (const leaf of leafNodes) {
+      const pathIds = [];
+      let currentHash = leaf._hash;
+      while (currentHash) {
+        const current = treeMap.get(currentHash);
+        if (!current) break;
+        if (current.id) {
+          pathIds.unshift(current.id);
+        }
+        const parentHash = childToParentMap.get(currentHash);
+        if (!parentHash) break;
+        currentHash = parentHash;
+      }
+      const routeStr = "/" + pathIds.join("/");
+      const route = Route.fromFlat(routeStr);
+      cells.push({
+        route,
+        value: leaf,
+        row: leaf,
+        path: [[this._tableKey, "_data", 0, ...pathIds]]
+      });
+    }
+    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;
+    for (const tree of trees) {
+      for (const treeChildRef of tree.children ?? []) {
+        childRefs.push({
+          tableKey: this._tableKey,
+          ref: treeChildRef
+        });
+      }
+    }
+    return childRefs;
+  }
+  /* v8 ignore next -- @preserve */
+  async filterRow() {
+    return false;
+  }
+}
 const createController = async (type, core, tableKey, refs) => {
   let ctrl;
   switch (type) {
@@ -943,7 +1171,7 @@ const createController = async (type, core, tableKey, refs) => {
     case "edits":
     case "editHistory":
     case "multiEdits":
-    case "head":
+    case "insertHistory":
       ctrl = new ComponentController(core, tableKey, refs);
       break;
     case "cakes":
@@ -956,6 +1184,9 @@ const createController = async (type, core, tableKey, refs) => {
         refs
       );
       break;
+    case "trees":
+      ctrl = new TreeController(core, tableKey);
+      break;
     default:
       throw new Error(`Controller for type ${type} is not implemented yet.`);
   }
@@ -1048,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) {
@@ -1062,7 +1297,7 @@ const inject = (tree, path, value) => {
       tree[segment] = value;
       delete tree["_hash"];
     } else {
-      if (!tree[segment]) {
+      if (!tree[segment] || typeof tree[segment] !== "object") {
         tree[segment] = {};
       }
       tree = tree[segment];
@@ -2726,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;
@@ -2762,7 +3003,7 @@ class Db {
     delete nodeWhere["_tableKey"];
     const {
       [nodeTableKey]: { _data: nodeRows, _type: nodeType, _hash: nodeHash }
-    } = await nodeController.get(nodeWhere);
+    } = await nodeController.get(nodeWhere, void 0, route.propertyKey);
     const nodeColumnCfgs = nodeController.tableCfg().columns;
     const filterActive = filter && filter.length > 0;
     const sliceIdActive = nodeSliceIds && nodeSliceIds.length > 0;
@@ -2892,20 +3133,39 @@ class Db {
         const routeWithProperty = opts.skipCell ? null : Route.fromFlat(
           baseRouteStr + `/${route.propertyKey}`
         ).toRouteWithProperty();
-        const tree3 = opts.skipTree ? {} : { [nodeTableKey]: node[nodeTableKey] };
-        const cell3 = opts.skipCell ? [] : nodeRowsFiltered.map(
-          (v, idx) => ({
-            value: v[route.propertyKey] ?? null,
-            row: v,
-            route: routeWithProperty,
-            path: [[nodeTableKey, "_data", idx, route.propertyKey]]
-          })
-        );
-        const result3 = {
-          rljson: isolatedNode,
-          tree: tree3,
-          cell: cell3
-        };
+        let result3;
+        if (nodeType === "trees") {
+          const rljson3 = node;
+          const tree3 = opts.skipTree ? {} : {
+            [nodeTableKey]: {
+              _data: [
+                await nodeController.buildTreeFromTrees(nodeRows)
+              ],
+              _type: "trees"
+            }
+          };
+          const cell3 = opts.skipCell ? [] : await nodeController.buildCellsFromTree(nodeRows);
+          result3 = {
+            rljson: rljson3,
+            tree: tree3,
+            cell: cell3
+          };
+        } else {
+          const tree3 = opts.skipTree ? {} : { [nodeTableKey]: node[nodeTableKey] };
+          const cell3 = opts.skipCell ? [] : nodeRowsFiltered.map(
+            (v, idx) => ({
+              value: v[route.propertyKey] ?? null,
+              row: v,
+              route: routeWithProperty,
+              path: [[nodeTableKey, "_data", idx, route.propertyKey]]
+            })
+          );
+          result3 = {
+            rljson: isolatedNode,
+            tree: tree3,
+            cell: cell3
+          };
+        }
         this._cache.set(cacheHash, result3);
         return result3;
       }
@@ -3319,7 +3579,10 @@ class Db {
     for (const [tableKey, controller] of Object.entries(controllers)) {
       runFns[tableKey] = controller.insert.bind(controller);
     }
-    return this._insert(route, tree, runFns, options);
+    const insertHistoryRow = await this._insert(route, tree, runFns, options);
+    if (!options?.skipHistory)
+      await this._writeInsertHistory(route.top.tableKey, insertHistoryRow[0]);
+    return insertHistoryRow;
   }
   // ...........................................................................
   /**
@@ -3345,7 +3608,7 @@ class Db {
     const previousHash = nodeSegment[nodeTableKey + "Ref"] ?? null;
     const previousTimeId = nodeSegment[nodeTableKey + "InsertHistoryRef"] ?? null;
     const previous = previousHash ? await this.getTimeIdsForRef(nodeTableKey, previousHash) : previousTimeId ? [previousTimeId] : [];
-    if (!nodeRoute.isRoot) {
+    if (!nodeRoute.isRoot && nodeType != "trees") {
       const childRoute = nodeRoute.deeper(1);
       const childTableKey = childRoute.top.tableKey;
       if (nodeType === "cakes") {
@@ -3516,10 +3779,31 @@ class Db {
           );
         }
       }
+      if (nodeType === "trees") {
+        const treeObject = tree[nodeTableKey]._data[0];
+        if (!treeObject) {
+          throw new Error(
+            `Db._insert: No tree data found for table "${nodeTableKey}" in route "${route.flat}".`
+          );
+        }
+        const trees = treeFromObject(treeObject, true);
+        const writePromises = trees.map(
+          (tree2) => runFn("add", tree2, "db.insert")
+        );
+        const writeResults = await Promise.all(writePromises);
+        const lastResult = writeResults[writeResults.length - 1];
+        if (lastResult && lastResult.length > 0) {
+          results.push(
+            ...lastResult.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
     }
     for (const result of results) {
-      if (!options?.skipHistory)
-        await this._writeInsertHistory(nodeTableKey, result);
       if (!options?.skipNotification)
         this.notify.notify(Route.fromFlat(result.route), result);
     }
@@ -3599,21 +3883,6 @@ class Db {
     });
   }
   // ...........................................................................
-  /**
-   * Add a head revision for a cake
-   * @param cakeKey - The cake table key
-   * @param cakeRef - The cake reference
-   */
-  async addHeadRevision(cakeKey, cakeRef) {
-    const cakeHeadKey = cakeKey + "Heads";
-    const cakeHeadController = await this.getController(cakeHeadKey);
-    return await cakeHeadController.insert("add", {
-      cakeRef,
-      timeId: timeId(),
-      _hash: ""
-    });
-  }
-  // ...........................................................................
   /**
    * Add a multiEdit
    * @param cakeKey - The cake table key
@@ -3641,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;
   }
   // ...........................................................................
@@ -4194,9 +4461,6 @@ class MultiEditProcessor {
     }
     const inserted = inserteds[0];
     const writtenCakeRef = inserted[this._cakeKey + "Ref"];
-    if (!options?.skipHeadUpdate) {
-      await this._db.addHeadRevision(this._cakeKey, writtenCakeRef);
-    }
     if (!options?.skipSaveMultiEdit) {
       await this._db.addMultiEdit(this._cakeKey, this._multiEdit);
     }
@@ -5358,27 +5622,6 @@ const staticExample = () => {
       }
     ]
   });
-  const carCakeHeadTableCfg = hip(
-    createHeadsTableCfg("carCake")
-  );
-  const carCakeHeads = hip({
-    _tableCfg: carCakeHeadTableCfg._hash,
-    _type: "head",
-    _data: [
-      {
-        timeId: "1764756756311:jkCG",
-        cakeRef: carCake._data[0]._hash
-      },
-      {
-        timeId: "1764756756312:1AGV",
-        cakeRef: carCake._data[1]._hash
-      },
-      {
-        timeId: "1764756756312:g8nh",
-        cakeRef: carCake._data[2]._hash
-      }
-    ]
-  });
   const seriesSliceIdTableCfg = hip(
     createSliceIdsTableCfg("seriesSliceId")
   );
@@ -5735,27 +5978,6 @@ const staticExample = () => {
       }
     ]
   });
-  const seriesCakeHeadTableCfg = hip(
-    createHeadsTableCfg("seriesCake")
-  );
-  const seriesCakeHeads = hip({
-    _tableCfg: seriesCakeHeadTableCfg._hash,
-    _type: "head",
-    _data: [
-      {
-        timeId: "1764756756315:L14y",
-        cakeRef: seriesCake._data[0]._hash
-      },
-      {
-        timeId: "1764756756315:xCXT",
-        cakeRef: seriesCake._data[1]._hash
-      },
-      {
-        timeId: "1764756756315:fZwA",
-        cakeRef: seriesCake._data[2]._hash
-      }
-    ]
-  });
   const catalogSliceIdTableCfg = hip(
     createSliceIdsTableCfg("catalogSliceId")
   );
@@ -5857,19 +6079,6 @@ const staticExample = () => {
       }
     ]
   });
-  const catalogCakeHeadTableCfg = hip(
-    createHeadsTableCfg("catalogCake")
-  );
-  const catalogCakeHeads = hip({
-    _tableCfg: catalogCakeHeadTableCfg._hash,
-    _type: "head",
-    _data: [
-      {
-        timeId: "1764756756317:5UTy",
-        cakeRef: catalogCake._data[0]._hash
-      }
-    ]
-  });
   const tableCfgs = {
     _data: [
       carSliceIdTableCfg,
@@ -5881,19 +6090,16 @@ const staticExample = () => {
       carTechnicalLayerTableCfg,
       carColorLayerTableCfg,
       carCakeTableCfg,
-      carCakeHeadTableCfg,
       seriesSliceIdTableCfg,
       seriesGeneralTableCfg,
       seriesCarsTableCfg,
       seriesGeneralLayerTableCfg,
       seriesCarsLayerTableCfg,
       seriesCakeTableCfg,
-      seriesCakeHeadTableCfg,
       catalogSliceIdTableCfg,
       catalogSeriesTableCfg,
       catalogSeriesLayerTableCfg,
-      catalogCakeTableCfg,
-      catalogCakeHeadTableCfg
+      catalogCakeTableCfg
     ]
   };
   const staticExample2 = {
@@ -5906,19 +6112,16 @@ const staticExample = () => {
     carTechnicalLayer,
     carColorLayer,
     carCake,
-    carCakeHeads,
     seriesSliceId,
     seriesGeneral,
     seriesCars,
     seriesGeneralLayer,
     seriesCarsLayer,
     seriesCake,
-    seriesCakeHeads,
     catalogSliceId,
     catalogSeries,
     catalogSeriesLayer,
     catalogCake,
-    catalogCakeHeads,
     tableCfgs
   };
   return staticExample2;
@@ -5934,6 +6137,10 @@ export {
   exampleEditActionRowSort,
   exampleEditActionSetValue,
   exampleEditSetValueReferenced,
+  inject,
+  isolate,
+  makeUnique,
+  mergeTrees,
   staticExample
 };
 //# sourceMappingURL=db.js.map