@rljson/db 0.0.10 → 0.0.12

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";
@@ -184,7 +184,6 @@ class CakeController extends BaseController {
     this._refs = _refs;
     this._contentType = "cakes";
   }
-  _table = null;
   _baseLayers = {};
   async init() {
     if (this._tableKey.endsWith("Cake") === false) {
@@ -192,9 +191,8 @@ class CakeController extends BaseController {
         `Table ${this._tableKey} is not supported by CakeController.`
       );
     }
-    const rljson = await this._core.dumpTable(this._tableKey);
-    this._table = rljson[this._tableKey];
-    if (this._table._type !== "cakes") {
+    const contentType = await this._core.contentType(this._tableKey);
+    if (contentType !== "cakes") {
       throw new Error(`Table ${this._tableKey} is not of type cakes.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -207,21 +205,9 @@ class CakeController extends BaseController {
       }
       const baseCake = baseCakes[0];
       this._baseLayers = rmhsh(baseCake.layers);
-    } else {
-      const cake = this._table._data[0];
-      if (!!cake) {
-        this._refs = {
-          sliceIdsTable: cake.sliceIdsTable,
-          sliceIdsRow: cake.sliceIdsRow
-        };
-        this._baseLayers = rmhsh(cake.layers);
-      }
     }
   }
   async getChildRefs(where, filter) {
-    if (!this._table) {
-      throw new Error(`Controller not initialized.`);
-    }
     const childRefs = [];
     const { [this._tableKey]: table } = await this.get(where, filter);
     const cakes = table._data;
@@ -302,7 +288,7 @@ class ComponentController extends BaseController {
     "edits",
     "editHistory",
     "multiEdits",
-    "head"
+    "insertHistory"
   ];
   _resolvedColumns = null;
   _refTableKeyToColumnKeyMap = null;
@@ -310,9 +296,8 @@ class ComponentController extends BaseController {
     if (!!this._refs && !this._refs.base) {
       throw new Error(`Refs are not required on ComponentController.`);
     }
-    const rljson = await this._core.dumpTable(this._tableKey);
-    const table = rljson[this._tableKey];
-    if (this._allowedContentTypes.indexOf(table._type) === -1) {
+    const contentType = await this._core.contentType(this._tableKey);
+    if (this._allowedContentTypes.indexOf(contentType) === -1) {
       throw new Error(`Table ${this._tableKey} is not of type components.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -653,9 +638,8 @@ class SliceIdController extends BaseController {
         `Table ${this._tableKey} is not supported by SliceIdController.`
       );
     }
-    const rljson = await this._core.dumpTable(this._tableKey);
-    const table = rljson[this._tableKey];
-    if (table._type !== "sliceIds") {
+    const contentType = await this._core.contentType(this._tableKey);
+    if (contentType !== "sliceIds") {
       throw new Error(`Table ${this._tableKey} is not of type sliceIds.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -666,13 +650,6 @@ class SliceIdController extends BaseController {
       if (SliceIds2.length === 0) {
         throw new Error(`Base sliceId ${this._refs.base} does not exist.`);
       }
-    } else {
-      const sliceId = table._data[0];
-      if (!!sliceId) {
-        this._refs = {
-          base: sliceId.base
-        };
-      }
     }
   }
   async insert(command, value, origin, refs) {
@@ -771,9 +748,8 @@ class LayerController extends BaseController {
         `Table ${this._tableKey} is not supported by LayerController.`
       );
     }
-    const rljson = await this._core.dumpTable(this._tableKey);
-    const table = rljson[this._tableKey];
-    if (table._type !== "layers") {
+    const contentType = await this._core.contentType(this._tableKey);
+    if (contentType !== "layers") {
       throw new Error(`Table ${this._tableKey} is not of type layers.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -792,15 +768,6 @@ class LayerController extends BaseController {
           componentsTable: baseLayer.componentsTable
         };
       }
-    } else {
-      const layer = table._data[0];
-      if (!!layer) {
-        this._refs = {
-          sliceIdsTable: layer.sliceIdsTable,
-          sliceIdsTableRow: layer.sliceIdsTableRow,
-          componentsTable: layer.componentsTable
-        };
-      }
     }
   }
   async insert(command, value, origin, refs) {
@@ -963,6 +930,199 @@ 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 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 {};
+    }
+    const treeMap = /* @__PURE__ */ new Map();
+    for (const tree of trees) {
+      treeMap.set(tree._hash, tree);
+    }
+    const buildObject = (tree) => {
+      if (!tree.isParent || !tree.children || tree.children.length === 0) {
+        return tree;
+      }
+      const result2 = {};
+      for (const childHash of tree.children) {
+        const childTree = treeMap.get(childHash);
+        if (childTree && childTree.id) {
+          result2[childTree.id] = buildObject(childTree);
+        }
+      }
+      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) {
+    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) {
@@ -973,7 +1133,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":
@@ -986,6 +1146,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.`);
   }
@@ -1071,17 +1234,8 @@ class Core {
   }
   // ...........................................................................
   async tableCfg(table) {
-    const { [table]: dump } = await this._io.dumpTable({ table });
-    const tableCfgRef = dump._tableCfg;
     const tableCfgs = await this._io.rawTableCfgs();
-    let tableCfg;
-    if (!tableCfgRef) {
-      tableCfg = tableCfgs.find((tc) => tc.key === table);
-    } else {
-      tableCfg = tableCfgs.find(
-        (tc) => tc.key === table && tc._hash === tableCfgRef
-      );
-    }
+    const tableCfg = tableCfgs.find((tc) => tc.key === table);
     return tableCfg;
   }
   // ...........................................................................
@@ -1101,7 +1255,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];
@@ -2731,7 +2885,7 @@ class Db {
    * @returns An array of Rljson objects matching the route and filter
    * @throws {Error} If the route is not valid or if any controller cannot be created
    */
-  async get(route, where, filter, sliceIds) {
+  async get(route, where, filter, sliceIds, options) {
     if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
     const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
     const controllers = await this.indexedControllers(isolatedRoute);
@@ -2740,7 +2894,9 @@ class Db {
       where,
       controllers,
       filter,
-      sliceIds
+      sliceIds,
+      void 0,
+      options
     );
     const dataWithControllers = {
       ...data,
@@ -2758,20 +2914,30 @@ class Db {
    * @param controllers - The controllers to use for fetching data
    * @param filter - Optional filter to apply to the data at the current route segment
    * @param sliceIds - Optional slice IDs to filter the data at the current route segment
+   * @param routeAccumulator - The accumulated route up to the current segment
+   * @param options - Additional options for fetching data
    * @returns - An Rljson object matching the route and filters
    */
-  async _get(route, where, controllers, filter, sliceIds, routeAccumulator) {
-    const params = {
-      route: route.flat,
-      where,
-      filter,
-      sliceIds,
-      routeAccumulator: routeAccumulator ? routeAccumulator.flat : ""
-    };
-    const cacheHash = hsh(rmhsh(params))._hash;
-    const isCached = this._cache.has(cacheHash);
-    if (isCached) {
-      return this._cache.get(cacheHash);
+  async _get(route, where, controllers, filter, sliceIds, routeAccumulator, options) {
+    const opts = options ?? {};
+    const routeHasRefs = route.flat != route.flatWithoutRefs;
+    const hasFilter = filter !== void 0 && filter.length > 0;
+    const cacheable = !!routeHasRefs || !!hasFilter;
+    let cacheHash = "";
+    if (cacheable) {
+      const params = {
+        route: route.flat,
+        where,
+        filter,
+        sliceIds,
+        routeAccumulator: routeAccumulator ? routeAccumulator.flat : "",
+        options: opts
+      };
+      cacheHash = hsh(rmhsh(params))._hash;
+      const isCached = this._cache.has(cacheHash);
+      if (isCached) {
+        return this._cache.get(cacheHash);
+      }
     }
     const nodeTableKey = route.top.tableKey;
     const nodeRoute = route;
@@ -2789,12 +2955,59 @@ 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;
+    const filterMap = filterActive ? /* @__PURE__ */ new Map() : null;
+    if (filterActive) {
+      for (const f of filter) {
+        if (f.tableKey === nodeTableKey) {
+          if (!filterMap.has(f.ref)) {
+            filterMap.set(f.ref, []);
+          }
+          filterMap.get(f.ref).push(f);
+        }
+      }
+    }
+    const sliceIdResolvePromises = /* @__PURE__ */ new Map();
+    const nodeSliceIdSet = sliceIdActive ? new Set(nodeSliceIds) : null;
+    if (sliceIdActive) {
+      for (const nodeRow of nodeRows) {
+        if (nodeType === "cakes") {
+          const cake = nodeRow;
+          const key = `${cake.sliceIdsTable}:${cake.sliceIdsRow}`;
+          if (!sliceIdResolvePromises.has(key)) {
+            sliceIdResolvePromises.set(
+              key,
+              this._resolveSliceIds(cake.sliceIdsTable, cake.sliceIdsRow)
+            );
+          }
+        } else if (nodeType === "layers") {
+          const layer = nodeRow;
+          const key = `${layer.sliceIdsTable}:${layer.sliceIdsTableRow}`;
+          if (!sliceIdResolvePromises.has(key)) {
+            sliceIdResolvePromises.set(
+              key,
+              this._resolveSliceIds(
+                layer.sliceIdsTable,
+                layer.sliceIdsTableRow
+              )
+            );
+          }
+        }
+      }
+    }
+    const resolvedSliceIds = /* @__PURE__ */ new Map();
+    if (sliceIdResolvePromises.size > 0) {
+      const entries = Array.from(sliceIdResolvePromises.entries());
+      const results = await Promise.all(entries.map(([, p]) => p));
+      entries.forEach(([key], idx) => {
+        resolvedSliceIds.set(key, new Set(results[idx]));
+      });
+    }
     const nodeRowsFiltered = [];
     for (const nodeRow of nodeRows) {
-      const filterActive = filter && filter.length > 0;
-      const sliceIdActive = nodeSliceIds && nodeSliceIds.length > 0;
       if (!filterActive && !sliceIdActive) {
         nodeRowsFiltered.push(nodeRow);
         continue;
@@ -2802,12 +3015,10 @@ class Db {
       let filterResult = false;
       const filterProperties = [];
       if (filterActive) {
-        for (const f of filter) {
-          if (f.tableKey !== nodeTableKey) continue;
-          if (nodeRow._hash === f.ref) {
-            filterProperties.push(f);
-            filterResult = true;
-          }
+        const rowFilters = filterMap.get(nodeRow._hash);
+        if (rowFilters) {
+          filterProperties.push(...rowFilters);
+          filterResult = true;
         }
       } else {
         filterResult = true;
@@ -2817,36 +3028,36 @@ class Db {
         switch (nodeType) {
           case "cakes":
             const cake = nodeRow;
-            const cakeSliceIds = await this._resolveSliceIds(
-              cake.sliceIdsTable,
-              cake.sliceIdsRow
-            );
-            const cakeMatchesSliceIds = nodeSliceIds.filter(
-              (sId) => cakeSliceIds.includes(sId)
-            );
-            if (cakeMatchesSliceIds.length > 0) sliceIdResult = true;
+            const cakeKey = `${cake.sliceIdsTable}:${cake.sliceIdsRow}`;
+            const cakeSliceIdSet = resolvedSliceIds.get(cakeKey);
+            for (const sId of nodeSliceIdSet) {
+              if (cakeSliceIdSet.has(sId)) {
+                sliceIdResult = true;
+                break;
+              }
+            }
             break;
           case "layers":
             const layer = nodeRow;
-            const layerSliceIds = await this._resolveSliceIds(
-              layer.sliceIdsTable,
-              layer.sliceIdsTableRow
-            );
-            const layerMatchesSliceIds = nodeSliceIds.filter(
-              (sId) => layerSliceIds.includes(sId)
-            );
-            if (layerMatchesSliceIds.length > 0) sliceIdResult = true;
+            const layerKey = `${layer.sliceIdsTable}:${layer.sliceIdsTableRow}`;
+            const layerSliceIdSet = resolvedSliceIds.get(layerKey);
+            for (const sId of nodeSliceIdSet) {
+              if (layerSliceIdSet.has(sId)) {
+                sliceIdResult = true;
+                break;
+              }
+            }
             break;
           case "components":
             if (filterProperties.length > 0) {
-              const componentSliceIds = filterProperties.flatMap(
-                (f) => f.sliceIds
+              const componentSliceIdSet = new Set(
+                filterProperties.flatMap((f) => f.sliceIds)
               );
-              const componentMatchesSliceIds = nodeSliceIds.filter(
-                (sId) => componentSliceIds.includes(sId)
-              );
-              if (componentMatchesSliceIds.length > 0) {
-                sliceIdResult = true;
+              for (const sId of nodeSliceIdSet) {
+                if (componentSliceIdSet.has(sId)) {
+                  sliceIdResult = true;
+                  break;
+                }
               }
             }
             break;
@@ -2867,47 +3078,68 @@ class Db {
         _hash: nodeHash
       }
     };
-    const nodeValue = node[nodeTableKey]._data.filter(
-      (v) => v !== void 0 && v !== null
-    );
     if (route.isRoot) {
+      const baseRouteStr = (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "");
       if (route.hasPropertyKey) {
-        const isolatedNode = this.isolatePropertyFromComponents(
-          node,
-          route.propertyKey
-        );
-        const result3 = {
-          rljson: isolatedNode,
-          tree: { [nodeTableKey]: node[nodeTableKey] },
-          cell: nodeValue.map(
+        const isolatedNode = opts.skipRljson ? {} : this.isolatePropertyFromComponents(node, route.propertyKey);
+        const routeWithProperty = opts.skipCell ? null : Route.fromFlat(
+          baseRouteStr + `/${route.propertyKey}`
+        ).toRouteWithProperty();
+        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: Route.fromFlat(
-                (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "") + `/${route.propertyKey}`
-              ).toRouteWithProperty(),
+              route: routeWithProperty,
               path: [[nodeTableKey, "_data", idx, route.propertyKey]]
             })
-          )
-        };
+          );
+          result3 = {
+            rljson: isolatedNode,
+            tree: tree3,
+            cell: cell3
+          };
+        }
         this._cache.set(cacheHash, result3);
         return result3;
       }
+      const routeObj = opts.skipCell ? null : Route.fromFlat(baseRouteStr);
+      const rljson2 = opts.skipRljson ? {} : node;
+      const tree2 = opts.skipTree ? {} : { [nodeTableKey]: node[nodeTableKey] };
+      const cell2 = opts.skipCell ? [] : nodeRowsFiltered.map(
+        (v, idx) => ({
+          value: v[route.propertyKey] ?? null,
+          row: v,
+          route: routeObj,
+          path: [[nodeTableKey, "_data", idx]]
+        })
+      );
       const result2 = {
-        rljson: node,
-        tree: { [nodeTableKey]: node[nodeTableKey] },
-        cell: nodeValue.map(
-          (v, idx) => ({
-            value: v[route.propertyKey] ?? null,
-            row: v,
-            route: Route.fromFlat(
-              (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "")
-            ),
-            path: [[nodeTableKey, "_data", idx]]
-          })
-        )
+        rljson: rljson2,
+        tree: tree2,
+        cell: cell2
       };
-      this._cache.set(cacheHash, result2);
+      if (cacheable) {
+        this._cache.set(cacheHash, result2);
+      }
       return result2;
     }
     const childrenRoute = route.deeper();
@@ -2916,12 +3148,20 @@ class Db {
     const childrenThroughProperty = childrenWhere?._through;
     const nodeChildrenArray = [];
     const nodeRowsMatchingChildrenRefs = /* @__PURE__ */ new Map();
+    const columnReferenceMap = nodeType === "components" ? nodeColumnCfgs.filter((c) => c.ref?.tableKey === childrenTableKey).filter(
+      (c) => c.ref && ["components", "cakes"].includes(c.ref.type)
+    ).reduce((acc, curr) => {
+      acc.set(curr.key, curr.ref.tableKey);
+      return acc;
+    }, /* @__PURE__ */ new Map()) : null;
+    const childRefsPromises = nodeRowsFiltered.map(
+      (nodeRow) => nodeController.getChildRefs(nodeRow._hash)
+    );
+    const allChildRefs = await Promise.all(childRefsPromises);
     for (let i = 0; i < nodeRowsFiltered.length; i++) {
       const nodeRow = nodeRowsFiltered[i];
-      const nodeRowObj = { ...{}, ...nodeRow };
-      const childrenRefs = await nodeController.getChildRefs(
-        nodeRow._hash
-      );
+      const nodeRowHash = nodeRow._hash;
+      const childrenRefs = allChildRefs[i];
       const childrenRefTypes = /* @__PURE__ */ new Map();
       const childrenRefSliceIds = /* @__PURE__ */ new Set();
       for (const cr of childrenRefs) {
@@ -2942,13 +3182,19 @@ class Db {
           }
         }
       }
-      if (childrenRefTypes.size > 1) {
+      const childrenRefTypesSet = /* @__PURE__ */ new Set([
+        ...childrenRefTypes.values()
+      ]);
+      if (childrenRefTypesSet.size > 1) {
         throw new Error(
-          `Db._get: Multiple reference types found for children of table ${nodeTableKey}.`
+          `Db._get: Multiple reference types found for children of node table "${nodeTableKey}" and row "${nodeRowHash}". Found types: ${[
+            ...childrenRefTypesSet
+          ].join(", ")}.`
         );
       }
-      const cakeIsReferenced = childrenRefTypes.size === 1 && [...childrenRefTypes.values()][0] === "cakes";
-      const componentIsReferenced = childrenRefTypes.size === 1 && nodeType === "components" && [...childrenRefTypes.values()][0] === "components";
+      const childrenRefType = childrenRefTypesSet.size > 0 ? [...childrenRefTypesSet][0] : null;
+      const cakeIsReferenced = childrenRefTypes.size > 0 && childrenRefType === "cakes";
+      const componentIsReferenced = childrenRefTypes.size > 0 && nodeType === "components" && childrenRefType === "components";
       const childrenSliceIds = cakeIsReferenced ? [...childrenRefSliceIds] : componentIsReferenced ? void 0 : nodeSliceIds;
       const {
         rljson: rowChildrenRljson,
@@ -2962,29 +3208,43 @@ class Db {
         childrenSliceIds,
         Route.fromFlat(
           (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "") + "/" + childrenTableKey
-        )
+        ),
+        opts
       );
+      if (!rowChildrenRljson[childrenTableKey] || rowChildrenRljson[childrenTableKey]._data.length === 0)
+        continue;
+      nodeChildrenArray.push(rowChildrenRljson);
+      if (opts.skipTree && opts.skipCell) {
+        nodeRowsMatchingChildrenRefs.set(nodeRowHash, {
+          rljson: nodeRow,
+          tree: {},
+          cell: []
+        });
+        continue;
+      }
+      const nodeRowObj = { ...nodeRow };
       if (cakeIsReferenced) {
         const refKey = [...childrenRefTypes.keys()][0];
         nodeRowObj[refKey] = rowChildrenTree;
       }
-      if (rowChildrenRljson[childrenTableKey]._data.length === 0) continue;
-      nodeChildrenArray.push(rowChildrenRljson);
       if (childrenThroughProperty) {
-        const resolvedChildrenHashes = rowChildrenRljson[childrenTableKey]._data.map((rc) => rc._hash);
+        const resolvedChildrenHashesSet = new Set(
+          rowChildrenRljson[childrenTableKey]._data.map(
+            (rc) => rc._hash
+          )
+        );
         for (const nr of nodeRowsFiltered) {
-          {
-            const throughHashesInRowCouldBeArray = nr[childrenThroughProperty];
-            const throughHashesInRow = Array.isArray(
-              throughHashesInRowCouldBeArray
-            ) ? throughHashesInRowCouldBeArray : [throughHashesInRowCouldBeArray];
-            for (const th of throughHashesInRow) {
-              if (resolvedChildrenHashes.includes(th)) {
-                nodeRowObj[childrenThroughProperty] = {
-                  ...rowChildrenTree[childrenTableKey],
-                  ...{ _tableKey: childrenTableKey }
-                };
-              }
+          const throughHashesInRowCouldBeArray = nr[childrenThroughProperty];
+          const throughHashesInRow = Array.isArray(
+            throughHashesInRowCouldBeArray
+          ) ? throughHashesInRowCouldBeArray : [throughHashesInRowCouldBeArray];
+          for (const th of throughHashesInRow) {
+            if (resolvedChildrenHashesSet.has(th)) {
+              nodeRowObj[childrenThroughProperty] = {
+                ...rowChildrenTree[childrenTableKey],
+                _tableKey: childrenTableKey
+              };
+              break;
             }
           }
         }
@@ -2993,8 +3253,14 @@ class Db {
       const childrenRefsOfRow = childrenRefs.filter(
         (cr) => cr.tableKey == childrenTableKey
       );
+      const resolvedChildrenHashSet = new Set(
+        resolvedChildren.map((ch) => ch._hash)
+      );
       const matchingChildrenRefs = childrenRefsOfRow.filter(
-        (cr) => !!resolvedChildren.find((ch) => cr.ref === ch._hash)
+        (cr) => resolvedChildrenHashSet.has(cr.ref)
+      );
+      const matchingRefsMap = new Map(
+        matchingChildrenRefs.map((cr) => [cr.ref, cr])
       );
       if (nodeType === "layers") {
         const compChildrenTrees = rowChildrenTree[childrenTableKey]._data;
@@ -3006,9 +3272,8 @@ class Db {
           };
         });
         const layerTreesAndPaths = components.map(({ tree: comp, path }) => {
-          const sliceIds2 = matchingChildrenRefs.find(
-            (cr) => cr.ref === comp._hash
-          )?.sliceIds;
+          const matchedRef = matchingRefsMap.get(comp._hash);
+          const sliceIds2 = matchedRef?.sliceIds;
           if (!sliceIds2 || sliceIds2.length === 0) {
             throw new Error(
               `Db._get: No sliceIds found for component ${comp._hash} of layer ${nodeRow._hash}.`
@@ -3020,99 +3285,90 @@ class Db {
             );
           }
           const sliceId = sliceIds2[0];
-          const pathsForSliceId = [
-            ...path.map((p) => p[0]).map((p) => {
-              const newPath = [...p];
-              newPath[2] = 0;
-              return ["add", sliceId, ...newPath];
-            })
-          ];
+          const pathsForSliceId = path.map((p) => {
+            const newPath = [...p[0]];
+            newPath[2] = 0;
+            return ["add", sliceId, ...newPath];
+          });
           return {
             [sliceId]: {
               tree: {
                 [childrenTableKey]: {
-                  ...{ _data: [comp] },
-                  ...{ _type: "components" }
+                  _data: [comp],
+                  _type: "components"
                 }
               },
               path: pathsForSliceId
             }
           };
         });
-        const layer = layerTreesAndPaths.flatMap(
-          (ltap) => Object.entries(ltap).map(([sliceId, { tree }]) => ({
-            [sliceId]: tree
-          }))
-        ).reduce((a, b) => ({ ...a, ...b }), {});
-        const paths = layerTreesAndPaths.map(
-          (ltap) => Object.values(ltap)[0].path
+        const layer = {};
+        const paths = [];
+        for (const ltap of layerTreesAndPaths) {
+          for (const [sliceId, value] of Object.entries(ltap)) {
+            layer[sliceId] = value.tree;
+            if (!opts.skipCell) {
+              paths.push(value.path);
+            }
+          }
+        }
+        const rljson2 = nodeRow;
+        const tree2 = opts.skipTree ? {} : {
+          ...nodeRowObj,
+          add: { ...nodeRowObj.add, ...layer }
+        };
+        const cell2 = opts.skipCell ? [] : rowChildrenCell.map(
+          (c, idx) => ({
+            ...c,
+            path: [paths.flat()[idx]]
+          })
         );
-        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
-          rljson: nodeRow,
-          tree: {
-            ...nodeRowObj,
-            add: { ...nodeRowObj.add, ...layer }
-          },
-          cell: rowChildrenCell.map(
-            (c, idx) => ({
-              ...c,
-              ...{
-                path: [paths.flat()[idx]]
-              }
-            })
-          )
+        nodeRowsMatchingChildrenRefs.set(nodeRowHash, {
+          rljson: rljson2,
+          tree: tree2,
+          cell: cell2
         });
       } else if (nodeType === "cakes") {
-        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+        nodeRowsMatchingChildrenRefs.set(nodeRowHash, {
           rljson: nodeRow,
-          tree: {
+          tree: opts.skipTree ? {} : {
             ...nodeRowObj,
             layers: { ...nodeRowObj.layers, ...rowChildrenTree }
           },
-          cell: rowChildrenCell.map((c) => ({
+          cell: opts.skipCell ? [] : rowChildrenCell.map((c) => ({
             ...c,
-            ...{
-              path: c.path.map((p) => ["layers", ...p])
-            }
+            path: c.path.map((p) => ["layers", ...p])
           }))
         });
       } else if (nodeType === "components") {
         if (rowChildrenTree && Object.keys(rowChildrenTree).length > 0) {
-          const columnReferenceMap = nodeColumnCfgs.filter(
-            (c) => c.ref && ["components", "cakes"].includes(c.ref.type)
-          ).reduce((acc, curr) => {
-            acc.set(curr.key, curr.ref.tableKey);
-            return acc;
-          }, /* @__PURE__ */ new Map());
-          const resolvedRefs = {};
+          const resolvedProperties = {};
+          const allCells = [];
           for (const [colKey, childTableKey] of columnReferenceMap) {
-            const tree = {
-              ...rowChildrenTree[childTableKey],
-              ...{ _tableKey: childTableKey }
-            };
-            const cell = rowChildrenCell.map((c) => ({
-              ...c,
-              ...{
+            if (!opts.skipTree) {
+              resolvedProperties[colKey] = {
+                ...rowChildrenTree[childTableKey],
+                _tableKey: childTableKey
+              };
+            }
+            if (!opts.skipCell) {
+              const cell2 = rowChildrenCell.map((c) => ({
+                ...c,
                 path: c.path.filter((p) => p[0] === childTableKey).map((p) => [colKey, ...p.slice(1)])
-              }
-            }));
-            resolvedRefs[colKey] = { tree, cell };
+              }));
+              allCells.push(...cell2);
+            }
           }
-          const resolvedProperties = Object.entries(resolvedRefs).map(([colKey, { tree }]) => ({
-            [colKey]: tree
-          })).reduce((a, b) => ({ ...a, ...b }), {});
-          const resolvedTree = {
-            ...nodeRowObj,
-            ...resolvedProperties
-          };
-          const resolvedCell = Object.values(resolvedRefs).map((r) => r.cell).flat();
-          nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          nodeRowsMatchingChildrenRefs.set(nodeRowHash, {
             rljson: nodeRow,
-            tree: resolvedTree,
-            cell: resolvedCell
+            tree: opts.skipTree ? {} : {
+              ...nodeRowObj,
+              ...resolvedProperties
+            },
+            cell: allCells
           });
         } else {
-          nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          nodeRowsMatchingChildrenRefs.set(nodeRowHash, {
             rljson: nodeRow,
             tree: { ...nodeRowObj },
             cell: rowChildrenCell
@@ -3124,43 +3380,46 @@ class Db {
         );
       }
     }
-    const nodeChildren = makeUnique(
-      merge(...nodeChildrenArray)
-    );
+    const nodeChildren = opts.skipRljson ? {} : makeUnique(merge(...nodeChildrenArray));
     const matchedNodeRows = Array.from(nodeRowsMatchingChildrenRefs.values());
-    const result = {
-      rljson: {
-        ...node,
-        ...{
-          [nodeTableKey]: {
-            ...{
-              _data: matchedNodeRows.map((mr) => mr.rljson),
-              _type: nodeType
-            },
-            ...{
-              ...nodeHash ? { _hash: nodeHash } : {}
-            }
-          }
-        },
-        ...nodeChildren
+    const rljson = opts.skipRljson ? {} : {
+      ...node,
+      [nodeTableKey]: {
+        _data: matchedNodeRows.map((mr) => mr.rljson),
+        _type: nodeType,
+        ...nodeHash ? { _hash: nodeHash } : {}
       },
-      tree: {
-        [nodeTableKey]: {
-          ...{
-            _data: matchedNodeRows.map((mr) => mr.tree),
-            _type: nodeType
-          },
-          ...{
-            ...nodeHash ? { _hash: nodeHash } : {}
-          }
+      ...nodeChildren
+    };
+    const tree = opts.skipTree ? {} : {
+      [nodeTableKey]: {
+        _data: matchedNodeRows.map((mr) => mr.tree),
+        _type: nodeType,
+        ...nodeHash ? { _hash: nodeHash } : {}
+      }
+    };
+    const cell = opts.skipCell ? [] : (() => {
+      let totalSize = 0;
+      for (const mr of matchedNodeRows) {
+        totalSize += mr.cell.length;
+      }
+      const cells = new Array(totalSize);
+      let cellIdx = 0;
+      for (let rowIdx = 0; rowIdx < matchedNodeRows.length; rowIdx++) {
+        const mr = matchedNodeRows[rowIdx];
+        for (const c of mr.cell) {
+          cells[cellIdx++] = {
+            ...c,
+            path: c.path.map((p) => [nodeTableKey, "_data", rowIdx, ...p])
+          };
         }
-      },
-      cell: matchedNodeRows.map(
-        (mr, idx) => mr.cell.map((c) => ({
-          ...c,
-          ...{ path: c.path.map((p) => [nodeTableKey, "_data", idx, ...p]) }
-        }))
-      ).flat()
+      }
+      return cells;
+    })();
+    const result = {
+      rljson,
+      tree,
+      cell
     };
     this._cache.set(cacheHash, result);
     return result;
@@ -3192,7 +3451,13 @@ class Db {
   async join(columnSelection, cakeKey, cakeRef) {
     const {
       tree: { [cakeKey]: cakesTable }
-    } = await this.get(Route.fromFlat(`${cakeKey}@${cakeRef}`), {});
+    } = await this.get(
+      Route.fromFlat(`${cakeKey}@${cakeRef}`),
+      {},
+      void 0,
+      void 0,
+      { skipCell: true, skipRljson: true }
+    );
     const cakes = cakesTable._data;
     if (cakes.length === 0) {
       throw new Error(
@@ -3266,7 +3531,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;
   }
   // ...........................................................................
   /**
@@ -3292,7 +3560,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") {
@@ -3463,10 +3731,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);
+        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);
     }
@@ -3546,21 +3835,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
@@ -4141,9 +4415,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);
     }
@@ -4192,7 +4463,11 @@ class MultiEditProcessor {
         multiEdit.previous
       );
       const previousMultiEdit = previousMultiEdits[0];
-      return this._resolve(previousMultiEdit);
+      const previousEditFromMultiEdit = previousMultiEdit.edit;
+      const previousEdit = this._edits[this._edits.length - 2] ? this._edits[this._edits.length - 2]._hash : null;
+      if (previousEdit !== previousEditFromMultiEdit) {
+        return await this._resolve(previousMultiEdit);
+      }
     }
   }
   //...........................................................................
@@ -4329,6 +4604,14 @@ class MultiEditProcessor {
     }
     return this._join;
   }
+  //...........................................................................
+  /**
+   * Get the list of Edits applied in this MultiEditProcessor
+   * @returns Array of Edits
+   */
+  get edits() {
+    return this._edits;
+  }
 }
 class MultiEditManager {
   constructor(_cakeKey, _db) {
@@ -5293,27 +5576,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")
   );
@@ -5670,27 +5932,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")
   );
@@ -5792,19 +6033,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,
@@ -5816,19 +6044,16 @@ const staticExample = () => {
       carTechnicalLayerTableCfg,
       carColorLayerTableCfg,
       carCakeTableCfg,
-      carCakeHeadTableCfg,
       seriesSliceIdTableCfg,
       seriesGeneralTableCfg,
       seriesCarsTableCfg,
       seriesGeneralLayerTableCfg,
       seriesCarsLayerTableCfg,
       seriesCakeTableCfg,
-      seriesCakeHeadTableCfg,
       catalogSliceIdTableCfg,
       catalogSeriesTableCfg,
       catalogSeriesLayerTableCfg,
-      catalogCakeTableCfg,
-      catalogCakeHeadTableCfg
+      catalogCakeTableCfg
     ]
   };
   const staticExample2 = {
@@ -5841,19 +6066,16 @@ const staticExample = () => {
     carTechnicalLayer,
     carColorLayer,
     carCake,
-    carCakeHeads,
     seriesSliceId,
     seriesGeneral,
     seriesCars,
     seriesGeneralLayer,
     seriesCarsLayer,
     seriesCake,
-    seriesCakeHeads,
     catalogSliceId,
     catalogSeries,
     catalogSeriesLayer,
     catalogCake,
-    catalogCakeHeads,
     tableCfgs
   };
   return staticExample2;