@rljson/db 0.0.6 → 0.0.8

package/dist/db.js

@@ -1,13 +1,16 @@
-import { equals, merge } from "@rljson/json";
-import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, validateInsert, isTimeId } from "@rljson/rljson";
 import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
+import { equals, merge } from "@rljson/json";
+import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, isTimeId } from "@rljson/rljson";
 import { IoMem } from "@rljson/io";
+import { traverse } from "object-traversal";
 import { compileExpression } from "filtrex";
 class BaseController {
   constructor(_core, _tableKey) {
     this._core = _core;
     this._tableKey = _tableKey;
   }
+  _contentType;
+  _tableCfg;
   // ...........................................................................
   /**
    * Retrieves the current state of the table.
@@ -66,6 +69,28 @@ class BaseController {
     });
     return rows;
   }
+  // ...........................................................................
+  /**
+   * Gets the content type of the controller.
+   * @returns The content type managed by the controller.
+   */
+  /* v8 ignore next -- @preserve */
+  contentType() {
+    return this._contentType ?? "components";
+  }
+  // ...........................................................................
+  /**
+   * Gets the table configuration of the controller.
+   * @returns The table configuration managed by the controller.
+   */
+  tableCfg() {
+    if (!this._tableCfg) {
+      throw new Error(
+        `TableCfg for controller ${this._tableKey} is not initialized.`
+      );
+    }
+    return this._tableCfg;
+  }
 }
 class CakeController extends BaseController {
   constructor(_core, _tableKey, _refs) {
@@ -73,6 +98,7 @@ class CakeController extends BaseController {
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "cakes";
   }
   _table = null;
   _baseLayers = {};
@@ -87,7 +113,8 @@ class CakeController extends BaseController {
     if (this._table._type !== "cakes") {
       throw new Error(`Table ${this._tableKey} is not of type cakes.`);
     }
-    if (this._refs && this._refs.base) {
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+    if (this._refs && this._refs.base && this._refs.base !== void 0 && this._refs.base.length > 0) {
       const {
         [this._tableKey]: { _data: baseCakes }
       } = await this._core.readRow(this._tableKey, this._refs.base);
@@ -98,10 +125,13 @@ class CakeController extends BaseController {
       this._baseLayers = rmhsh(baseCake.layers);
     } else {
       const cake = this._table._data[0];
-      this._refs = {
-        sliceIdsTable: cake.sliceIdsTable,
-        sliceIdsRow: cake.sliceIdsRow
-      };
+      if (!!cake) {
+        this._refs = {
+          sliceIdsTable: cake.sliceIdsTable,
+          sliceIdsRow: cake.sliceIdsRow
+        };
+        this._baseLayers = rmhsh(cake.layers);
+      }
     }
   }
   async getChildRefs(where, filter) {
@@ -126,8 +156,21 @@ class CakeController extends BaseController {
     if (!command.startsWith("add")) {
       throw new Error(`Command ${command} is not supported by CakeController.`);
     }
+    if (this._refs?.base) delete this._refs.base;
+    const normalizedValue = {};
+    for (const [layerTable, layerRef] of Object.entries(
+      value.layers
+    )) {
+      if (Array.isArray(layerRef) && layerRef.length > 1) {
+        throw new Error(
+          `CakeController insert: Layer ref for table ${layerTable} cannot be an array of size > 1. No 1:n relations supported.`
+        );
+      }
+      normalizedValue[layerTable] = Array.isArray(layerRef) ? layerRef[0] : layerRef;
+    }
     const cake = {
-      layers: { ...this._baseLayers, ...value },
+      ...value,
+      layers: { ...this._baseLayers, ...normalizedValue },
       ...refs || this._refs
     };
     const rlJson = { [this._tableKey]: { _data: [cake] } };
@@ -141,7 +184,7 @@ class CakeController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
@@ -152,7 +195,7 @@ class CakeController extends BaseController {
       return Promise.resolve({});
     }
   }
-  filterRow(row, key, value) {
+  async filterRow(row, key, value) {
     const cake = row;
     for (const [layerKey, layerRef] of Object.entries(cake.layers)) {
       if (layerKey === key && layerRef === value) {
@@ -168,8 +211,14 @@ class ComponentController extends BaseController {
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "components";
   }
-  _tableCfg = null;
+  _allowedContentTypes = [
+    "components",
+    "edits",
+    "editHistory",
+    "multiEdits"
+  ];
   _resolvedColumns = null;
   _refTableKeyToColumnKeyMap = null;
   async init() {
@@ -178,7 +227,7 @@ class ComponentController extends BaseController {
     }
     const rljson = await this._core.dumpTable(this._tableKey);
     const table = rljson[this._tableKey];
-    if (table._type !== "components") {
+    if (this._allowedContentTypes.indexOf(table._type) === -1) {
       throw new Error(`Table ${this._tableKey} is not of type components.`);
     }
     this._tableCfg = await this._core.tableCfg(this._tableKey);
@@ -197,17 +246,20 @@ class ComponentController extends BaseController {
       throw new Error(`Refs are not supported on ComponentController.`);
     }
     const component = value;
+    delete component._somethingToInsert;
     const rlJson = { [this._tableKey]: { _data: [component] } };
     await this._core.import(rlJson);
-    return {
-      //Ref to component
-      [this._tableKey + "Ref"]: hsh(component)._hash,
-      //Data from edit
-      route: "",
-      origin,
-      //Unique id/timestamp
-      timeId: timeId()
-    };
+    return [
+      {
+        //Ref to component
+        [this._tableKey + "Ref"]: hsh(component)._hash,
+        //Data from edit
+        route: "",
+        origin,
+        //Unique id/timestamp
+        timeId: timeId()
+      }
+    ];
   }
   // ...........................................................................
   /**
@@ -242,6 +294,20 @@ class ComponentController extends BaseController {
                 columnKey: propertyKey,
                 ref: refItem
               });
+              continue;
+            }
+            if (typeof refItem === "object" && refItem !== null) {
+              const cakeReference = refItem;
+              childRefs.set(
+                `${childRefTableKey}|${propertyKey}|${cakeReference.ref}|${cakeReference.sliceIds?.join(",")}`,
+                {
+                  tableKey: childRefTableKey,
+                  columnKey: propertyKey,
+                  ref: cakeReference.ref,
+                  sliceIds: cakeReference.sliceIds
+                }
+              );
+              continue;
             }
           }
           continue;
@@ -274,7 +340,7 @@ class ComponentController extends BaseController {
         const column = Object.keys(refWhere)[0];
         const refValue = refWhere[column];
         for (const row of tableData) {
-          if (this.filterRow(row, column, refValue)) {
+          if (await this.filterRow(row, column, refValue)) {
             consolidatedRows.set(row._hash, row);
           }
         }
@@ -473,7 +539,7 @@ class ComponentController extends BaseController {
       return this._core.readRows(table, where);
     }
   }
-  filterRow(row, key, value) {
+  async filterRow(row, key, value) {
     for (const [propertyKey, propertyValue] of Object.entries(row)) {
       if (propertyKey === key && equals(propertyValue, value)) {
         return true;
@@ -488,12 +554,131 @@ class ComponentController extends BaseController {
     return false;
   }
 }
+class SliceIdController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+    this._contentType = "sliceIds";
+  }
+  async init() {
+    if (this._tableKey.endsWith("SliceId") === false) {
+      throw new Error(
+        `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") {
+      throw new Error(`Table ${this._tableKey} is not of type sliceIds.`);
+    }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: SliceIds2 }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      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) {
+    if (!command.startsWith("add") && !command.startsWith("remove")) {
+      throw new Error(
+        `Command ${command} is not supported by SliceIdController.`
+      );
+    }
+    const sliceIds = command.startsWith("add") === true ? {
+      add: value,
+      ...refs || this._refs
+    } : {
+      add: [],
+      remove: value,
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [sliceIds] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(sliceIds)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return [result];
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else {
+      return this._getByWhere(where, filter);
+    }
+  }
+  async resolveBaseSliceIds(sliceIds) {
+    const add = /* @__PURE__ */ new Set();
+    const remove = /* @__PURE__ */ new Set();
+    if (!!sliceIds.base) {
+      const baseSliceIds = await this.get(sliceIds.base);
+      if (!baseSliceIds[this._tableKey]?._data?.[0]) {
+        throw new Error(`Base sliceIds ${sliceIds.base} does not exist.`);
+      }
+      if (baseSliceIds[this._tableKey]._data.length > 1) {
+        throw new Error(
+          `Base sliceIds ${sliceIds.base} has more than one entry.`
+        );
+      }
+      const baseSliceId = baseSliceIds[this._tableKey]._data[0];
+      const resolvedBaseSliceIds = await this.resolveBaseSliceIds(baseSliceId);
+      for (const sliceId of resolvedBaseSliceIds.add) {
+        add.add(sliceId);
+      }
+    }
+    for (const sliceId of sliceIds.add) {
+      add.add(sliceId);
+    }
+    if (!!sliceIds.remove)
+      for (const sliceId of sliceIds.remove) {
+        remove.add(sliceId);
+      }
+    for (const sliceId of remove.values()) {
+      if (add.has(sliceId)) {
+        add.delete(sliceId);
+      }
+    }
+    return { add: Array.from(add) };
+  }
+  /* v8 ignore next -- @preserve */
+  async getChildRefs() {
+    return [];
+  }
+  async filterRow(row, _, value) {
+    const sliceIds = row;
+    const sliceId = value;
+    for (const sId of Object.values(sliceIds.add)) {
+      if (sliceId === sId) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
 class LayerController extends BaseController {
   constructor(_core, _tableKey, _refs) {
     super(_core, _tableKey);
     this._core = _core;
     this._tableKey = _tableKey;
     this._refs = _refs;
+    this._contentType = "layers";
   }
   async init() {
     if (this._tableKey.endsWith("Layer") === false) {
@@ -506,6 +691,7 @@ class LayerController extends BaseController {
     if (table._type !== "layers") {
       throw new Error(`Table ${this._tableKey} is not of type layers.`);
     }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
     if (this._refs && this._refs.base) {
       const {
         [this._tableKey]: { _data: baseLayers }
@@ -523,11 +709,13 @@ class LayerController extends BaseController {
       }
     } else {
       const layer = table._data[0];
-      this._refs = {
-        sliceIdsTable: layer.sliceIdsTable,
-        sliceIdsTableRow: layer.sliceIdsTableRow,
-        componentsTable: layer.componentsTable
-      };
+      if (!!layer) {
+        this._refs = {
+          sliceIdsTable: layer.sliceIdsTable,
+          sliceIdsTableRow: layer.sliceIdsTableRow,
+          componentsTable: layer.componentsTable
+        };
+      }
     }
   }
   async insert(command, value, origin, refs) {
@@ -536,13 +724,30 @@ class LayerController extends BaseController {
         `Command ${command} is not supported by LayerController.`
       );
     }
-    const layer = command.startsWith("add") === true ? {
-      add: value,
-      ...refs || this._refs
+    const isAdd = command.startsWith("add");
+    const normalizedValue = {};
+    for (const [sliceId, compRef] of isAdd ? Object.entries(value.add) : Object.entries(value.remove)) {
+      if (Array.isArray(compRef) && compRef.length > 1) {
+        throw new Error(
+          `LayerController insert: Component ref for slice ${sliceId} cannot be an array of size > 1. No 1:n relations supported.`
+        );
+      }
+      normalizedValue[sliceId] = Array.isArray(compRef) ? compRef[0] : compRef;
+    }
+    const layer = isAdd ? {
+      ...value,
+      ...{
+        add: normalizedValue,
+        remove: {}
+      },
+      ...refs
     } : {
-      add: {},
-      remove: value,
-      ...refs || this._refs
+      ...value,
+      ...{
+        remove: normalizedValue,
+        add: {}
+      },
+      ...refs
     };
     const rlJson = { [this._tableKey]: { _data: [layer] } };
     await this._core.import(rlJson);
@@ -555,7 +760,7 @@ class LayerController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
@@ -564,25 +769,108 @@ class LayerController extends BaseController {
       return this._getByWhere(where, filter);
     }
   }
+  async resolveBaseLayer(layer) {
+    const add = /* @__PURE__ */ new Map();
+    const sliceIds = /* @__PURE__ */ new Set();
+    if (!!layer.base) {
+      const baseLayer = await this.get(layer.base);
+      if (!baseLayer[this._tableKey]?._data?.[0]) {
+        throw new Error(`Base layer ${layer.base} does not exist.`);
+      }
+      if (baseLayer[this._tableKey]._data.length > 1) {
+        throw new Error(
+          `Base layer ${layer.base} resolving not possible. Not unique.`
+        );
+      }
+      const baseLayerData = rmhsh(baseLayer[this._tableKey]._data[0]);
+      const baseLayerResolved = await this.resolveBaseLayer(baseLayerData);
+      for (const [sliceId, compRef] of Object.entries(baseLayerResolved.add)) {
+        if (sliceId.startsWith("_")) continue;
+        add.set(sliceId, compRef);
+      }
+      for (const sliceId of baseLayerResolved.sliceIds) {
+        sliceIds.add(sliceId);
+      }
+      const baseLayerSliceIdsTable = baseLayerData.sliceIdsTable;
+      const baseLayerSliceIdsRow = baseLayerData.sliceIdsTableRow;
+      const {
+        [baseLayerSliceIdsTable]: { _data: baseLayerSliceIds }
+      } = await this._core.readRow(
+        baseLayerSliceIdsTable,
+        baseLayerSliceIdsRow
+      );
+      for (const sIds of baseLayerSliceIds) {
+        const sliceIdController = new SliceIdController(
+          this._core,
+          baseLayerSliceIdsTable
+        );
+        const resolvedSliceIds = await sliceIdController.resolveBaseSliceIds(
+          sIds
+        );
+        for (const sId of resolvedSliceIds.add) {
+          if (sId.startsWith("_")) continue;
+          sliceIds.add(sId);
+        }
+      }
+    }
+    const {
+      [layer.sliceIdsTable]: { _data: layerSliceIds }
+    } = await this._core.readRow(layer.sliceIdsTable, layer.sliceIdsTableRow);
+    if (!layerSliceIds || layerSliceIds.length === 0) {
+      throw new Error(
+        `Layer sliceIds ${layer.sliceIdsTableRow} does not exist.`
+      );
+    }
+    if (layerSliceIds.length > 1) {
+      throw new Error(
+        `Layer sliceIds ${layer.sliceIdsTableRow} has more than one entry.`
+      );
+    }
+    const layerSliceId = layerSliceIds[0];
+    for (const sId of layerSliceId.add) {
+      if (sId.startsWith("_")) continue;
+      sliceIds.add(sId);
+    }
+    if (!!layerSliceId.remove)
+      for (const sId of Object.keys(layerSliceId.remove)) {
+        if (sliceIds.has(sId)) {
+          sliceIds.delete(sId);
+        }
+      }
+    for (const [sliceId, compRef] of Object.entries(layer.add)) {
+      if (sliceId.startsWith("_")) continue;
+      add.set(sliceId, compRef);
+    }
+    if (!!layer.remove)
+      for (const sliceId of Object.keys(layer.remove)) {
+        if (add.has(sliceId)) {
+          add.delete(sliceId);
+        }
+      }
+    return { add: Object.fromEntries(add), sliceIds: Array.from(sliceIds) };
+  }
   async getChildRefs(where, filter) {
     const { [this._tableKey]: table } = await this.get(where, filter);
     const childRefs = [];
     for (const row of table._data) {
       const layer = row;
-      for (const [sliceId, compRef] of Object.entries(layer.add)) {
+      const resolvedLayer = await this.resolveBaseLayer(layer);
+      for (const [sliceId, ref] of Object.entries(resolvedLayer.add)) {
         if (sliceId.startsWith("_")) continue;
         childRefs.push({
           tableKey: layer.componentsTable,
-          ref: compRef
+          ref,
+          sliceIds: [sliceId]
         });
       }
     }
     return childRefs;
   }
-  filterRow(row, _, value) {
+  async filterRow(row, _, value) {
     const layer = row;
     const compRef = value;
-    for (const componentRef of Object.values(layer.add)) {
+    const resolvedLayer = await this.resolveBaseLayer(layer);
+    for (const componentRef of Object.values(resolvedLayer.add)) {
       if (componentRef === compRef) {
         return true;
       }
@@ -597,11 +885,21 @@ const createController = async (type, core, tableKey, refs) => {
       ctrl = new LayerController(core, tableKey, refs);
       break;
     case "components":
+    case "edits":
+    case "editHistory":
+    case "multiEdits":
       ctrl = new ComponentController(core, tableKey, refs);
       break;
     case "cakes":
       ctrl = new CakeController(core, tableKey, refs);
       break;
+    case "sliceIds":
+      ctrl = new SliceIdController(
+        core,
+        tableKey,
+        refs
+      );
+      break;
     default:
       throw new Error(`Controller for type ${type} is not implemented yet.`);
   }
@@ -665,7 +963,7 @@ class Core {
     const validate = new Validate();
     validate.addValidator(new BaseValidator());
     const result = await validate.run(data);
-    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound) {
+    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound && !result.base.layerBasesNotFound) {
       throw new Error(
         "The imported rljson data is not valid:\n" + JSON.stringify(result, null, 2)
       );
@@ -711,6 +1009,152 @@ class Core {
     return this._io.readRows({ table, where });
   }
 }
+const inject = (tree, path, value) => {
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (i === path.length - 1) {
+      tree[segment] = value;
+      delete tree["_hash"];
+    } else {
+      if (!tree[segment]) {
+        tree[segment] = {};
+      }
+      tree = tree[segment];
+    }
+  }
+};
+const isolate = (tree, path, preservedKeys = []) => {
+  if (path.length === 0) {
+    return Array.isArray(tree) ? [] : {};
+  }
+  if (tree == null) {
+    return null;
+  }
+  const [currentKey, ...remainingPath] = path;
+  const result = Array.isArray(tree) ? [] : {};
+  if (!Array.isArray(tree)) {
+    for (const key in tree) {
+      if (typeof key === "string" && key.startsWith("_") || preservedKeys.includes(key)) {
+        result[key] = tree[key];
+      }
+    }
+  }
+  if (!(currentKey in tree)) {
+    return result;
+  }
+  const currentValue = tree[currentKey];
+  if (remainingPath.length === 0) {
+    if (Array.isArray(result)) {
+      result[currentKey] = currentValue;
+    } else {
+      result[currentKey] = currentValue;
+    }
+  } else {
+    const isolatedChild = isolate(currentValue, remainingPath, preservedKeys);
+    const hasContent = Array.isArray(isolatedChild) ? isolatedChild.length > 0 : Object.keys(isolatedChild).length > 0;
+    if (hasContent || isolatedChild === null) {
+      if (Array.isArray(result)) {
+        result[currentKey] = isolatedChild;
+      } else {
+        result[currentKey] = isolatedChild;
+      }
+    }
+  }
+  return result;
+};
+const mergeTrees = (trees) => {
+  if (!trees || trees.length === 0) {
+    return {};
+  }
+  let result = {};
+  for (const { tree } of trees) {
+    if (tree != null) {
+      result = mergeStructures(result, tree);
+    }
+  }
+  const pathValues = [];
+  for (const { tree, path } of trees) {
+    if (tree == null) continue;
+    let current = tree;
+    let pathExists = true;
+    for (const key of path) {
+      if (current == null || !(key in current)) {
+        pathExists = false;
+        break;
+      }
+      current = current[key];
+    }
+    if (pathExists && current != null) {
+      pathValues.push({ path, value: current });
+    }
+  }
+  const pathGroups = /* @__PURE__ */ new Map();
+  for (const { path, value } of pathValues) {
+    const pathKey = JSON.stringify(path);
+    if (!pathGroups.has(pathKey)) {
+      pathGroups.set(pathKey, []);
+    }
+    pathGroups.get(pathKey).push(value);
+  }
+  for (const [pathKey, values] of pathGroups) {
+    const path = JSON.parse(pathKey);
+    let mergedValue = void 0;
+    for (const value of values) {
+      if (value == null) continue;
+      if (mergedValue === void 0) {
+        mergedValue = value;
+        continue;
+      }
+      if (Array.isArray(mergedValue) && Array.isArray(value)) {
+        mergedValue = [...mergedValue, ...value];
+      } else if (!Array.isArray(mergedValue) && !Array.isArray(value)) {
+        mergedValue = {
+          ...mergedValue,
+          ...value
+        };
+      }
+    }
+    let current = result;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      if (current == null || !(key in current)) {
+        current[key] = typeof path[i + 1] === "number" ? [] : {};
+      }
+      current = current[key];
+    }
+    if (path.length > 0) {
+      current[path[path.length - 1]] = mergedValue;
+    }
+  }
+  return result;
+};
+function mergeStructures(target, source) {
+  if (source == null) return target;
+  if (target == null) return source;
+  if (Array.isArray(target) && Array.isArray(source)) {
+    const result = [...target];
+    for (let i = 0; i < source.length; i++) {
+      if (result[i] === void 0) {
+        result[i] = source[i];
+      } else {
+        result[i] = mergeStructures(result[i], source[i]);
+      }
+    }
+    return result;
+  }
+  if (typeof target === "object" && typeof source === "object" && !Array.isArray(target) && !Array.isArray(source) && target !== null && source !== null) {
+    const result = { ...target };
+    for (const key in source) {
+      if (key in result) {
+        result[key] = mergeStructures(result[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+  return source;
+}
 class ColumnSelection {
   constructor(columns) {
     this._throwOnWrongAlias(columns);
@@ -975,53 +1419,156 @@ class ColumnSelection {
   static exampleCarsColumnSelection() {
     return new ColumnSelection([
       {
-        route: "carCake/carGeneralLayer/carGeneral/brand",
         key: "brand",
+        route: "carCake/carGeneralLayer/carGeneral/brand",
         alias: "brand",
-        titleShort: "Brand",
         titleLong: "Car Brand",
-        type: "string"
+        titleShort: "Brand",
+        type: "string",
+        _hash: ""
       },
       {
-        route: "carCake/carGeneralLayer/carGeneral/type",
         key: "type",
+        route: "carCake/carGeneralLayer/carGeneral/type",
         alias: "type",
-        titleShort: "Type",
         titleLong: "Car Type",
-        type: "string"
+        titleShort: "Type",
+        type: "string",
+        _hash: ""
+      },
+      {
+        key: "serviceIntervals",
+        route: "carCake/carGeneralLayer/carGeneral/serviceIntervals",
+        alias: "serviceIntervals",
+        titleLong: "Car Service Intervals",
+        titleShort: "Service Intervals",
+        type: "jsonValue",
+        _hash: ""
       },
       {
-        route: "carCake/carGeneralLayer/carGeneral/isElectric",
         key: "isElectric",
+        route: "carCake/carGeneralLayer/carGeneral/isElectric",
         alias: "isElectric",
-        titleShort: "Is Electric",
-        titleLong: "This Car is Electric",
-        type: "boolean"
+        titleLong: "Is Electric Car",
+        titleShort: "Electric",
+        type: "boolean",
+        _hash: ""
+      },
+      {
+        key: "carDimensions/height",
+        route: "carCake/carTechnicalLayer/carTechnical/carDimensions/height",
+        alias: "height",
+        titleLong: "Car Height",
+        titleShort: "Height",
+        type: "number",
+        _hash: ""
+      },
+      {
+        key: "carDimensions/width",
+        route: "carCake/carTechnicalLayer/carTechnical/carDimensions/width",
+        alias: "width",
+        titleLong: "Car Width",
+        titleShort: "Width",
+        type: "number",
+        _hash: ""
+      },
+      {
+        key: "carDimensions/length",
+        route: "carCake/carTechnicalLayer/carTechnical/carDimensions/length",
+        alias: "length",
+        titleLong: "Car Length",
+        titleShort: "Length",
+        type: "number",
+        _hash: ""
       },
       {
-        route: "carCake/carTechnicalLayer/carTechnical/transmission",
-        key: "transmission",
-        alias: "transmission",
-        titleShort: "Transmission",
-        titleLong: "Type of Transmission",
-        type: "string"
+        key: "engine",
+        route: "carCake/carTechnicalLayer/carTechnical/engine",
+        alias: "engine",
+        titleLong: "Car Engine",
+        titleShort: "Engine",
+        type: "string",
+        _hash: ""
       },
       {
-        route: "carCake/carColorLayer/carColor/sides",
-        key: "sides",
-        alias: "sides",
-        titleShort: "Sides",
-        titleLong: "Car Sides Color",
-        type: "string"
+        key: "repairedByWorkshop",
+        route: "carCake/carTechnicalLayer/carTechnical/repairedByWorkshop",
+        alias: "repairedByWorkshop",
+        titleLong: "Was Repaired By Workshop",
+        titleShort: "Repaired By Workshop",
+        type: "boolean",
+        _hash: ""
       }
     ]);
   }
-  // ...........................................................................
-  static empty() {
-    return new ColumnSelection([]);
+  static exampleCarsDeeplyNestedColumnSelection() {
+    return new ColumnSelection([
+      {
+        key: "brand",
+        route: "catalogCake/catalogSeriesLayer/catalogSeries/seriesCake/seriesCarsLayer/seriesCars/carCake/carGeneralLayer/carGeneral/brand",
+        alias: "brand",
+        titleLong: "Car Brand",
+        titleShort: "Brand",
+        type: "string",
+        _hash: ""
+      }
+    ]);
   }
-}
-const trueValues = ["t", "j", "y"];
+  static exampleCarsColumnSelectionOnlySomeColumns() {
+    return new ColumnSelection([
+      {
+        key: "brand",
+        route: "carCake/carGeneralLayer/carGeneral/brand",
+        alias: "brand",
+        titleLong: "Car Brand",
+        titleShort: "Brand",
+        type: "string",
+        _hash: ""
+      },
+      {
+        key: "type",
+        route: "carCake/carGeneralLayer/carGeneral/type",
+        alias: "type",
+        titleLong: "Car Type",
+        titleShort: "Type",
+        type: "string",
+        _hash: ""
+      },
+      {
+        key: "serviceIntervals",
+        route: "carCake/carGeneralLayer/carGeneral/serviceIntervals",
+        alias: "serviceIntervals",
+        titleLong: "Car Service Intervals",
+        titleShort: "Service Intervals",
+        type: "jsonValue",
+        _hash: ""
+      },
+      {
+        key: "isElectric",
+        route: "carCake/carGeneralLayer/carGeneral/isElectric",
+        alias: "isElectric",
+        titleLong: "Is Electric Car",
+        titleShort: "Electric",
+        type: "boolean",
+        _hash: ""
+      },
+      {
+        key: "carDimensions/length",
+        route: "carCake/carTechnicalLayer/carTechnical/carDimensions/length",
+        alias: "length",
+        titleLong: "Car Length",
+        titleShort: "Length",
+        type: "number",
+        _hash: ""
+      }
+    ]);
+  }
+  // ...........................................................................
+  static empty() {
+    return new ColumnSelection([]);
+  }
+}
+const trueValues = ["t", "j", "y"];
 const falseValues = ["n", "f"];
 const parseBooleanSearch = (search) => {
   if (typeof search == "undefined" || search == null) {
@@ -1492,9 +2039,11 @@ class RowFilterProcessor {
       return remainingIndices;
     }
     for (const i of remainingIndices) {
-      const cellValue = join.value(i, columnIndex);
-      if (filter.matches(cellValue)) {
-        result.push(i);
+      const cellValues = join.value(i, columnIndex);
+      for (const cellValue of cellValues) {
+        if (filter.matches(cellValue)) {
+          result.push(i);
+        }
       }
     }
     return result;
@@ -1532,9 +2081,11 @@ class RowFilterProcessor {
       if (applyTo[r]) {
         continue;
       }
-      const cellValue = join.value(r, columnIndex);
-      if (filter.matches(cellValue)) {
-        applyTo[r] = true;
+      const cellValues = join.value(r, columnIndex);
+      for (const cellValue of cellValues) {
+        if (filter.matches(cellValue)) {
+          applyTo[r] = true;
+        }
       }
     }
   }
@@ -1545,7 +2096,7 @@ class RowFilterProcessor {
       const route = item.route;
       if (availableRoutes.includes(route) === false) {
         throw new Error(
-          `RowFilterProcessor: Error while applying filter to view: There is a column filter for route "${route}", but the view does not have a column with this route.
+          `RowFilterProcessor: Error while applying filter to join: There is a column filter for route "${route}", but the join does not have a column with this route.
 
 Available routes:
 ${availableRoutes.map((a) => `- ${a}`).join("\n")}`
@@ -1554,13 +2105,22 @@ ${availableRoutes.map((a) => `- ${a}`).join("\n")}`
     }
   }
 }
+const joinPreserveKeys = [
+  "sliceIdsTable",
+  "sliceIdsRow",
+  /*'base',*/
+  "sliceIdsTable",
+  "sliceIdsTableRow",
+  "componentsTable"
+];
 class Join {
-  constructor(baseRows, _baseColumnSelection) {
-    this._baseColumnSelection = _baseColumnSelection;
-    this._base = this._hashedRows(baseRows);
-  }
   _base = {};
+  _baseColumnSelection;
   _processes = [];
+  constructor(rows, columnSelection) {
+    this._base = this._hashedRows(rows);
+    this._baseColumnSelection = columnSelection;
+  }
   // ...........................................................................
   /**
    * Applies a filter to the join and returns the filtered view
@@ -1589,14 +2149,62 @@ class Join {
     const data = {};
     for (const [sliceId, joinRowH] of Object.entries(this.data)) {
       const cols = [...joinRowH.columns];
+      const insertCols = [];
       for (const col of cols) {
-        if (Route.fromFlat(setValue.route).equalsWithoutRefs(col.route))
-          col.insert = setValue.value;
-        else continue;
+        const insertCol = {
+          ...col
+          //inserts: col.inserts ? [...col.inserts] : [],
+        };
+        if (Route.fromFlat(setValue.route).equalsWithoutRefs(col.route)) {
+          for (const cell of col.value.cell) {
+            if (cell.path.length === 0) {
+              throw new Error(
+                `Join: Error while applying SetValue: Cannot set value for column without paths. Route: ${setValue.route.toString()}.`
+              );
+            }
+            if (cell.path.length > 1) {
+              throw new Error(
+                `Join: Error while applying SetValue: Cannot set value for multiple paths in one cell. Found paths: [${cell.path.join(", ")}] for route: ${setValue.route.toString()}.`
+              );
+            }
+            const cellInsertTree = isolate(
+              { ...col.value.tree },
+              cell.path[0],
+              joinPreserveKeys
+            );
+            inject(cellInsertTree, cell.path[0], setValue.value);
+            const propertyKey = cell.path[0].slice(-1)[0];
+            const insert = {
+              cell: [
+                {
+                  ...cell,
+                  ...{ value: setValue.value },
+                  ...{
+                    row: {
+                      ...cell.row,
+                      ...{ [propertyKey]: setValue.value }
+                    }
+                  }
+                }
+              ],
+              tree: cellInsertTree,
+              rljson: col.value.rljson
+            };
+            if (insert) {
+              if (insertCol.inserts) insertCol.inserts.push(insert);
+              else insertCol.inserts = [insert];
+            }
+          }
+        }
+        insertCols.push(insertCol);
       }
       data[sliceId] = {
-        rowHash: Hash.default.calcHash(cols.map((c) => c.value)),
-        columns: cols
+        rowHash: Hash.default.calcHash(
+          insertCols.map(
+            (col) => col.value.cell.flatMap((c) => c.value)
+          )
+        ),
+        columns: insertCols
       };
     }
     const process = {
@@ -1639,15 +2247,15 @@ class Join {
     const data = {};
     for (let i2 = 0; i2 < this.rowCount; i2++) {
       const [sliceId, row] = Object.entries(this.data)[i2];
-      const selectedColumns = [];
+      const cols = [];
       for (let j = 0; j < masterColumnIndices.length; j++) {
-        selectedColumns.push(row.columns[masterColumnIndices[j]]);
+        cols.push(row.columns[masterColumnIndices[j]]);
       }
       data[sliceId] = {
         rowHash: Hash.default.calcHash(
-          selectedColumns.map((c) => c.value)
+          cols.map((col) => col.value.cell.flatMap((c) => c.value))
         ),
-        columns: selectedColumns
+        columns: cols
       };
     }
     const process = {
@@ -1686,16 +2294,51 @@ class Join {
    * Returns insert Object of the join
    */
   insert() {
-    const cakeInserts = this._insertCakeObject(this.data);
-    const mergedCakeInsertObj = merge(...cakeInserts);
-    const route = mergedCakeInsertObj[this.cakeRoute.root.tableKey].route.flat;
-    const value = mergedCakeInsertObj[this.cakeRoute.root.tableKey].value;
-    const insert = {
-      command: "add",
-      route,
-      value
-    };
-    return insert;
+    const inserts = [];
+    for (let i = 0; i < this.columnCount; i++) {
+      const colInserts = [];
+      for (const row of Object.values(this.data)) {
+        const col = row.columns[i];
+        if (col.inserts && col.inserts.length > 0) {
+          for (const insert of col.inserts) {
+            for (const cell of insert.cell) {
+              const tree = insert.tree;
+              const path = cell.path;
+              inject(tree, path[0].slice(0, -1), cell.row);
+              colInserts.push({
+                route: col.route,
+                tree,
+                path: path[0]
+              });
+            }
+          }
+        }
+      }
+      if (colInserts.length === 0) continue;
+      const routes = colInserts.map((ins) => ins.route.flat);
+      const uniqueRoute = Array.from(new Set(routes));
+      if (uniqueRoute.length > 1) {
+        throw new Error(
+          `Join: Error while generating insert: Multiple different routes found in inserts: ${uniqueRoute.map((r) => r.toString()).join(", ")}. Cannot generate single insert object.`
+        );
+      }
+      const merged = mergeTrees(
+        colInserts.map((ins) => ({
+          tree: ins.tree,
+          path: ins.path.slice(0, -1)
+        }))
+      );
+      traverse(merged, ({ parent, key, value }) => {
+        if (key == "_data" && Array.isArray(value) && value.length > 0) {
+          parent[key] = value.filter((v) => !!v);
+        }
+      });
+      inserts.push({
+        route: Route.fromFlat(uniqueRoute[0]).toRouteWithProperty(),
+        tree: merged
+      });
+    }
+    return inserts;
   }
   // ...........................................................................
   /**
@@ -1739,7 +2382,12 @@ class Join {
    */
   get layerRoutes() {
     return Array.from(
-      new Set(this.componentRoutes.map((r) => r.upper().flat))
+      new Set(
+        Object.values(this.columnSelection.columns).map((c) => [
+          Route.fromFlat(c.route).top,
+          Route.fromFlat(c.route).deeper(1).top
+        ]).map((segments) => new Route(segments).flat)
+      )
     ).map((r) => Route.fromFlat(r));
   }
   // ...........................................................................
@@ -1748,7 +2396,11 @@ class Join {
    */
   get cakeRoute() {
     const cakeRoute = Array.from(
-      new Set(this.layerRoutes.map((r) => r.upper().flat))
+      new Set(
+        Object.values(this.columnSelection.columns).map(
+          (c) => Route.fromFlat(c.route).top.tableKey
+        )
+      )
     ).map((r) => Route.fromFlat(r));
     if (cakeRoute.length !== 1) {
       throw new Error(
@@ -1833,7 +2485,11 @@ class Join {
           const dataColRoute = dataCol.route;
           return colInfoRoute.equalsWithoutRefs(dataColRoute);
         });
-        row.push(joinCol ? joinCol.insert ?? joinCol.value : null);
+        const insertValue = joinCol && joinCol.inserts ? joinCol.inserts.flatMap(
+          (con) => con.cell.flatMap((c) => c.value)
+        ) ?? null : null;
+        const baseValue = joinCol && joinCol.value.cell ? joinCol.value.cell.flatMap((c) => c.value) ?? null : null;
+        row.push(insertValue ?? baseValue);
       }
       result.push(row);
     }
@@ -1842,133 +2498,6 @@ class Join {
   static empty() {
     return new Join({}, ColumnSelection.empty());
   }
-  //#############################################################
-  // ############# Private Methods ##############################
-  //#############################################################
-  // ...........................................................................
-  /**
-   * Builds cake insert objects from the given join rows
-   * @param rows - The join rows
-   * @returns The cake insert objects
-   */
-  _insertCakeObject(rows) {
-    const cakeInsertObjects = [];
-    const cakeRoute = this.cakeRoute;
-    for (const [sliceId, row] of Object.entries(rows)) {
-      const layerInsertObjectList = this._insertLayerObjects(
-        sliceId,
-        row.columns
-      );
-      for (const layerInsertObject of layerInsertObjectList) {
-        const cakeInsertObject = {};
-        for (const [layerRoute, layerInsertObj] of Object.entries(
-          layerInsertObject
-        )) {
-          cakeInsertObject[cakeRoute.root.tableKey] = {
-            route: layerInsertObj.route,
-            value: {
-              [layerRoute]: layerInsertObj.value
-            }
-          };
-        }
-        cakeInsertObjects.push(cakeInsertObject);
-      }
-    }
-    return cakeInsertObjects;
-  }
-  // ...........................................................................
-  /**
-   * Wraps component insert objects into layer insert objects
-   * @param sliceId - The slice id
-   * @param componentInsertObjects - The component insert objects
-   * @returns
-   */
-  _insertLayerObjects(sliceId, insertRow) {
-    const layerRoutes = this.layerRoutes;
-    const layerInsertObjects = [];
-    const insertComponentObjects = this._insertComponentObjects(
-      sliceId,
-      insertRow
-    );
-    for (const layerRoute of layerRoutes) {
-      for (const [compRouteFlat, compInsertObj] of Object.entries(
-        insertComponentObjects
-      )) {
-        const compRoute = Route.fromFlat(compRouteFlat);
-        if (layerRoute.includes(compRoute)) {
-          const layerInsertObj = {};
-          layerInsertObj[layerRoute.root.tableKey] = {
-            route: compInsertObj.route,
-            value: {
-              [sliceId]: compInsertObj.value
-            }
-          };
-          layerInsertObjects.push(layerInsertObj);
-        } else {
-          continue;
-        }
-      }
-    }
-    return layerInsertObjects;
-  }
-  // ...........................................................................
-  /**
-   * Merges columns into component insert objects
-   * @param insertColumns - The columns to merge
-   * @returns
-   */
-  _insertComponentObjects(sliceId, insertColumns) {
-    const componentRoutes = this.componentRoutes;
-    const columns = this._mergeInsertRow(sliceId, insertColumns);
-    const result = {};
-    for (const compRoute of componentRoutes) {
-      let compChanged = false;
-      const compInsert = {};
-      for (const c of columns) {
-        if (compRoute.includes(c.route)) {
-          if (c.insert !== null) {
-            compChanged = true;
-            compInsert[c.route.propertyKey] = c.insert;
-          } else {
-            compInsert[c.route.propertyKey] = c.value;
-          }
-        } else {
-          continue;
-        }
-      }
-      result[compRoute.flat] = {
-        route: compRoute,
-        value: compChanged ? compInsert : null
-      };
-    }
-    return result;
-  }
-  // ...........................................................................
-  /**
-   * Merges the insert values into the base row
-   * @param sliceId - The slice id
-   * @param insertRow - The insert row
-   * @returns The merged join row
-   */
-  _mergeInsertRow(sliceId, insertRow) {
-    const baseColumns = this._base[sliceId].columns;
-    const mergedRow = [];
-    for (const baseCol of baseColumns) {
-      const insertCol = insertRow.find(
-        (col) => col.route.equalsWithoutRefs(baseCol.route)
-      );
-      if (insertCol) {
-        mergedRow.push({
-          route: baseCol.route,
-          value: baseCol.value,
-          insert: insertCol.insert
-        });
-      } else {
-        mergedRow.push(baseCol);
-      }
-    }
-    return mergedRow;
-  }
   // ...........................................................................
   /**
    * Hashes the given join rows. If insert value is present, it is used for hashing.
@@ -1980,13 +2509,15 @@ class Join {
     const sliceIds = Object.keys(rows);
     const hashedRows = {};
     for (const sliceId of sliceIds) {
-      const columns = rows[sliceId];
+      const cols = rows[sliceId];
       const rowHash = Hash.default.calcHash(
-        columns.map((col) => col.insert ?? col.value)
+        cols.map(
+          (col) => col.inserts?.flatMap((con) => con.cell.flatMap((c) => c.value)) ?? col.value.cell ? col.value.cell.flatMap((c) => c.value) : []
+        )
       );
       hashedRows[sliceId] = {
         rowHash,
-        columns
+        columns: cols
       };
     }
     return hashedRows;
@@ -2056,6 +2587,25 @@ class Notify {
     return this._callbacks.get(route.flat) || [];
   }
 }
+const makeUniqueArrayByHash = (arr) => {
+  const seen = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const item of arr) {
+    if (!seen.has(item._hash)) {
+      seen.set(item._hash, item);
+      result.push(item);
+    }
+  }
+  return result;
+};
+const makeUnique = (rljson) => {
+  traverse(rljson, ({ parent, key, value }) => {
+    if (key == "_data" && Array.isArray(value)) {
+      parent[key] = makeUniqueArrayByHash(value);
+    }
+  });
+  return rljson;
+};
 class Db {
   /**
    * Constructor
@@ -2080,87 +2630,444 @@ class Db {
    * Get data from a route with optional filtering
    * @param route - The route to get data from
    * @param where - Optional filter to apply to the data
+   * @param filter - Optional filter to apply to child entries in related tables
+   * @param sliceIds - Optional slice IDs to filter the data
    * @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) {
+  async get(route, where, filter, sliceIds) {
     if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
     const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
-    const cacheHash = `${isolatedRoute.flat}|${JSON.stringify(where)}`;
+    const controllers = await this.indexedControllers(isolatedRoute);
+    const data = await this._get(
+      isolatedRoute,
+      where,
+      controllers,
+      filter,
+      sliceIds
+    );
+    const dataWithControllers = {
+      ...data,
+      ...{ controllers }
+    };
+    return dataWithControllers;
+  }
+  // ...........................................................................
+  /**
+   * Resolves the route and returns corresponding data for any segment of the route,
+   * matching recursive filters and where clauses
+   *
+   * @param route - The route to get data from
+   * @param where - The recursive filtering key/value pairs to apply to the data
+   * @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
+   * @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);
-    } else {
-      const controllers = await this._indexedControllers(isolatedRoute);
-      const data = await this._get(isolatedRoute, where, controllers);
-      this._cache.set(cacheHash, data);
-      return data;
-    }
-  }
-  async _get(route, where, controllers, segmentLevel) {
-    if (segmentLevel === void 0) segmentLevel = 0;
-    const segment = route.segments[segmentLevel];
-    const segmentIsDeepest = segmentLevel === route.segments.length - 1;
-    const segmentController = controllers[segment.tableKey];
-    const segmentRef = await this._getReferenceOfRouteSegment(segment);
-    let segmentWhere = typeof where === "object" ? where : { _hash: where };
-    segmentWhere = segment.tableKey in segmentWhere ? segmentWhere[segment.tableKey] : segmentWhere;
-    segmentWhere = segmentRef ? { ...segmentWhere, ...{ _hash: segmentRef } } : segmentWhere;
-    const childSegmentLevel = segmentLevel + 1;
-    const childSegment = route.segments[childSegmentLevel];
-    const segmentWhereWithoutChildWhere = { ...segmentWhere };
-    if (!segmentIsDeepest && childSegment.tableKey in segmentWhere)
-      delete segmentWhereWithoutChildWhere[childSegment.tableKey];
-    let parent = await segmentController.get(segmentWhereWithoutChildWhere, {});
-    if (segmentIsDeepest && route.hasPropertyKey) {
-      parent = this.isolatePropertyFromComponents(parent, route.propertyKey);
-    }
-    const children = [];
-    const filteredParentRows = /* @__PURE__ */ new Map();
-    if (!segmentIsDeepest) {
-      const childRefs = await segmentController.getChildRefs(
-        segmentWhereWithoutChildWhere,
-        {}
+    }
+    const nodeTableKey = route.top.tableKey;
+    const nodeRoute = route;
+    const nodeRouteRef = await this._getReferenceOfRouteSegment(nodeRoute.top);
+    const nodeController = controllers[nodeTableKey];
+    const nodeSliceIds = nodeRoute.top.sliceIds ?? sliceIds;
+    let nodeWhere = typeof where === "object" ? { ...where } : where;
+    if (!route.isRoot && typeof nodeWhere === "object") {
+      delete nodeWhere[nodeRoute.deeper().top.tableKey];
+    }
+    nodeWhere = nodeWhere ? typeof nodeWhere === "string" ? { _hash: nodeWhere } : nodeWhere : {};
+    if (nodeRouteRef && nodeRouteRef.length > 0)
+      nodeWhere = { _hash: nodeRouteRef };
+    delete nodeWhere["_through"];
+    delete nodeWhere["_tableKey"];
+    const {
+      [nodeTableKey]: { _data: nodeRows, _type: nodeType, _hash: nodeHash }
+    } = await nodeController.get(nodeWhere);
+    const nodeColumnCfgs = nodeController.tableCfg().columns;
+    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;
+      }
+      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;
+          }
+        }
+      } else {
+        filterResult = true;
+      }
+      let sliceIdResult = false;
+      if (sliceIdActive) {
+        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;
+            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;
+            break;
+          case "components":
+            if (filterProperties.length > 0) {
+              const componentSliceIds = filterProperties.flatMap(
+                (f) => f.sliceIds
+              );
+              const componentMatchesSliceIds = nodeSliceIds.filter(
+                (sId) => componentSliceIds.includes(sId)
+              );
+              if (componentMatchesSliceIds.length > 0) {
+                sliceIdResult = true;
+              }
+            }
+            break;
+          /* v8 ignore next -- @preserve */
+          default:
+            sliceIdResult = true;
+            break;
+        }
+      } else {
+        sliceIdResult = true;
+      }
+      if (filterResult && sliceIdResult) nodeRowsFiltered.push(nodeRow);
+    }
+    const node = {
+      [nodeTableKey]: {
+        _data: nodeRowsFiltered,
+        _type: nodeType,
+        _hash: nodeHash
+      }
+    };
+    const nodeValue = node[nodeTableKey]._data.filter(
+      (v) => v !== void 0 && v !== null
+    );
+    if (route.isRoot) {
+      if (route.hasPropertyKey) {
+        const isolatedNode = this.isolatePropertyFromComponents(
+          node,
+          route.propertyKey
+        );
+        const result3 = {
+          rljson: isolatedNode,
+          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}` : "") + `/${route.propertyKey}`
+              ).toRouteWithProperty(),
+              path: [[nodeTableKey, "_data", idx, route.propertyKey]]
+            })
+          )
+        };
+        this._cache.set(cacheHash, result3);
+        return result3;
+      }
+      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]]
+          })
+        )
+      };
+      this._cache.set(cacheHash, result2);
+      return result2;
+    }
+    const childrenRoute = route.deeper();
+    const childrenTableKey = childrenRoute.top.tableKey;
+    const childrenWhere = typeof where === "object" ? where[childrenTableKey] ?? {} : {};
+    const childrenThroughProperty = childrenWhere?._through;
+    const nodeChildrenArray = [];
+    const nodeRowsMatchingChildrenRefs = /* @__PURE__ */ new Map();
+    for (let i = 0; i < nodeRowsFiltered.length; i++) {
+      const nodeRow = nodeRowsFiltered[i];
+      const nodeRowObj = { ...{}, ...nodeRow };
+      const childrenRefs = await nodeController.getChildRefs(
+        nodeRow._hash
       );
-      for (const { tableKey, columnKey, ref } of childRefs) {
-        if (tableKey !== childSegment.tableKey) continue;
-        const child = await this._get(
-          route,
-          { ...segmentWhere, ...{ _hash: ref } },
-          controllers,
-          childSegmentLevel
+      const childrenRefTypes = /* @__PURE__ */ new Map();
+      const childrenRefSliceIds = /* @__PURE__ */ new Set();
+      for (const cr of childrenRefs) {
+        if (!!cr.columnKey) {
+          const childrenRefColumnCfg = nodeColumnCfgs.find(
+            (c) => c.key === cr.columnKey
+          );
+          if (childrenRefColumnCfg) {
+            childrenRefTypes.set(
+              childrenRefColumnCfg.key,
+              childrenRefColumnCfg.ref?.type ?? ""
+            );
+          }
+          if (cr.sliceIds && cr.sliceIds.length > 0) {
+            for (const sId of cr.sliceIds) {
+              childrenRefSliceIds.add(sId);
+            }
+          }
+        }
+      }
+      if (childrenRefTypes.size > 1) {
+        throw new Error(
+          `Db._get: Multiple reference types found for children of table ${nodeTableKey}.`
         );
-        children.push(child);
-        for (const childObjs of child[tableKey]._data) {
-          const childRef = childObjs["_hash"];
-          for (const row of parent[segment.tableKey]._data) {
-            if (filteredParentRows.has(row["_hash"]))
-              continue;
-            const includesChild = segmentController.filterRow(
-              row,
-              columnKey ?? tableKey,
-              childRef
+      }
+      const cakeIsReferenced = childrenRefTypes.size === 1 && [...childrenRefTypes.values()][0] === "cakes";
+      const componentIsReferenced = childrenRefTypes.size === 1 && nodeType === "components" && [...childrenRefTypes.values()][0] === "components";
+      const childrenSliceIds = cakeIsReferenced ? [...childrenRefSliceIds] : componentIsReferenced ? void 0 : nodeSliceIds;
+      const {
+        rljson: rowChildrenRljson,
+        tree: rowChildrenTree,
+        cell: rowChildrenCell
+      } = await this._get(
+        childrenRoute,
+        childrenWhere,
+        controllers,
+        childrenRefs,
+        childrenSliceIds,
+        Route.fromFlat(
+          (routeAccumulator ? routeAccumulator.flat : nodeTableKey) + (nodeHash ? `@${nodeHash}` : "") + "/" + childrenTableKey
+        )
+      );
+      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);
+        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 resolvedChildren = rowChildrenRljson[childrenTableKey]._data;
+      const childrenRefsOfRow = childrenRefs.filter(
+        (cr) => cr.tableKey == childrenTableKey
+      );
+      const matchingChildrenRefs = childrenRefsOfRow.filter(
+        (cr) => !!resolvedChildren.find((ch) => cr.ref === ch._hash)
+      );
+      if (nodeType === "layers") {
+        const compChildrenTrees = rowChildrenTree[childrenTableKey]._data;
+        const compChildrenPaths = rowChildrenCell.map((c) => c.path);
+        const components = compChildrenTrees.map((c, idx) => {
+          return {
+            tree: c,
+            path: compChildrenPaths.filter((p) => p[0][2] == idx)
+          };
+        });
+        const layerTreesAndPaths = components.map(({ tree: comp, path }) => {
+          const sliceIds2 = matchingChildrenRefs.find(
+            (cr) => cr.ref === comp._hash
+          )?.sliceIds;
+          if (!sliceIds2 || sliceIds2.length === 0) {
+            throw new Error(
+              `Db._get: No sliceIds found for component ${comp._hash} of layer ${nodeRow._hash}.`
             );
-            if (includesChild) {
-              filteredParentRows.set(
-                row["_hash"],
-                row
-              );
+          }
+          if (sliceIds2.length > 1) {
+            throw new Error(
+              `Db._get: Multiple sliceIds found for component ${comp._hash} of layer ${nodeRow._hash}.`
+            );
+          }
+          const sliceId = sliceIds2[0];
+          const pathsForSliceId = [
+            ...path.map((p) => p[0]).map((p) => {
+              const newPath = [...p];
+              newPath[2] = 0;
+              return ["add", sliceId, ...newPath];
+            })
+          ];
+          return {
+            [sliceId]: {
+              tree: {
+                [childrenTableKey]: {
+                  ...{ _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
+        );
+        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          rljson: nodeRow,
+          tree: {
+            ...nodeRowObj,
+            add: { ...nodeRowObj.add, ...layer }
+          },
+          cell: rowChildrenCell.map(
+            (c, idx) => ({
+              ...c,
+              ...{
+                path: [paths.flat()[idx]]
+              }
+            })
+          )
+        });
+      } else if (nodeType === "cakes") {
+        nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+          rljson: nodeRow,
+          tree: {
+            ...nodeRowObj,
+            layers: { ...nodeRowObj.layers, ...rowChildrenTree }
+          },
+          cell: rowChildrenCell.map((c) => ({
+            ...c,
+            ...{
+              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 = {};
+          for (const [colKey, childTableKey] of columnReferenceMap) {
+            const tree = {
+              ...rowChildrenTree[childTableKey],
+              ...{ _tableKey: childTableKey }
+            };
+            const cell = rowChildrenCell.map((c) => ({
+              ...c,
+              ...{
+                path: c.path.filter((p) => p[0] === childTableKey).map((p) => [colKey, ...p.slice(1)])
+              }
+            }));
+            resolvedRefs[colKey] = { tree, cell };
           }
+          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, {
+            rljson: nodeRow,
+            tree: resolvedTree,
+            cell: resolvedCell
+          });
+        } else {
+          nodeRowsMatchingChildrenRefs.set(nodeRow._hash, {
+            rljson: nodeRow,
+            tree: { ...nodeRowObj },
+            cell: rowChildrenCell
+          });
         }
+      } else {
+        throw new Error(
+          `Db._get: Unsupported node type ${nodeType} for getting children.`
+        );
       }
-      const parentWithFilteredRows = {
-        [segment.tableKey]: {
-          ...parent[segment.tableKey],
+    }
+    const nodeChildren = 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
+      },
+      tree: {
+        [nodeTableKey]: {
+          ...{
+            _data: matchedNodeRows.map((mr) => mr.tree),
+            _type: nodeType
+          },
           ...{
-            _data: Array.from(filteredParentRows.values())
+            ...nodeHash ? { _hash: nodeHash } : {}
           }
         }
-      };
-      return merge(parentWithFilteredRows, ...children);
-    }
-    return parent;
+      },
+      cell: matchedNodeRows.map(
+        (mr, idx) => mr.cell.map((c) => ({
+          ...c,
+          ...{ path: c.path.map((p) => [nodeTableKey, "_data", idx, ...p]) }
+        }))
+      ).flat()
+    };
+    this._cache.set(cacheHash, result);
+    return result;
   }
   // ...........................................................................
   /**
@@ -2187,115 +3094,66 @@ class Db {
    * @param rljson - The Rljson to join data for
    */
   async join(columnSelection, cakeKey, cakeRef) {
-    const data = await this._getBaseDataForColumnSelection(columnSelection);
-    const cakesTable = data[cakeKey];
-    const cake = cakesTable._data.find((c) => c._hash === cakeRef);
-    if (!cake) {
+    const {
+      tree: { [cakeKey]: cakesTable }
+    } = await this.get(Route.fromFlat(`${cakeKey}@${cakeRef}`), {});
+    const cakes = cakesTable._data;
+    if (cakes.length === 0) {
       throw new Error(
         `Db.join: Cake with ref "${cakeRef}" not found in cake table "${cakeKey}".`
       );
     }
-    const layers = /* @__PURE__ */ new Map();
-    for (const layerKey of Object.keys(cake.layers)) {
-      if (!data[layerKey]) continue;
-      const layersTable = data[layerKey];
-      const layer = layersTable._data.find(
-        (l) => l._hash === cake.layers[layerKey]
+    if (cakes.length > 1) {
+      throw new Error(
+        `Db.join: Multiple cakes with ref "${cakeRef}" found in cake table "${cakeKey}".`
       );
-      layers.set(layerKey, layer);
-    }
-    const mergedSliceIds = /* @__PURE__ */ new Set();
-    for (const layer of layers.values()) {
-      const sliceIdsTable = layer.sliceIdsTable;
-      const sliceIdsTableRow = layer.sliceIdsTableRow;
-      const {
-        [sliceIdsTable]: { _data: sliceIds }
-      } = await this.core.readRows(sliceIdsTable, { _hash: sliceIdsTableRow });
-      for (const sid of sliceIds) {
-        for (const s of sid.add) {
-          mergedSliceIds.add(s);
-        }
-      }
     }
-    const columnCfgs = /* @__PURE__ */ new Map();
-    const columnInfos = /* @__PURE__ */ new Map();
-    for (const [layerKey, layer] of layers.entries()) {
-      const componentKey = layer.componentsTable;
-      const { columns: colCfgs } = await this.core.tableCfg(componentKey);
-      const columnCfg = [];
-      const columnInfo = [];
-      for (let i = 0; i < colCfgs.length; i++) {
-        if (colCfgs[i].key === "_hash") continue;
-        const colCfg = colCfgs[i];
-        columnCfg.push(colCfg);
-        columnInfo.push({
-          ...colCfg,
-          alias: `${colCfg.key}`,
-          route: Route.fromFlat(
-            `/${cakeKey}/${layerKey}/${componentKey}/${colCfg.key}`
-          ).flat.slice(1),
-          titleShort: colCfg.key,
-          titleLong: colCfg.key
-        });
-      }
-      columnInfos.set(componentKey, columnInfo);
-      columnCfgs.set(componentKey, columnCfg);
-    }
-    const rowMap = /* @__PURE__ */ new Map();
-    for (const sliceId of mergedSliceIds) {
-      let sliceIdRow = [];
-      for (const [layerKey, layer] of layers.entries()) {
-        const layerRef = layer._hash;
-        const componentKey = layer.componentsTable;
-        const componentRef = layer.add[sliceId];
-        const componentsTable = data[componentKey];
-        const component = componentsTable._data.find(
-          (r) => r._hash === componentRef
+    const cake = cakes[0];
+    const sliceIds = await this._resolveSliceIds(
+      cake.sliceIdsTable,
+      cake.sliceIdsRow
+    );
+    const rows = {};
+    for (const sliceId of sliceIds) {
+      const row = [];
+      for (const columnInfo of columnSelection.columns) {
+        const columnRoute = Route.fromFlat(
+          columnInfo.route
+        ).toRouteWithProperty();
+        const columnContainer = await this.get(
+          columnRoute,
+          cakeRef,
+          void 0,
+          [sliceId]
         );
-        const colCfgs = columnCfgs.get(componentKey);
-        const joinColumns = [];
-        for (let i = 0; i < colCfgs.length; i++) {
-          const columnCfg = colCfgs[i];
-          joinColumns.push({
-            route: Route.fromFlat(
-              `${cakeKey}@${cakeRef}/${layerKey}@${layerRef}/${componentKey}@${componentRef}/${columnCfg.key}`
-            ).toRouteWithProperty(),
-            value: component[columnCfg.key] ?? null,
-            insert: null
-          });
-        }
-        sliceIdRow = [...sliceIdRow, ...joinColumns];
+        const column = {
+          route: columnRoute,
+          value: columnContainer,
+          inserts: null
+        };
+        row.push(column);
       }
-      rowMap.set(sliceId, sliceIdRow);
+      rows[sliceId] = row;
     }
-    const joinRows = {};
-    for (const [sliceId, joinColumns] of rowMap.entries()) {
-      Object.assign(joinRows, {
-        [sliceId]: joinColumns
-      });
-    }
-    const joinColumnInfos = Array.from(columnInfos.values()).flat();
-    const joinColumnSelection = new ColumnSelection(joinColumnInfos);
-    return new Join(joinRows, joinColumnSelection).select(columnSelection);
+    return new Join(rows, columnSelection);
   }
   // ...........................................................................
-  /**
-   * Fetches data for the given ColumnSelection
-   * @param columnSelection - The ColumnSelection to fetch data for
-   */
-  async _getBaseDataForColumnSelection(columnSelection) {
-    const uniqueComponentRoutes = /* @__PURE__ */ new Set();
-    for (const colInfo of columnSelection.columns) {
-      const route = Route.fromFlat(colInfo.route).toRouteWithProperty();
-      uniqueComponentRoutes.add(route.toRouteWithoutProperty().flat);
-    }
-    const data = {};
-    for (const compRouteFlat of uniqueComponentRoutes) {
-      const uniqueComponentRoute = Route.fromFlat(compRouteFlat);
-      const componentData = await this.get(uniqueComponentRoute, {});
-      Object.assign(data, componentData);
+  async _resolveSliceIds(sliceIdTable, sliceIdRow) {
+    const sliceIdController = new SliceIdController(this.core, sliceIdTable);
+    sliceIdController.init();
+    const resolvedSliceIds = /* @__PURE__ */ new Set();
+    const {
+      [sliceIdTable]: { _data: sliceIds }
+    } = await sliceIdController.get(sliceIdRow);
+    for (const sliceId of sliceIds) {
+      const baseSliceIds = await sliceIdController.resolveBaseSliceIds(
+        sliceId
+      );
+      for (const sId of baseSliceIds.add) {
+        resolvedSliceIds.add(sId);
+      }
     }
-    return data;
+    return Array.from(resolvedSliceIds);
   }
   // ...........................................................................
   /**
@@ -2304,17 +3162,15 @@ class Db {
    * @returns The result of the Insert as an InsertHistoryRow
    * @throws {Error} If the Insert is not valid or if any controller cannot be created
    */
-  async insert(insert, options) {
-    const initialRoute = Route.fromFlat(insert.route);
-    const runs = await this._resolveInsert(insert);
-    const errors = validateInsert(insert);
-    if (!!errors.hasErrors) {
-      throw new Error(
-        `Db.insert: Insert is not valid:
-${JSON.stringify(errors, null, 2)}`
-      );
+  async insert(route, tree, options) {
+    const controllers = await this.indexedControllers(
+      Route.fromFlat(route.flatWithoutRefs)
+    );
+    const runFns = {};
+    for (const [tableKey, controller] of Object.entries(controllers)) {
+      runFns[tableKey] = controller.insert.bind(controller);
     }
-    return this._insert(insert, initialRoute, runs, options);
+    return this._insert(route, tree, runFns, options);
   }
   // ...........................................................................
   /**
@@ -2325,62 +3181,192 @@ ${JSON.stringify(errors, null, 2)}`
    * @returns The result of the Insert
    * @throws {Error} If the route is not valid or if any controller cannot be created
    */
-  async _insert(insert, route, runFns, options) {
-    let result;
-    let tableKey;
-    const segment = route.segment(0);
-    tableKey = segment.tableKey;
-    let previous = [];
-    if (Route.segmentHasRef(segment)) {
-      const routeRef = Route.segmentRef(segment);
-      if (Route.segmentHasInsertHistoryRef(segment)) {
-        previous = [...previous, routeRef];
-      }
-      if (Route.segmentHasDefaultRef(segment)) {
-        const timeIds = await this.getTimeIdsForRef(
-          tableKey,
-          Route.segmentRef(segment)
+  async _insert(route, tree, runFns, options) {
+    const results = [];
+    const nodeRoute = route;
+    const nodeSegment = nodeRoute.segment(0);
+    const nodeTableKey = nodeSegment.tableKey;
+    const nodeTree = tree[nodeTableKey];
+    const nodeType = nodeTree._type;
+    if (nodeTree._data.length === 0) {
+      throw new Error(
+        `Db._insert: No data found for table "${nodeTableKey}" in route "${route.flat}".`
+      );
+    }
+    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) {
+      const childRoute = nodeRoute.deeper(1);
+      const childTableKey = childRoute.top.tableKey;
+      if (nodeType === "cakes") {
+        const cakes = nodeTree._data;
+        if (cakes.length > 1) ;
+        const cake = cakes[0];
+        const childTree = cake.layers[childTableKey];
+        const childResults = await this._insert(
+          childRoute,
+          { [childTableKey]: childTree },
+          runFns
         );
-        previous = [...previous, ...timeIds];
-      }
-    }
-    if (!route.isRoot) {
-      const childRoute = route.deeper(1);
-      const childKeys = this._childKeys(insert.value);
-      const childRefs = {};
-      for (const k of childKeys) {
-        const childValue = insert.value[k];
-        const childInsert = { ...insert, value: childValue };
-        const childResult = await this._insert(childInsert, childRoute, runFns);
-        const childRefKey = childRoute.top.tableKey + "Ref";
-        const childRef = childResult[childRefKey];
-        childRefs[k] = childRef;
-      }
-      const runFn = runFns[tableKey];
-      result = {
-        ...await runFn(
-          insert.command,
-          {
-            ...insert.value,
-            ...childRefs
-          },
-          insert.origin
-        ),
-        previous
-      };
+        if (childResults.length > 1) {
+          throw new Error(
+            `Db._insert: Multiple inserts returned for child table "${childTableKey}" when inserting into cake table "${nodeTableKey}". Only single child inserts are supported.`
+          );
+        }
+        const childResult = childResults[0];
+        const insertValue = {
+          ...cake,
+          ...{
+            layers: {
+              ...cake.layers,
+              ...{
+                [childTableKey]: childResult[childTableKey + "Ref"]
+              }
+            }
+          }
+        };
+        const runFn = runFns[nodeTableKey];
+        const result = await runFn("add", rmhsh(insertValue), "db.insert");
+        results.push(
+          ...result.map((r) => ({
+            ...r,
+            ...{ previous },
+            ...{ route: route.flat }
+          }))
+        );
+      }
+      if (nodeType === "layers") {
+        const layers = nodeTree._data;
+        for (const layer of layers) {
+          const layerInsert = {};
+          for (const [sliceId, componentTree] of Object.entries(layer.add)) {
+            if (sliceId === "_hash") continue;
+            const writtenComponents = await this._insert(
+              childRoute,
+              componentTree,
+              runFns
+            );
+            if (writtenComponents.length > 1) {
+              throw new Error(
+                `Db._insert: Multiple components written for layer "${layer._hash}" and sliceId "${sliceId}" is currently not supported.`
+              );
+            }
+            const writtenComponent = writtenComponents[0];
+            if (!writtenComponent || !writtenComponent[childTableKey + "Ref"]) {
+              throw new Error(
+                `Db._insert: No component reference returned for layer "${layer._hash}" and sliceId "${sliceId}".`
+              );
+            }
+            layerInsert[sliceId] = writtenComponent[childTableKey + "Ref"];
+          }
+          const runFn = runFns[nodeTableKey];
+          const result = await runFn(
+            "add",
+            rmhsh({
+              ...layer,
+              ...{ add: layerInsert }
+            }),
+            "db.insert"
+          );
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (["components", "edits", "multiEdits"].includes(
+        nodeType
+      )) {
+        const runFn = runFns[nodeTableKey];
+        const components = nodeTree._data;
+        for (const component of components) {
+          const resolvedComponent = { ...component };
+          for (const [property, value] of Object.entries(component)) {
+            if (value.hasOwnProperty("_tableKey") && value._tableKey === childTableKey) {
+              const writtenReferences = await this._insert(
+                childRoute,
+                { [childTableKey]: value },
+                runFns
+              );
+              resolvedComponent[property] = writtenReferences.map(
+                (wr) => wr[childTableKey + "Ref"]
+              );
+            }
+          }
+          const result = await runFn(
+            "add",
+            rmhsh(resolvedComponent),
+            "db.insert"
+          );
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
     } else {
-      tableKey = route.root.tableKey;
-      const runFn = runFns[tableKey];
-      result = {
-        ...await runFn(insert.command, insert.value, insert.origin),
-        previous
-      };
+      const runFn = runFns[nodeTableKey];
+      if (["components", "edits", "multiEdits"].includes(
+        nodeType
+      )) {
+        const components = rmhsh(
+          tree[nodeTableKey]
+        );
+        for (const component of components._data) {
+          if (!component) continue;
+          delete component._tableKey;
+          delete component._type;
+          const result = await runFn("add", component, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (nodeType === "layers") {
+        const layers = rmhsh(tree[nodeTableKey]);
+        for (const layer of layers._data) {
+          const result = await runFn("add", layer, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
+      if (nodeType === "cakes") {
+        const cakes = rmhsh(tree[nodeTableKey]);
+        for (const cake of cakes._data) {
+          const result = await runFn("add", cake, "db.insert");
+          results.push(
+            ...result.map((r) => ({
+              ...r,
+              ...{ previous },
+              ...{ route: route.flat }
+            }))
+          );
+        }
+      }
     }
-    result.route = insert.route;
-    await this._writeInsertHistory(tableKey, result);
-    if (!options?.skipNotification)
-      this.notify.notify(Route.fromFlat(insert.route), result);
-    return result;
+    for (const result of results) {
+      if (!options?.skipHistory)
+        await this._writeInsertHistory(nodeTableKey, result);
+      if (!options?.skipNotification)
+        this.notify.notify(Route.fromFlat(result.route), result);
+    }
+    return results;
   }
   // ...........................................................................
   /**
@@ -2401,40 +3387,6 @@ ${JSON.stringify(errors, null, 2)}`
     this.notify.unregister(route, callback);
   }
   // ...........................................................................
-  /**
-   * Resolves an Insert by returning the run functions of all controllers involved in the Insert's route
-   * @param Insert - The Insert to resolve
-   * @returns A record of controller run functions, keyed by table name
-   * @throws {Error} If the route is not valid or if any controller cannot be created
-   */
-  async _resolveInsert(Insert2) {
-    const controllers = await this._indexedControllers(
-      Route.fromFlat(Insert2.route)
-    );
-    const runFns = {};
-    for (const tableKey of Object.keys(controllers)) {
-      runFns[tableKey] = controllers[tableKey].insert.bind(
-        controllers[tableKey]
-      );
-    }
-    return runFns;
-  }
-  // ...........................................................................
-  /**
-   * Returns the keys of child refs in a value based on a route
-   * @param value - The value to check
-   * @returns An array of keys of child refs in the value
-   */
-  _childKeys(value) {
-    const keys = Object.keys(value);
-    const childKeys = [];
-    for (const k of keys) {
-      if (typeof value[k] !== "object") continue;
-      childKeys.push(k);
-    }
-    return childKeys;
-  }
-  // ...........................................................................
   /**
    * Get a controller for a specific table
    * @param tableKey - The key of the table to get the controller for
@@ -2451,7 +3403,7 @@ ${JSON.stringify(errors, null, 2)}`
     return createController(contentType, this.core, tableKey, refs);
   }
   // ...........................................................................
-  async _indexedControllers(route) {
+  async indexedControllers(route) {
     const controllers = {};
     const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
     for (let i = 0; i < isolatedRoute.segments.length; i++) {
@@ -2500,15 +3452,9 @@ ${JSON.stringify(errors, null, 2)}`
     if (options.sorted) {
       const dumpedTable = await this.core.dumpTable(insertHistoryTable);
       const tableData = dumpedTable[insertHistoryTable]._data;
-      tableData.sort((a, b) => {
-        const aTime = a.timeId.split(":")[1];
-        const bTime = b.timeId.split(":")[1];
-        if (options.ascending) {
-          return aTime.localeCompare(bTime);
-        } else {
-          return bTime.localeCompare(aTime);
-        }
-      });
+      tableData.sort(
+        (a, b) => options.ascending ? a.timeId.localeCompare(b.timeId) : b.timeId.localeCompare(a.timeId)
+      );
       return {
         [insertHistoryTable]: { _data: tableData, _type: "insertHistory" }
       };
@@ -2591,15 +3537,20 @@ ${JSON.stringify(errors, null, 2)}`
    * @returns A route with extracted property key
    */
   async isolatePropertyKeyFromRoute(route) {
-    const lastSegment = route.segments[route.segments.length - 1];
-    const tableKey = lastSegment.tableKey;
-    const tableExists = await this._io.tableExists(tableKey);
-    if (!Route.segmentHasRef(lastSegment) && !tableExists) {
-      const result = route.upper();
-      result.propertyKey = lastSegment.tableKey;
-      return result;
-    }
-    return route;
+    const segmentLength = route.segments.length;
+    let propertyKey = "";
+    let result = route;
+    for (let i = segmentLength; i > 0; i--) {
+      const segment = route.segments[i - 1];
+      const tableKey = segment.tableKey;
+      const tableExists = await this._io.tableExists(tableKey);
+      if (!tableExists) {
+        propertyKey = propertyKey.length > 0 ? segment.tableKey + "/" + propertyKey : segment.tableKey;
+        result = result.upper();
+        result.propertyKey = propertyKey;
+      }
+    }
+    return result;
   }
   // ...........................................................................
   /**