@rljson/db 0.0.5 → 0.0.7

package/dist/db.js

@@ -1,8 +1,9 @@
+import { equals, merge } from "@rljson/json";
+import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, validateInsert, isTimeId } from "@rljson/rljson";
+import { traverse } from "object-traversal";
+import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
 import { IoMem } from "@rljson/io";
-import { timeId, createEditProtocolTableCfg, Validate, BaseValidator, Route, validateEdit, isTimeId } from "@rljson/rljson";
-import { rmhsh, hsh } from "@rljson/hash";
-import { equals } from "@rljson/json";
-// @license
+import { compileExpression } from "filtrex";
 class BaseController {
   constructor(_core, _tableKey) {
     this._core = _core;
@@ -27,6 +28,9 @@ class BaseController {
     if (typeof where === "string") {
       return this._getByHash(where, filter);
     } else if (typeof where === "object" && where !== null) {
+      if (Object.keys(where).length === 1 && "_hash" in where && typeof where["_hash"] === "string") {
+        return this._getByHash(where["_hash"], filter);
+      }
       return this._getByWhere(where, filter);
     } else {
       return Promise.resolve({});
@@ -64,7 +68,6 @@ class BaseController {
     return rows;
   }
 }
-// @license
 class CakeController extends BaseController {
   constructor(_core, _tableKey, _refs) {
     super(_core, _tableKey);
@@ -72,6 +75,7 @@ class CakeController extends BaseController {
     this._tableKey = _tableKey;
     this._refs = _refs;
   }
+  _table = null;
   _baseLayers = {};
   async init() {
     if (this._tableKey.endsWith("Cake") === false) {
@@ -80,11 +84,11 @@ class CakeController extends BaseController {
       );
     }
     const rljson = await this._core.dumpTable(this._tableKey);
-    const table = rljson[this._tableKey];
-    if (table._type !== "cakes") {
+    this._table = rljson[this._tableKey];
+    if (this._table._type !== "cakes") {
       throw new Error(`Table ${this._tableKey} is not of type cakes.`);
     }
-    if (this._refs && this._refs.base) {
+    if (this._refs && this._refs.base && this._refs.base.length > 0) {
       const {
         [this._tableKey]: { _data: baseCakes }
       } = await this._core.readRow(this._tableKey, this._refs.base);
@@ -93,26 +97,51 @@ class CakeController extends BaseController {
       }
       const baseCake = baseCakes[0];
       this._baseLayers = rmhsh(baseCake.layers);
-      if (!this._refs.sliceIdsTable || !this._refs.sliceIdsRow) {
-        this._refs = {
-          sliceIdsTable: baseCake.sliceIdsTable,
-          sliceIdsRow: baseCake.sliceIdsRow
-        };
-      }
     } else {
-      const cake = table._data[0];
+      const cake = this._table._data[0];
       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;
+    for (const cake of cakes) {
+      for (const layerTable of Object.keys(cake.layers)) {
+        if (layerTable.startsWith("_")) continue;
+        childRefs.push({
+          tableKey: layerTable,
+          ref: cake.layers[layerTable]
+        });
+      }
+    }
+    return childRefs;
   }
-  async run(command, value, origin, refs) {
+  async insert(command, value, origin, refs) {
     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
+    )) {
+      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 },
+      layers: { ...this._baseLayers, ...normalizedValue },
       ...refs || this._refs
     };
     const rlJson = { [this._tableKey]: { _data: [cake] } };
@@ -126,49 +155,27 @@ class CakeController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
       return this._getByHash(where, filter);
     } else if (typeof where === "object" && where !== null) {
-      const keys = Object.keys(where);
-      if (keys.length === 1 && keys[0].endsWith("Ref")) {
-        const tableKey = keys[0].replace("Ref", "");
-        return this._getByRef(tableKey, where[keys[0]], filter);
-      } else {
-        return this._getByWhere(where, filter);
-      }
+      return this._getByWhere(where, filter);
     } else {
       return Promise.resolve({});
     }
   }
-  async _getByRef(tableKey, ref, filter) {
-    let table = {};
-    if (!!filter && Object.keys(filter).length > 0) {
-      table = await this._core.readRows(
-        this._tableKey,
-        filter
-      );
-    } else {
-      table = await this._core.dumpTable(this._tableKey);
-    }
-    const cakes = [];
-    for (const row of table[this._tableKey]._data) {
-      const cake = row;
-      const layers = cake.layers;
-      for (const layerTable of Object.keys(layers)) {
-        if (layerTable === tableKey && layers[layerTable] === ref) {
-          cakes.push(cake);
-        }
+  filterRow(row, key, value) {
+    const cake = row;
+    for (const [layerKey, layerRef] of Object.entries(cake.layers)) {
+      if (layerKey === key && layerRef === value) {
+        return true;
       }
     }
-    return {
-      [this._tableKey]: { _data: cakes, _type: "cakes" }
-    };
+    return false;
   }
 }
-// @license
 class ComponentController extends BaseController {
   constructor(_core, _tableKey, _refs) {
     super(_core, _tableKey);
@@ -176,6 +183,9 @@ class ComponentController extends BaseController {
     this._tableKey = _tableKey;
     this._refs = _refs;
   }
+  _tableCfg = null;
+  _resolvedColumns = null;
+  _refTableKeyToColumnKeyMap = null;
   async init() {
     if (!!this._refs && !this._refs.base) {
       throw new Error(`Refs are not required on ComponentController.`);
@@ -185,8 +195,13 @@ class ComponentController extends BaseController {
     if (table._type !== "components") {
       throw new Error(`Table ${this._tableKey} is not of type components.`);
     }
+    this._tableCfg = await this._core.tableCfg(this._tableKey);
+    this._resolvedColumns = await this._resolveReferenceColumns({
+      base: this._tableCfg.columns
+    });
+    this._refTableKeyToColumnKeyMap = this._createRefTableKeyToColumnKeyMap();
   }
-  async run(command, value, origin, refs) {
+  async insert(command, value, origin, refs) {
     if (!command.startsWith("add")) {
       throw new Error(
         `Command ${command} is not supported by ComponentController.`
@@ -195,21 +210,329 @@ class ComponentController extends BaseController {
     if (!!refs) {
       throw new Error(`Refs are not supported on ComponentController.`);
     }
-    const component = value;
-    const rlJson = { [this._tableKey]: { _data: [component] } };
-    await this._core.import(rlJson);
+    const values = [];
+    const referencedValues = /* @__PURE__ */ new Map();
+    for (const [k, v] of Object.entries(value)) {
+      if (Array.isArray(v)) {
+        for (const possibleRef of v) {
+          if (typeof possibleRef === "object" && possibleRef.hasOwnProperty("_ref") && possibleRef.hasOwnProperty("_value")) {
+            const ref = possibleRef._ref;
+            const val = possibleRef._value;
+            if (!referencedValues.has(ref))
+              referencedValues.set(ref, { [k]: val });
+            else {
+              const existing = referencedValues.get(ref);
+              referencedValues.set(ref, { ...{ [k]: val }, ...existing });
+            }
+          }
+        }
+      }
+    }
+    if (referencedValues.size > 0) {
+      for (const refValue of referencedValues.values()) {
+        values.push({ ...value, ...refValue });
+      }
+    } else {
+      values.push(value);
+    }
+    const components = values;
+    const results = [];
+    for (const component of components) {
+      delete component._somethingToInsert;
+      const rlJson = { [this._tableKey]: { _data: [component] } };
+      await this._core.import(rlJson);
+      const result = {
+        //Ref to component
+        [this._tableKey + "Ref"]: hsh(component)._hash,
+        //Data from edit
+        route: "",
+        origin,
+        //Unique id/timestamp
+        timeId: timeId()
+      };
+      results.push(result);
+    }
+    return results;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves references to child entries in related tables based on a condition.
+   * @param where - The condition to filter the data.
+   * @param filter - Optional filter to apply to the data.
+   * @returns
+   */
+  async getChildRefs(where, filter) {
+    const { [this._tableKey]: table } = await this.get(where, filter);
+    const { columns } = await this._core.tableCfg(this._tableKey);
+    const childRefs = /* @__PURE__ */ new Map();
+    for (const colCfg of columns) {
+      if (!colCfg.ref || colCfg.ref === void 0) continue;
+      const propertyKey = colCfg.key;
+      const childRefTableKey = colCfg.ref.tableKey;
+      for (const row of table._data) {
+        const refValue = row[propertyKey];
+        if (typeof refValue === "string") {
+          childRefs.set(`${childRefTableKey}|${propertyKey}|${refValue}`, {
+            tableKey: childRefTableKey,
+            columnKey: propertyKey,
+            ref: refValue
+          });
+          continue;
+        }
+        if (Array.isArray(refValue)) {
+          for (const refItem of refValue) {
+            if (typeof refItem === "string") {
+              childRefs.set(`${childRefTableKey}|${propertyKey}|${refItem}`, {
+                tableKey: childRefTableKey,
+                columnKey: propertyKey,
+                ref: refItem
+              });
+            }
+          }
+          continue;
+        }
+      }
+    }
+    return Array.from(childRefs.values());
+  }
+  // ...........................................................................
+  /**
+   * Fetches a specific entry from the table by a partial match. Resolves references as needed.
+   * @param where - An object representing a partial match.
+   * @returns A promise that resolves to an array of entries matching the criteria, or null if no entries are found.
+   */
+  async _getByWhere(where, filter) {
+    const consolidatedWheres = [];
+    const consolidatedRows = /* @__PURE__ */ new Map();
+    const hasReferenceColumns = this._hasReferenceColumns(where);
+    if (hasReferenceColumns) {
+      const resolvedReferences = await this._resolveReferences(this._getWhereReferences(where));
+      const refWhereClauses = this._referencesToWhereClauses(resolvedReferences);
+      for (const refWhere of refWhereClauses) {
+        consolidatedWheres.push({
+          ...this._getWhereBase(where),
+          ...refWhere
+        });
+        const {
+          [this._tableKey]: { _data: tableData }
+        } = await this._core.dumpTable(this._tableKey);
+        const column = Object.keys(refWhere)[0];
+        const refValue = refWhere[column];
+        for (const row of tableData) {
+          if (this.filterRow(row, column, refValue)) {
+            consolidatedRows.set(row._hash, row);
+          }
+        }
+      }
+    } else {
+      const {
+        [this._tableKey]: { _data: rows }
+      } = await this._core.readRows(this._tableKey, {
+        ...where,
+        ...filter
+      });
+      for (const row of rows) {
+        consolidatedRows.set(row._hash, row);
+      }
+    }
     return {
-      //Ref to component
-      [this._tableKey + "Ref"]: hsh(component)._hash,
-      //Data from edit
-      route: "",
-      origin,
-      //Unique id/timestamp
-      timeId: timeId()
+      [this._tableKey]: {
+        _data: Array.from(consolidatedRows.values()),
+        _type: "components"
+      }
     };
   }
+  _referencesToWhereClauses(references) {
+    const whereClauses = [];
+    for (const [tableKey, refs] of Object.entries(references)) {
+      const wherePropertyKeys = this._refTableKeyToColumnKeyMap?.[tableKey];
+      for (const propKey of wherePropertyKeys) {
+        for (const ref of refs) {
+          whereClauses.push({ [propKey]: ref });
+        }
+      }
+    }
+    return whereClauses;
+  }
+  _createRefTableKeyToColumnKeyMap() {
+    const map = {};
+    const columns = this._tableCfg?.columns;
+    for (const colCfg of columns) {
+      if (colCfg.ref) {
+        const tableKey = colCfg.ref.tableKey;
+        if (!map[tableKey]) {
+          map[tableKey] = [];
+        }
+        map[tableKey].push(colCfg.key);
+      }
+    }
+    return map;
+  }
+  // ...........................................................................
+  /**
+   * Extracts reference columns from the where clause.
+   * @param where - The condition to filter the data.
+   * @returns An object representing only the reference columns in the where clause.
+   */
+  _getWhereReferences(where) {
+    const whereRefs = {};
+    for (const colCfg of this._referenceColumns) {
+      if (colCfg.key in where) {
+        whereRefs[colCfg.key] = where[colCfg.key];
+      }
+    }
+    return whereRefs;
+  }
+  // ...........................................................................
+  /**
+   * Removes reference columns from the where clause.
+   * @param where - The condition to filter the data.
+   * @returns An object representing the where clause without reference columns.
+   */
+  _getWhereBase(where) {
+    const whereWithoutRefs = { ...where };
+    for (const colCfg of this._referenceColumns) {
+      if (colCfg.key in whereWithoutRefs) {
+        delete whereWithoutRefs[colCfg.key];
+      }
+    }
+    return whereWithoutRefs;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves all reference columns from the resolved columns.
+   * @returns An array of ColumnCfg representing the reference columns.
+   */
+  get _referenceColumns() {
+    if (!this._resolvedColumns) {
+      throw new Error(
+        `Resolved columns are not available for table ${this._tableKey}. You must call init() first.`
+      );
+    }
+    const references = [];
+    for (const refCols of Object.values(this._resolvedColumns.references)) {
+      references.push(...refCols);
+    }
+    return references;
+  }
+  // ...........................................................................
+  /**
+   * Checks if the where clause contains any reference columns.
+   * @param where - The condition to filter the data.
+   * @returns A promise that resolves to true if reference columns are present, false otherwise.
+   */
+  _hasReferenceColumns(where) {
+    if (!this._resolvedColumns) {
+      throw new Error(
+        `Resolved columns are not available for table ${this._tableKey}. You must call init() first.`
+      );
+    }
+    for (const colCfg of this._referenceColumns) {
+      if (colCfg.key in where) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // ...........................................................................
+  /**
+   * Resolves reference columns in the where clause.
+   * @param columns - The columns to resolve.
+   * @returns A promise that resolves to an object containing base and reference columns.
+   */
+  async _resolveReferenceColumns(columns) {
+    const base = [];
+    const references = {};
+    for (const col of columns.base) {
+      if (!!col.ref) {
+        const refTableKey = col.ref.tableKey;
+        const { columns: refColumns } = await this._core.tableCfg(refTableKey);
+        if (!references[refTableKey]) {
+          references[refTableKey] = [];
+        }
+        const refsHaveRefs = refColumns.some((c) => !!c.ref);
+        if (refsHaveRefs) {
+          const resolvedRefColumns = await this._resolveReferenceColumns({
+            base: refColumns
+          });
+          references[refTableKey].push(...resolvedRefColumns.base);
+        }
+        references[refTableKey].push(...refColumns);
+      } else {
+        base.push(col);
+      }
+    }
+    return { base, references };
+  }
+  // ...........................................................................
+  /**
+   * Resolves references based on the where clause.
+   * @param where - The condition to filter the data.
+   * @returns - A promise that resolves to an object containing resolved references.
+   */
+  async _resolveReferences(where) {
+    if (!this._resolvedColumns) {
+      throw new Error(
+        `Resolved columns are not available for table ${this._tableKey}. You must call init() first.`
+      );
+    }
+    const resolvedReferences = {};
+    const references = this._resolvedColumns.references;
+    for (const [tableKey, refColumns] of Object.entries(references)) {
+      const whereForTable = {};
+      for (const colCfg of refColumns) {
+        if (colCfg.key in where) {
+          whereForTable[colCfg.key] = where[colCfg.key];
+        }
+      }
+      if (Object.keys(whereForTable).length === 0) {
+        continue;
+      }
+      const refRows = await this._readRowsWithReferences(
+        tableKey,
+        whereForTable
+      );
+      const refs = refRows[tableKey]._data.map(
+        (r) => r._hash
+      );
+      resolvedReferences[tableKey] = refs;
+    }
+    return resolvedReferences;
+  }
+  async _readRowsWithReferences(table, where) {
+    const splitted = [];
+    for (const [key, value] of Object.entries(where)) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          splitted.push({ ...where, ...{ [key]: v } });
+        }
+      }
+    }
+    if (splitted.length > 0) {
+      const results = [];
+      for (const s of splitted) {
+        results.push(await this._core.readRows(table, s));
+      }
+      return merge(...results);
+    } else {
+      return this._core.readRows(table, where);
+    }
+  }
+  filterRow(row, key, value) {
+    for (const [propertyKey, propertyValue] of Object.entries(row)) {
+      if (propertyKey === key && equals(propertyValue, value)) {
+        return true;
+      } else if (Array.isArray(propertyValue)) {
+        for (const item of propertyValue) {
+          if (equals(item, value)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
 }
-// @license
 class LayerController extends BaseController {
   constructor(_core, _tableKey, _refs) {
     super(_core, _tableKey);
@@ -236,10 +559,7 @@ class LayerController extends BaseController {
         throw new Error(`Base layer ${this._refs.base} does not exist.`);
       }
       const baseLayer = baseLayers[0];
-      if (
-        /* v8 ignore start */
-        !this._refs.sliceIdsTable || !this._refs.sliceIdsRow || !this._refs.componentsTable
-      ) {
+      if (!this._refs.sliceIdsTable || !this._refs.sliceIdsRow || !this._refs.componentsTable) {
         this._refs = {
           sliceIdsTable: baseLayer.sliceIdsTable,
           sliceIdsTableRow: baseLayer.sliceIdsTableRow,
@@ -255,18 +575,29 @@ class LayerController extends BaseController {
       };
     }
   }
-  async run(command, value, origin, refs) {
+  async insert(command, value, origin, refs) {
     if (!command.startsWith("add") && !command.startsWith("remove")) {
       throw new Error(
         `Command ${command} is not supported by LayerController.`
       );
     }
+    const normalizedValue = {};
+    for (const [sliceId, compRef] of Object.entries(
+      value
+    )) {
+      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 = command.startsWith("add") === true ? {
-      add: value,
+      add: normalizedValue,
       ...refs || this._refs
     } : {
       add: {},
-      remove: value,
+      remove: normalizedValue,
       ...refs || this._refs
     };
     const rlJson = { [this._tableKey]: { _data: [layer] } };
@@ -280,50 +611,41 @@ class LayerController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
       return this._getByHash(where, filter);
-    } else if (typeof where === "object" && where !== null) {
-      const keys = Object.keys(where);
-      if (keys.length === 1 && keys[0].endsWith("Ref")) {
-        const tableKey = keys[0].replace("Ref", "");
-        return this._getByRef(tableKey, where[keys[0]], filter);
-      } else {
-        return this._getByWhere(where, filter);
-      }
     } else {
-      return Promise.resolve({});
+      return this._getByWhere(where, filter);
     }
   }
-  async _getByRef(tableKey, ref, filter) {
-    let table = {};
-    if (!!filter && Object.keys(filter).length > 0) {
-      table = await this._core.readRows(this._tableKey, {
-        ...filter
-      });
-    } else {
-      table = await this._core.dumpTable(this._tableKey);
-    }
-    const layers = [];
-    for (const row of table[this._tableKey]._data) {
+  async getChildRefs(where, filter) {
+    const { [this._tableKey]: table } = await this.get(where, filter);
+    const childRefs = [];
+    for (const row of table._data) {
       const layer = row;
-      if (layer.componentsTable !== tableKey) {
-        continue;
+      for (const [sliceId, compRef] of Object.entries(layer.add)) {
+        if (sliceId.startsWith("_")) continue;
+        childRefs.push({
+          tableKey: layer.componentsTable,
+          ref: compRef
+        });
       }
-      for (const layerRef of Object.values(layer.add)) {
-        if (layerRef === ref) {
-          layers.push(layer);
-        }
+    }
+    return childRefs;
+  }
+  filterRow(row, _, value) {
+    const layer = row;
+    const compRef = value;
+    for (const componentRef of Object.values(layer.add)) {
+      if (componentRef === compRef) {
+        return true;
       }
     }
-    return {
-      [this._tableKey]: { _data: layers, _type: "layers" }
-    };
+    return false;
   }
 }
-// @license
 const createController = async (type, core, tableKey, refs) => {
   let ctrl;
   switch (type) {
@@ -342,7 +664,6 @@ const createController = async (type, core, tableKey, refs) => {
   await ctrl.init();
   return ctrl;
 };
-// @license
 class Core {
   // ...........................................................................
   constructor(_io) {
@@ -353,12 +674,12 @@ class Core {
   };
   // ...........................................................................
   /**
-   * Creates a table and an edit protocol for the table
+   * Creates a table and an insertHistory for the table
    * @param tableCfg TableCfg of table to create
    */
-  async createEditable(tableCfg) {
+  async createTableWithInsertHistory(tableCfg) {
     await this.createTable(tableCfg);
-    await this.createEditProtocol(tableCfg);
+    await this.createInsertHistory(tableCfg);
   }
   /**
    * Creates a table
@@ -368,11 +689,11 @@ class Core {
     return this._io.createOrExtendTable({ tableCfg });
   }
   /**
-   * Creates an edit protocol table for a given table
+   * Creates an insertHistory table for a given table
    * @param tableCfg TableCfg of table
    */
-  async createEditProtocol(tableCfg) {
-    const cfg = createEditProtocolTableCfg(tableCfg);
+  async createInsertHistory(tableCfg) {
+    const cfg = createInsertHistoryTableCfg(tableCfg);
     await this.createTable(cfg);
   }
   // ...........................................................................
@@ -422,6 +743,21 @@ class Core {
     return contentType;
   }
   // ...........................................................................
+  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
+      );
+    }
+    return tableCfg;
+  }
+  // ...........................................................................
   /** Reads a specific row from a database table */
   readRow(table, rowHash) {
     return this._io.readRows({ table, where: { _hash: rowHash } });
@@ -431,184 +767,1956 @@ class Core {
     return this._io.readRows({ table, where });
   }
 }
-// @license
-class Notify {
-  _callbacks = /* @__PURE__ */ new Map();
-  // ...........................................................................
-  constructor() {
+class ColumnSelection {
+  constructor(columns) {
+    this._throwOnWrongAlias(columns);
+    this.routes = columns.map((column) => column.route);
+    this.routeHashes = this.routes.map(ColumnSelection.calcHash);
+    this.aliases = columns.map((column) => column.alias);
+    this.columns = this._initColumns(columns);
+    ColumnSelection.check(this.aliases, this.routes);
   }
   // ...........................................................................
   /**
-   * Registers a callback for a specific route.
-   * @param route   The route to register the callback for.
-   * @param callback  The callback function to be invoked when a notification is sent.
+   * Returns unique routes from a list of routes
+   * @param routes - The list of routes
+   * @returns Unique routes
    */
-  register(route, callback) {
-    this._callbacks.set(route.flat, [
-      ...this._callbacks.get(route.flat) || [],
-      callback
-    ]);
+  static uniqueRoutes(routes) {
+    return Array.from(new Set(routes.map((r) => r.flat))).map(
+      (flat) => Route.fromFlat(flat)
+    );
   }
   // ...........................................................................
   /**
-   * Unregisters a callback for a specific route.
-   * @param route   The route to unregister the callback from.
-   * @param callback  The callback function to be removed.
+   * Returns a ColumnSelection from a list of route segments
+   * @param routeSegmentsList - A list of route segments
+   * @returns A ColumnSelection object
    */
-  unregister(route, callback) {
-    const callbacks = this._callbacks.get(route.flat);
-    if (callbacks) {
-      this._callbacks.set(
-        route.flat,
-        callbacks.filter((cb) => cb !== callback)
-      );
+  static fromRoutes(routes) {
+    const definition = [];
+    const aliasCountMap = {};
+    for (const route of this.uniqueRoutes(routes)) {
+      const alias = route.root.tableKey;
+      let uniqueAlias = alias;
+      const aliasCount = aliasCountMap[alias] ?? 0;
+      if (aliasCount > 0) {
+        uniqueAlias = `${alias}${aliasCount}`;
+      }
+      aliasCountMap[alias] = aliasCount + 1;
+      definition.push({
+        key: uniqueAlias,
+        type: "jsonValue",
+        alias: uniqueAlias,
+        route: route.flat.slice(1),
+        titleLong: "",
+        titleShort: ""
+      });
     }
+    return new ColumnSelection(definition);
   }
   // ...........................................................................
-  /**
-   * Notifies all registered callbacks for a specific route with the provided edit protocol row.
-   * @param route   The route to notify callbacks for.
-   * @param editProtocolRow  The edit protocol row to pass to the callbacks.
-   */
-  notify(route, editProtocolRow) {
-    const callbacks = this._callbacks.get(route.flat);
-    if (callbacks) {
-      for (const cb of callbacks) {
-        cb(editProtocolRow);
-      }
-    }
+  columns;
+  routes;
+  aliases;
+  routeHashes;
+  metadata(key) {
+    return this.columns.map((column) => column[key]);
   }
   // ...........................................................................
-  /**
-   * Returns the current map of registered callbacks.
-   * @returns A map where keys are route strings and values are arrays of callback functions.
-   */
-  get callbacks() {
-    return this._callbacks;
+  static merge(columnSelections) {
+    const routes = columnSelections.map((selection) => selection.routes).flat();
+    const routesWithoutDuplicates = Array.from(new Set(routes));
+    return ColumnSelection.fromRoutes(
+      routesWithoutDuplicates.map((route) => Route.fromFlat(route))
+    );
   }
   // ...........................................................................
-  /**
-   * Retrieves the list of callbacks registered for a specific route.
-   * @param route   The route to get callbacks for.
-   * @returns An array of callback functions registered for the specified route.
-   */
-  getCallBacksForRoute(route) {
-    return this._callbacks.get(route.flat) || [];
+  static calcHash(str) {
+    return Hash.default.calcHash(str);
   }
-}
-// @license
-class Db {
-  /**
-   * Constructor
-   * @param _io - The Io instance used to read and write data
-   */
-  constructor(_io) {
-    this._io = _io;
-    this.core = new Core(this._io);
-    this.notify = new Notify();
+  route(aliasRouteOrHash) {
+    return this.column(aliasRouteOrHash).route;
   }
-  /**
-   * Core functionalities like importing data, setting and getting tables
-   */
-  core;
-  /**
-   * Notification system to register callbacks on data changes
-   */
-  notify;
   // ...........................................................................
-  /**
-   * 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
-   * @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) {
-    if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
-    const controllers = await this._indexedControllers(route);
-    return this._get(route, where, controllers);
+  alias(aliasRouteOrHash) {
+    return this.column(aliasRouteOrHash).alias;
   }
   // ...........................................................................
-  /**
-   * Recursively fetches data from the given route using the provided controllers
-   * @param route - The route to fetch data from
-   * @param where - The filter to apply to the root table
-   * @param controllers - A record of controllers keyed by table name
-   * @returns An array of Rljson objects matching the route and filter
-   */
-  async _get(route, where, controllers) {
-    let filter = {};
-    if (Route.segmentHasRef(route.root)) {
-      let revision = "";
-      if (Route.segmentHasDefaultRef(route.root)) {
-        revision = Route.segmentRef(route.root);
-      } else {
-        revision = await this.getRefOfTimeId(
-          route.root.tableKey,
-          Route.segmentRef(route.root)
-        );
-      }
-      filter = { _hash: revision };
+  columnIndex(hashAliasOrRoute, throwIfNotExisting = true) {
+    if (typeof hashAliasOrRoute === "number") {
+      return hashAliasOrRoute;
     }
-    const rootRljson = await controllers[route.root.tableKey].get(
-      where,
-      filter
-    );
-    const rootRefs = rootRljson[route.root.tableKey]._data.map(
-      (r) => r._hash
-    );
-    if (route.segments.length === 1) {
-      return [rootRljson];
+    const str = Array.isArray(hashAliasOrRoute) ? hashAliasOrRoute.join("/") : hashAliasOrRoute;
+    const hashIndex = this.routeHashes.indexOf(str);
+    if (hashIndex >= 0) {
+      return hashIndex;
     }
-    const results = [];
-    for (const ref of rootRefs) {
-      const superiorRoute = new Route(route.segments.slice(0, -1));
-      const res = await this._get(
-        superiorRoute,
-        {
-          [route.root.tableKey + "Ref"]: ref
-        },
-        controllers
-      );
-      results.push(...res);
+    const aliasIndex = this.aliases.indexOf(str);
+    if (aliasIndex >= 0) {
+      return aliasIndex;
     }
-    return results.map((r) => ({ ...r, ...rootRljson }));
+    const routeIndex = this.routes.indexOf(str);
+    if (routeIndex < 0) {
+      if (throwIfNotExisting) {
+        throw new Error(`Unknown column alias or route: ${str}`);
+      }
+      return -1;
+    }
+    return routeIndex;
   }
-  // ...........................................................................
-  /**
-   * Runs an edit by executing the appropriate controller(s) based on the edit's route
-   * @param edit - The edit to run
-   * @returns The result of the edit as an EditProtocolRow
-   * @throws {Error} If the edit is not valid or if any controller cannot be created
+  /***
+   * Returns the column config for a specific alias, route or hash.
    */
-  async run(edit, options) {
-    const initialRoute = Route.fromFlat(edit.route);
-    const runs = await this._resolveRuns(edit);
-    const errors = validateEdit(edit);
-    if (!!errors.hasErrors) {
-      throw new Error(`Edit is not valid:
-${JSON.stringify(errors, null, 2)}`);
-    }
-    return this._run(edit, initialRoute, runs, options);
+  column(aliasRouteOrHash) {
+    const index = this.columnIndex(aliasRouteOrHash);
+    return this.columns[index];
   }
   // ...........................................................................
-  /**
-   * Recursively runs controllers based on the route of the edit
-   * @param edit - The edit to run
-   * @param route - The route of the edit
-   * @param runFns - A record of controller run functions, keyed by table name
-   * @returns The result of the edit
-   * @throws {Error} If the route is not valid or if any controller cannot be created
-   */
-  async _run(edit, route, runFns, options) {
-    let result;
-    let tableKey;
-    const segment = route.segment(0);
+  get count() {
+    return this.aliases.length;
+  }
+  // ...........................................................................
+  addedColumns(columnSelection) {
+    const a = this.routes.filter(
+      (route) => !columnSelection.routes.includes(route)
+    );
+    return a;
+  }
+  // ...........................................................................
+  static check(aliases, routes) {
+    const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
+    const invalidKeys = aliases.filter((key) => !camelCaseRegex.test(key));
+    if (invalidKeys.length > 0) {
+      throw new Error(
+        `Invalid alias "${invalidKeys[0]}". Aliases must be lower camel case.`
+      );
+    }
+    const validValueRegex = /^[a-zA-Z0-9/]*$/;
+    const invalidValues = routes.filter(
+      (value) => !validValueRegex.test(value)
+    );
+    if (invalidValues.length > 0) {
+      throw new Error(
+        `Invalid route "${invalidValues}". Routes must only contain letters, numbers and slashes.`
+      );
+    }
+    const pathParts = routes.map((value) => value.split("/")).flat();
+    const invalidPathParts = pathParts.filter(
+      (part) => !camelCaseRegex.test(part)
+    );
+    if (invalidPathParts.length > 0) {
+      throw new Error(
+        `Invalid route segment "${invalidPathParts[0]}". Route segments must be lower camel case.`
+      );
+    }
+    const routeCountMap = {};
+    routes.forEach((value) => {
+      routeCountMap[value] = (routeCountMap[value] ?? 0) + 1;
+    });
+    const duplicateRoutes = Object.entries(routeCountMap).filter(([, count]) => count > 1).map(([route]) => route);
+    if (duplicateRoutes.length > 0) {
+      throw new Error(
+        `Duplicate route ${duplicateRoutes[0]}. A column must only occur once.`
+      );
+    }
+  }
+  // ######################
+  // Private
+  // ######################
+  _throwOnWrongAlias(columns) {
+    const aliases = /* @__PURE__ */ new Set();
+    for (const column of columns) {
+      if (aliases.has(column.alias)) {
+        throw new Error(`Duplicate alias: ${column.alias}`);
+      }
+      aliases.add(column.alias);
+    }
+  }
+  _initColumns(columns) {
+    let i = 0;
+    return columns.map(
+      (column) => hip({
+        ...column,
+        routeHash: this.routeHashes[i],
+        index: i++,
+        _hash: ""
+      })
+    );
+  }
+  // ######################
+  // Example
+  // ######################
+  static example() {
+    return new ColumnSelection([
+      {
+        key: "stringCol",
+        alias: "stringCol",
+        route: "basicTypes/stringsRef/value",
+        type: "string",
+        titleLong: "String values",
+        titleShort: "Strings"
+      },
+      {
+        key: "intCol",
+        alias: "intCol",
+        route: "basicTypes/numbersRef/intsRef/value",
+        type: "number",
+        titleLong: "Int values",
+        titleShort: "Ints"
+      },
+      {
+        key: "floatCol",
+        alias: "floatCol",
+        route: "basicTypes/numbersRef/floatsRef/value",
+        type: "number",
+        titleLong: "Float values",
+        titleShort: "Floats"
+      },
+      {
+        key: "booleanCol",
+        alias: "booleanCol",
+        route: "basicTypes/booleansRef/value",
+        type: "boolean",
+        titleLong: "Boolean values",
+        titleShort: "Booleans"
+      },
+      {
+        key: "jsonObjectCol",
+        alias: "jsonObjectCol",
+        route: "complexTypes/jsonObjectsRef/value",
+        type: "json",
+        titleLong: "Json objects",
+        titleShort: "JO"
+      },
+      {
+        key: "jsonArrayCol",
+        alias: "jsonArrayCol",
+        route: "complexTypes/jsonArraysRef/value",
+        type: "jsonArray",
+        titleLong: "Array values",
+        titleShort: "JA"
+      },
+      {
+        key: "jsonValueCol",
+        alias: "jsonValueCol",
+        route: "complexTypes/jsonValuesRef/value",
+        type: "jsonValue",
+        titleLong: "Json values",
+        titleShort: "JV"
+      }
+    ]);
+  }
+  static exampleBroken() {
+    return [
+      {
+        key: "stringCol",
+        alias: "stringCol",
+        route: "basicTypes/stringsRef/value",
+        type: "string",
+        titleLong: "String values",
+        titleShort: "Strings"
+      },
+      {
+        key: "stringCol2",
+        alias: "stringCol",
+        // ⚠️ Duplicate alias
+        route: "basicTypes/stringsRef/value",
+        type: "string",
+        titleLong: "String values",
+        titleShort: "Strings"
+      }
+    ];
+  }
+  static exampleCarsColumnSelection() {
+    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/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: ""
+      },
+      {
+        key: "engine",
+        route: "carCake/carTechnicalLayer/carTechnical/engine",
+        alias: "engine",
+        titleLong: "Car Engine",
+        titleShort: "Engine",
+        type: "string",
+        _hash: ""
+      },
+      {
+        key: "repairedByWorkshop",
+        route: "carCake/carTechnicalLayer/carTechnical/repairedByWorkshop",
+        alias: "repairedByWorkshop",
+        titleLong: "Was Repaired By Workshop",
+        titleShort: "Repaired By Workshop",
+        type: "boolean",
+        _hash: ""
+      }
+    ]);
+  }
+  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) {
+    return null;
+  }
+  if (typeof search == "boolean") {
+    return search;
+  }
+  if (typeof search == "number") {
+    return search != 0;
+  }
+  if (typeof search == "string") {
+    const val = search.toLowerCase();
+    for (const trueValue of trueValues) {
+      if (val.startsWith(trueValue)) {
+        return true;
+      }
+    }
+    for (const falseValue of falseValues) {
+      if (val.startsWith(falseValue)) {
+        return false;
+      }
+    }
+    const containsOnlyNumbers = /^\d+$/.test(search);
+    if (containsOnlyNumbers) {
+      return parseInt(search) != 0;
+    }
+  }
+  return false;
+};
+const exampleBooleanFilter = () => hip({
+  column: "basicTypes/booleansRef/value",
+  operator: "equals",
+  type: "boolean",
+  search: true,
+  _hash: ""
+});
+class BooleanFilterProcessor {
+  constructor(operator, search) {
+    this.operator = operator;
+    this.search = search === null ? null : typeof search === "boolean" ? search : parseBooleanSearch(search);
+  }
+  search;
+  // ...........................................................................
+  static fromModel(model) {
+    return new BooleanFilterProcessor(model.operator, model.search);
+  }
+  // ...........................................................................
+  equals(other) {
+    return other instanceof BooleanFilterProcessor && this.operator === other.operator && this.search === other.search;
+  }
+  // ...........................................................................
+  static allOperators = ["equals", "notEquals"];
+  // ...........................................................................
+  matches(cellValue) {
+    if (this.search === null || this.search === void 0) {
+      return true;
+    }
+    if (cellValue === null || cellValue === void 0) {
+      return false;
+    }
+    if (typeof cellValue == "number") {
+      cellValue = cellValue != 0;
+    }
+    if (typeof cellValue == "string") {
+      const val = cellValue.toLowerCase();
+      cellValue = val === "true" || val === "yes" || "1";
+    }
+    switch (this.operator) {
+      case "equals":
+        return cellValue === this.search;
+      case "notEquals":
+        return cellValue !== this.search;
+    }
+  }
+  // ...........................................................................
+  static get example() {
+    const model = exampleBooleanFilter();
+    const filterProcessor = BooleanFilterProcessor.fromModel(model);
+    return filterProcessor;
+  }
+}
+const exampleNumberFilter = () => hip({
+  column: "basicTypes/numbersRef/intsRef/value",
+  operator: "greaterThanOrEquals",
+  type: "number",
+  search: 1e3,
+  _hash: ""
+});
+class NumberFilterProcessor {
+  constructor(operator, search) {
+    this.operator = operator;
+    if (operator === "filtrex") {
+      this.search = search;
+      this._initFiltrex();
+    } else {
+      this.search = typeof search == "string" ? parseFloat(search) : search;
+    }
+  }
+  // ...........................................................................
+  static fromModel(model) {
+    return new NumberFilterProcessor(model.operator, model.search);
+  }
+  equals(other) {
+    return other instanceof NumberFilterProcessor && this.operator === other.operator && this.search === other.search;
+  }
+  // ...........................................................................
+  static allOperators = [
+    "equals",
+    "notEquals",
+    "greaterThan",
+    "greaterThanOrEquals",
+    "lessThan",
+    "lessThanOrEquals",
+    "filtrex"
+  ];
+  // ...........................................................................
+  matches(cellValue) {
+    if (!this.search && this.search !== 0) {
+      return true;
+    }
+    if (cellValue === null || cellValue === void 0) {
+      return false;
+    }
+    switch (this.operator) {
+      case "equals":
+        return cellValue === this.search;
+      case "notEquals":
+        return cellValue !== this.search;
+      case "greaterThan":
+        return cellValue > this.search;
+      case "lessThan":
+        return cellValue < this.search;
+      case "greaterThanOrEquals":
+        return cellValue >= this.search;
+      case "lessThanOrEquals":
+        return cellValue <= this.search;
+      case "filtrex":
+        return this?._evalExpression(cellValue);
+    }
+  }
+  search = "";
+  static get example() {
+    return NumberFilterProcessor.fromModel(exampleNumberFilter());
+  }
+  // ######################
+  // Private
+  // ######################
+  _expression = null;
+  // ..........................................................................
+  _initFiltrex() {
+    if (this.search === "") {
+      return;
+    }
+    if (typeof this.search === "number") {
+      return;
+    }
+    const isNumber = /^\d+$/.test(this.search);
+    if (isNumber) {
+      this.search = parseInt(this.search);
+      return;
+    }
+    try {
+      this._expression = compileExpression(this.search);
+    } catch (_) {
+      this._expression = "";
+    }
+  }
+  // ...........................................................................
+  _evalExpression(cellValue) {
+    return this._expression ? (
+      // result can also contain errors which could be sent to the outside here
+      this._expression({ v: cellValue }) == true
+    ) : cellValue == this.search;
+  }
+}
+const exampleStringFilter = () => hip({
+  type: "string",
+  column: "basicTypes/stringsRef/value",
+  operator: "startsWith",
+  search: "t",
+  matchCase: false,
+  _hash: ""
+});
+class StringFilterProcessor {
+  constructor(operator, search, matchCase = false) {
+    this.operator = operator;
+    this.matchCase = matchCase;
+    this.search = (matchCase ? search : search.toLowerCase()).replaceAll(
+      " ",
+      ""
+    );
+    try {
+      this.regExp = operator === "regExp" ? new RegExp(search) : null;
+    } catch {
+    }
+  }
+  // ...........................................................................
+  static fromModel(model) {
+    return new StringFilterProcessor(
+      model.operator,
+      model.search,
+      model.matchCase
+    );
+  }
+  // ...........................................................................
+  search;
+  regExp = null;
+  // ...........................................................................
+  equals(other) {
+    return other instanceof StringFilterProcessor && this.operator === other.operator && this.search === other.search && this.matchCase === other.matchCase;
+  }
+  // ...........................................................................
+  static allOperators = [
+    "contains",
+    "equals",
+    "notEquals",
+    "startsWith",
+    "notContains",
+    "endsWith",
+    "regExp"
+  ];
+  // ...........................................................................
+  matches(cellValue) {
+    if (!this.search) {
+      return true;
+    }
+    if (cellValue === null || cellValue === void 0) {
+      return false;
+    }
+    if (typeof cellValue !== "string") {
+      cellValue = `${cellValue}`;
+    }
+    if (!this.matchCase) {
+      cellValue = cellValue.toLowerCase();
+    }
+    cellValue = cellValue.replaceAll(" ", "");
+    switch (this.operator) {
+      case "equals":
+        return cellValue === this.search;
+      case "notEquals":
+        return cellValue !== this.search;
+      case "startsWith":
+        return cellValue.startsWith(this.search);
+      case "contains":
+        return cellValue.includes(this.search);
+      case "endsWith":
+        return cellValue.endsWith(this.search);
+      /* v8 ignore next -- @preserve */
+      case "regExp":
+        return this.regExp?.test(cellValue) ?? false;
+      case "notContains":
+        return !cellValue.includes(this.search);
+    }
+  }
+  // ...........................................................................
+  static get example() {
+    const result = StringFilterProcessor.fromModel(exampleStringFilter());
+    return result;
+  }
+}
+class ColumnFilterProcessor {
+  /* v8 ignore next -- @preserve */
+  matches(_cellValue) {
+    return true;
+  }
+  equals(_other) {
+    return this === _other;
+  }
+  // ...........................................................................
+  static fromModel(model) {
+    switch (model.type) {
+      case "string":
+        return StringFilterProcessor.fromModel(model);
+      case "number":
+        return NumberFilterProcessor.fromModel(model);
+      case "boolean":
+        return BooleanFilterProcessor.fromModel(model);
+      /* v8 ignore next -- @preserve */
+      default:
+        return StringFilterProcessor.fromModel(model);
+    }
+  }
+  // ...........................................................................
+  /* v8 ignore stop */
+  static operatorsForType(type) {
+    switch (type) {
+      case "string":
+        return StringFilterProcessor.allOperators;
+      case "number":
+        return NumberFilterProcessor.allOperators;
+      case "boolean":
+        return BooleanFilterProcessor.allOperators;
+      default:
+        return StringFilterProcessor.allOperators;
+    }
+  }
+  static translationsForType(type, language) {
+    const operators = ColumnFilterProcessor.operatorsForType(type);
+    const translations = [];
+    for (const operator of operators) {
+      translations.push(
+        ColumnFilterProcessor.translateOperator(operator, language)
+      );
+    }
+    return translations;
+  }
+  static translateOperator(operator, language) {
+    const translations = {
+      equals: { en: "Equals", de: "Gleich" },
+      notEquals: { en: "Not equals", de: "Ungleich" },
+      greaterThan: { en: "Greater than", de: "Größer" },
+      greaterThanOrEquals: {
+        en: "Greater than or Equals",
+        de: "Größer oder gleich"
+      },
+      lessThan: { en: "Less than", de: "Kleiner als" },
+      lessThanOrEquals: {
+        en: "Less than or equals",
+        de: "Kleiner gleich"
+      },
+      startsWith: { en: "Starts with", de: "Beginnt mit" },
+      contains: { en: "Contains", de: "Enthält" },
+      notContains: { en: "Not contains", de: "Enthält nicht" },
+      endsWith: { en: "Ends with", de: "Endet mit" },
+      regExp: { en: "Regular expression", de: "Regulärer Ausdruck" },
+      filtrex: { en: "Expression", de: "Ausdruck" }
+    };
+    return translations[operator][language];
+  }
+}
+class RowFilterProcessor {
+  // ...........................................................................
+  constructor(columnFilters, operator = "and") {
+    this.operator = operator;
+    this._columnFilters = this._initColumnFilters(columnFilters);
+  }
+  // ...........................................................................
+  static fromModel(model) {
+    const operator = model.operator;
+    const columnFilters = {};
+    for (const columnFilter of model.columnFilters) {
+      const key = columnFilter.column;
+      const processor = ColumnFilterProcessor.fromModel(columnFilter);
+      columnFilters[key] = processor;
+    }
+    return new RowFilterProcessor(columnFilters, operator);
+  }
+  // ...........................................................................
+  get processors() {
+    return Object.values(this._columnFilters).map((item) => item.processor);
+  }
+  // ...........................................................................
+  /// Returns an empty filter
+  static get empty() {
+    return new RowFilterProcessor({}, "and");
+  }
+  // ...........................................................................
+  /// Checks if two filters are equal
+  equals(other) {
+    if (this.operator !== other.operator) {
+      return false;
+    }
+    const thisKeys = Object.keys(this._columnFilters);
+    const otherKeys = Object.keys(other._columnFilters);
+    if (thisKeys.length !== otherKeys.length) {
+      return false;
+    }
+    for (const key of thisKeys) {
+      const a = this._columnFilters[key];
+      const b = other._columnFilters[key];
+      if (a?.processor.equals(b?.processor) === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // ...........................................................................
+  applyTo(join) {
+    if (join.rowCount === 0) {
+      return join.data;
+    }
+    this._throwOnWrongRoutes(join.columnSelection);
+    const columnCount = join.columnCount;
+    const columnHashes = join.columnSelection.routeHashes;
+    const filterArray = new Array(columnCount).fill(
+      null
+    );
+    let hasFilters = false;
+    for (let c = 0; c < columnCount; c++) {
+      const hash = columnHashes[c];
+      const filter = this._columnFilters[hash];
+      if (filter) {
+        filterArray[c] = filter.processor;
+        hasFilters = true;
+      }
+    }
+    if (!hasFilters) {
+      return join.data;
+    }
+    let rowIndices = [];
+    switch (this.operator) {
+      case "and":
+        rowIndices = this._filterRowsAnd(join, filterArray);
+        break;
+      case "or":
+        rowIndices = this._filterRowsOr(join, filterArray);
+        break;
+    }
+    const result = {};
+    const rowIndexSet = new Set(rowIndices);
+    let idx = 0;
+    for (const [sliceId, row] of Object.entries(join.data)) {
+      if (rowIndexSet.has(idx)) {
+        result[sliceId] = row;
+      }
+      idx++;
+    }
+    return result;
+  }
+  // ######################
+  // Private
+  // ######################
+  // ...........................................................................
+  _columnFilters;
+  // ...........................................................................
+  _initColumnFilters(columnFilters) {
+    const result = {};
+    const columnKeys = Object.keys(columnFilters);
+    const columnRoutes = columnKeys.map((k) => Route.fromFlat(k));
+    const columnSelection = ColumnSelection.fromRoutes(columnRoutes);
+    const { routeHashes, routes } = columnSelection;
+    for (let i = 0; i < routeHashes.length; i++) {
+      const routeHash = routeHashes[i];
+      const route = routes[i];
+      const processor = columnFilters[route];
+      result[routeHash] = {
+        processor,
+        routeHash,
+        route
+      };
+    }
+    return result;
+  }
+  // ...........................................................................
+  _filterRowsAnd(join, filters) {
+    const rowCount = join.rowCount;
+    let remainingIndices = new Array(rowCount);
+    for (let i = 0; i < rowCount; i++) {
+      remainingIndices[i] = i;
+    }
+    const columnCount = join.columnCount;
+    for (let c = 0; c < columnCount; c++) {
+      remainingIndices = this._filterColumnAnd(
+        join,
+        c,
+        remainingIndices,
+        filters
+      );
+    }
+    return remainingIndices;
+  }
+  // ...........................................................................
+  _filterColumnAnd(join, columnIndex, remainingIndices, filters) {
+    const result = [];
+    const filter = filters[columnIndex];
+    if (filter == null) {
+      return remainingIndices;
+    }
+    for (const i of remainingIndices) {
+      const cellValue = join.value(i, columnIndex);
+      if (Array.isArray(cellValue)) {
+        for (const v of cellValue) {
+          if (typeof v === "object" && v !== null && v.hasOwnProperty("_value")) {
+            const matchValue = v._value;
+            if (filter.matches(matchValue)) {
+              result.push(i);
+              break;
+            }
+          } else {
+            if (filter.matches(v)) {
+              result.push(i);
+              break;
+            }
+          }
+        }
+      } else {
+        if (filter.matches(cellValue)) {
+          result.push(i);
+        }
+      }
+    }
+    return result;
+  }
+  // ...........................................................................
+  _filterRowsOr(join, filters) {
+    const applyTo = new Array(join.rowCount).fill(false);
+    const columnCount = join.columnCount;
+    for (let c = 0; c < columnCount; c++) {
+      this._filterColumnOr(join, c, applyTo, filters);
+    }
+    let rowCount = 0;
+    for (let r = 0; r < applyTo.length; r++) {
+      if (applyTo[r]) {
+        rowCount++;
+      }
+    }
+    const result = new Array(rowCount);
+    let resultIndex = 0;
+    for (let r = 0; r < applyTo.length; r++) {
+      if (applyTo[r]) {
+        result[resultIndex] = r;
+        resultIndex++;
+      }
+    }
+    return result;
+  }
+  // ...........................................................................
+  _filterColumnOr(join, columnIndex, applyTo, filters) {
+    const filter = filters[columnIndex];
+    if (filter == null) {
+      return;
+    }
+    for (let r = 0; r < join.rowCount; r++) {
+      if (applyTo[r]) {
+        continue;
+      }
+      const cellValue = join.value(r, columnIndex);
+      if (filter.matches(cellValue)) {
+        applyTo[r] = true;
+      }
+    }
+  }
+  // ...........................................................................
+  _throwOnWrongRoutes(columnSelection) {
+    const availableRoutes = columnSelection.routes;
+    for (const item of Object.values(this._columnFilters)) {
+      const route = item.route;
+      if (availableRoutes.includes(route) === false) {
+        throw new Error(
+          `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")}`
+        );
+      }
+    }
+  }
+}
+class Join {
+  constructor(baseRows, _baseColumnSelection, _objectMap) {
+    this._baseColumnSelection = _baseColumnSelection;
+    this._objectMap = _objectMap;
+    this._base = this._hashedRows(baseRows);
+  }
+  _base = {};
+  _processes = [];
+  // ...........................................................................
+  /**
+   * Applies a filter to the join and returns the filtered view
+   *
+   * @param filter The filter to apply
+   */
+  filter(filter) {
+    const proc = RowFilterProcessor.fromModel(filter);
+    const data = proc.applyTo(this);
+    const process = {
+      type: "filter",
+      instance: filter,
+      data,
+      columnSelection: this.columnSelection
+    };
+    this._processes.push(process);
+    return this;
+  }
+  // ...........................................................................
+  /**
+   * Applies a set value action to the join and returns the edited join
+   *
+   * @param setValue The set value action to apply
+   */
+  setValue(setValue) {
+    const data = {};
+    for (const [sliceId, joinRowH] of Object.entries(this.data)) {
+      const cols = [...joinRowH.columns];
+      for (const col of cols) {
+        if (Route.fromFlat(setValue.route).equalsWithoutRefs(col.route))
+          col.insert = setValue.value;
+        else continue;
+      }
+      data[sliceId] = {
+        rowHash: Hash.default.calcHash(cols.map((c) => c.value)),
+        columns: cols
+      };
+    }
+    const process = {
+      type: "setValue",
+      instance: setValue,
+      data,
+      columnSelection: this.columnSelection
+    };
+    this._processes.push(process);
+    return this;
+  }
+  // ...........................................................................
+  /**
+   * Applies multiple set value actions to the join and returns the edited join
+   *
+   * @param setValues The set value actions to apply
+   */
+  setValues(setValues) {
+    let result = this.clone();
+    for (const setValue of setValues) {
+      result = result.setValue(setValue);
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Selects columns from the join and returns the resulting join
+   *
+   * @param columnSelection The column selection to apply
+   */
+  select(columnSelection) {
+    const columnCount = columnSelection.count;
+    const masterColumnIndices = new Array(columnCount);
+    let i = 0;
+    for (const hash of columnSelection.routeHashes) {
+      const index = this.columnSelection.columnIndex(hash);
+      masterColumnIndices[i] = index;
+      i++;
+    }
+    const data = {};
+    for (let i2 = 0; i2 < this.rowCount; i2++) {
+      const [sliceId, row] = Object.entries(this.data)[i2];
+      const selectedColumns = [];
+      for (let j = 0; j < masterColumnIndices.length; j++) {
+        selectedColumns.push(row.columns[masterColumnIndices[j]]);
+      }
+      data[sliceId] = {
+        rowHash: Hash.default.calcHash(
+          selectedColumns.map((c) => c.value)
+        ),
+        columns: selectedColumns
+      };
+    }
+    const process = {
+      type: "selection",
+      instance: columnSelection,
+      data,
+      columnSelection
+    };
+    this._processes.push(process);
+    return this;
+  }
+  // ...........................................................................
+  /**
+   * Sorts the join rows and returns the sorted join
+   *
+   * @param rowSort The row sort to apply
+   */
+  sort(rowSort) {
+    const sortedIndices = rowSort.applyTo(this);
+    const data = {};
+    for (let i = 0; i < sortedIndices.length; i++) {
+      const sliceId = sortedIndices[i];
+      data[sliceId] = this.data[sliceId];
+    }
+    const process = {
+      type: "sort",
+      instance: rowSort,
+      data,
+      columnSelection: this.columnSelection
+    };
+    this._processes.push(process);
+    return this;
+  }
+  // ...........................................................................
+  /**
+   * Returns insert Object of the join
+   */
+  insert() {
+    const cakeInserts = this._insertCakeObjects(this.data);
+    const cakeInsertsMergedOfLayerRoutes = /* @__PURE__ */ new Map();
+    for (const { [this.cakeRoute.root.tableKey]: cakeInsert } of cakeInserts) {
+      const cakeInsertRoute = cakeInsert.route.flat;
+      if (!cakeInsertsMergedOfLayerRoutes.has(cakeInsertRoute)) {
+        cakeInsertsMergedOfLayerRoutes.set(cakeInsertRoute, cakeInsert.value);
+      } else {
+        const existingValue = cakeInsertsMergedOfLayerRoutes.get(
+          cakeInsertRoute
+        );
+        const mergedValue = merge(existingValue, cakeInsert.value);
+        cakeInsertsMergedOfLayerRoutes.set(cakeInsertRoute, mergedValue);
+      }
+    }
+    const results = [];
+    for (const [route, value] of cakeInsertsMergedOfLayerRoutes) {
+      const insert = {
+        command: "add",
+        route,
+        value
+      };
+      results.push(insert);
+    }
+    return results;
+  }
+  // ...........................................................................
+  /**
+   * Returns the value at the given row and column index
+   *
+   * @param row The row index
+   * @param column The column index
+   * @returns The value at the given row and column
+   */
+  value(row, column) {
+    return this.rows[row][column];
+  }
+  // ...........................................................................
+  /**
+   * Clones the join
+   *
+   * @returns The cloned join
+   */
+  clone() {
+    const cloned = Object.create(this);
+    cloned._data = this._base;
+    cloned._processes = [...this._processes];
+    return cloned;
+  }
+  // ...........................................................................
+  /**
+   * Returns all component routes of the join
+   */
+  get componentRoutes() {
+    return Array.from(
+      new Set(
+        Object.values(this.columnSelection.columns).map(
+          (c) => Route.fromFlat(c.route).upper().flatWithoutRefs
+        )
+      )
+    ).map((r) => Route.fromFlat(r));
+  }
+  // ...........................................................................
+  /**
+   * Returns all layer routes of the join
+   */
+  get layerRoutes() {
+    return Array.from(
+      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));
+  }
+  // ...........................................................................
+  /**
+   * Returns the cake route of the join
+   */
+  get cakeRoute() {
+    const cakeRoute = Array.from(
+      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(
+        `Join: Error while getting cake route: The join has ${cakeRoute.length} different cake routes. Cannot determine a single cake route.`
+      );
+    }
+    return cakeRoute[0];
+  }
+  // ...........................................................................
+  /**
+   * Returns the number of rows in the join
+   */
+  get rowCount() {
+    return Object.keys(this.data).length;
+  }
+  // ...........................................................................
+  /**
+   * Returns the number of columns in the join
+   */
+  get columnCount() {
+    return this.columnSelection.count;
+  }
+  // ...........................................................................
+  /**
+   * Returns the row indices (sliceIds) of the join
+   */
+  get rowIndices() {
+    return Object.keys(this.data);
+  }
+  // ...........................................................................
+  /**
+   * Returns the join row for the given slice id
+   *
+   * @param sliceId - The slice id
+   * @returns The join row
+   */
+  row(sliceId) {
+    return this.data[sliceId].columns;
+  }
+  // ...........................................................................
+  /**
+   * Returns the data of the join
+   */
+  get data() {
+    if (this._processes.length > 0) {
+      return this._processes[this._processes.length - 1].data;
+    }
+    return this._base;
+  }
+  // ...........................................................................
+  /**
+   * Returns the column types of the join
+   */
+  get columnTypes() {
+    return this.columnSelection.columns.map((col) => col.type);
+  }
+  // ...........................................................................
+  /**
+   * Returns the column selection of the join
+   */
+  get columnSelection() {
+    if (this._processes.length > 0) {
+      return this._processes[this._processes.length - 1].columnSelection;
+    }
+    return this._baseColumnSelection;
+  }
+  // ...........................................................................
+  /**
+   * Returns all rows of the join w/ nulled missing values
+   *
+   * @return The rows of the join
+   */
+  get rows() {
+    const result = [];
+    const sliceIds = Object.keys(this.data);
+    for (const sliceId of sliceIds) {
+      const dataColumns = this.data[sliceId].columns;
+      const row = [];
+      for (const colInfo of this.columnSelection.columns) {
+        const joinCol = dataColumns.find((dataCol) => {
+          const colInfoRoute = Route.fromFlat(colInfo.route);
+          const dataColRoute = dataCol.route;
+          return colInfoRoute.equalsWithoutRefs(dataColRoute);
+        });
+        row.push(joinCol ? joinCol.insert ?? joinCol.value : null);
+      }
+      result.push(row);
+    }
+    return result;
+  }
+  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
+   */
+  _insertCakeObjects(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
+      )) {
+        if (!compInsertObj._somethingToInsert) continue;
+        const compRoute = Route.fromFlat(compRouteFlat);
+        if (layerRoute.includes(compRoute)) {
+          const layerInsertObj = {};
+          layerInsertObj[layerRoute.root.tableKey] = {
+            route: Route.fromFlat(compRouteFlat),
+            value: {
+              [sliceId]: compInsertObj
+            }
+          };
+          layerInsertObjects.push(layerInsertObj);
+        } else {
+          continue;
+        }
+      }
+    }
+    return layerInsertObjects;
+  }
+  // ...........................................................................
+  /**
+   * Merges columns into component insert objects
+   * @param insertColumns - The columns to merge
+   * @returns
+   */
+  _insertComponentObjects(sliceId, insertColumns) {
+    const columns = this._mergeInsertRow(sliceId, insertColumns);
+    return this._denormalizeComponentInserts(columns, this._objectMap || {});
+  }
+  _denormalizeComponentInserts(columns, objectMap, refTableKey) {
+    const result = {};
+    for (const [propertyKey, propertyValue] of Object.entries(objectMap)) {
+      if (typeof propertyValue === "object") {
+        const refObjectMap = {};
+        const refTableKey2 = propertyValue._tableKey;
+        for (const [refKey, refValue] of Object.entries(
+          propertyValue
+        )) {
+          if (refKey === "_tableKey") continue;
+          refObjectMap[refTableKey2 + "/" + refKey] = refValue;
+        }
+        const refInsert = this._denormalizeComponentInserts(
+          columns,
+          refObjectMap,
+          refTableKey2
+        );
+        for (const [refRoute, refObject] of Object.entries(refInsert)) {
+          const insertObj = { [propertyKey]: refObject };
+          result[refRoute] = {
+            ...result[refRoute],
+            ...insertObj,
+            ...{
+              _somethingToInsert: result[refRoute]._somethingToInsert || refObject._somethingToInsert
+            }
+          };
+        }
+      } else {
+        let compKey = Route.fromFlat(propertyValue).upper().flat;
+        compKey = refTableKey ? compKey.replace(`/${refTableKey}`, "") : compKey;
+        const refPropertyKey = refTableKey ? propertyKey.replace(`${refTableKey}/`, "") : propertyKey;
+        if (!result[compKey]) result[compKey] = {};
+        if (refTableKey && !result[compKey]._tableKey)
+          result[compKey]._tableKey = refTableKey;
+        const propValue = columns.find((col) => {
+          return col.route.propertyKey === propertyKey;
+        });
+        if (!propValue) {
+          throw new Error(
+            `Join._denormalizeComponentInserts: Could not find column value for property key "${propertyKey}".`
+          );
+        }
+        const somethingToInsert = !!propValue.insert;
+        result[compKey] = {
+          ...result[compKey],
+          [refPropertyKey]: propValue.insert ?? propValue.value,
+          ...{
+            _somethingToInsert: result[compKey]._somethingToInsert || somethingToInsert
+          }
+        };
+      }
+    }
+    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.
+   *
+   * @param rows The join rows to hash
+   * @returns The hashed join rows
+   */
+  _hashedRows(rows) {
+    const sliceIds = Object.keys(rows);
+    const hashedRows = {};
+    for (const sliceId of sliceIds) {
+      const columns = rows[sliceId];
+      const rowHash = Hash.default.calcHash(
+        columns.map((col) => col.insert ?? col.value)
+      );
+      hashedRows[sliceId] = {
+        rowHash,
+        columns
+      };
+    }
+    return hashedRows;
+  }
+}
+class Notify {
+  _callbacks = /* @__PURE__ */ new Map();
+  // ...........................................................................
+  constructor() {
+  }
+  // ...........................................................................
+  /**
+   * Registers a callback for a specific route.
+   * @param route   The route to register the callback for.
+   * @param callback  The callback function to be invoked when a notification is sent.
+   */
+  register(route, callback) {
+    this._callbacks.set(route.flat, [
+      ...this._callbacks.get(route.flat) || [],
+      callback
+    ]);
+  }
+  // ...........................................................................
+  /**
+   * Unregisters a callback for a specific route.
+   * @param route   The route to unregister the callback from.
+   * @param callback  The callback function to be removed.
+   */
+  unregister(route, callback) {
+    const callbacks = this._callbacks.get(route.flat);
+    if (callbacks) {
+      this._callbacks.set(
+        route.flat,
+        callbacks.filter((cb) => cb !== callback)
+      );
+    }
+  }
+  // ...........................................................................
+  /**
+   * Notifies all registered callbacks for a specific route with the provided edit protocol row.
+   * @param route   The route to notify callbacks for.
+   * @param insertHistoryRow  The edit protocol row to pass to the callbacks.
+   */
+  notify(route, insertHistoryRow) {
+    const callbacks = this._callbacks.get(route.flat);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        cb(insertHistoryRow);
+      }
+    }
+  }
+  // ...........................................................................
+  /**
+   * Returns the current map of registered callbacks.
+   * @returns A map where keys are route strings and values are arrays of callback functions.
+   */
+  get callbacks() {
+    return this._callbacks;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves the list of callbacks registered for a specific route.
+   * @param route   The route to get callbacks for.
+   * @returns An array of callback functions registered for the specified route.
+   */
+  getCallBacksForRoute(route) {
+    return this._callbacks.get(route.flat) || [];
+  }
+}
+class Db {
+  /**
+   * Constructor
+   * @param _io - The Io instance used to read and write data
+   */
+  constructor(_io) {
+    this._io = _io;
+    this.core = new Core(this._io);
+    this.notify = new Notify();
+  }
+  /**
+   * Core functionalities like importing data, setting and getting tables
+   */
+  core;
+  /**
+   * Notification system to register callbacks on data changes
+   */
+  notify;
+  _cache = /* @__PURE__ */ new Map();
+  // ...........................................................................
+  /**
+   * 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
+   * @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) {
+    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 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;
+    }
+  }
+  // ...........................................................................
+  /**
+   * 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
+   * @returns - An Rljson object matching the route and filters
+   */
+  async _get(route, where, controllers, filter) {
+    const nodeTableKey = route.top.tableKey;
+    const nodeRoute = route;
+    const nodeRouteRef = await this._getReferenceOfRouteSegment(nodeRoute.top);
+    const nodeController = controllers[nodeTableKey];
+    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 = { ...nodeWhere, ...{ _hash: nodeRouteRef } };
+    delete nodeWhere["_through"];
+    delete nodeWhere["_tableKey"];
+    const {
+      [nodeTableKey]: { _data: nodeRows, _type: nodeType, _hash: nodeHash }
+    } = await nodeController.get(nodeWhere);
+    const nodeRowsFiltered = [];
+    if (filter && filter.length > 0) {
+      for (const f of filter) {
+        if (f.tableKey !== nodeTableKey) continue;
+        for (const nodeRow of nodeRows) {
+          if (nodeRow._hash === f.ref) {
+            nodeRowsFiltered.push(nodeRow);
+          }
+        }
+      }
+    } else {
+      nodeRowsFiltered.push(...nodeRows);
+    }
+    const node = {
+      [nodeTableKey]: {
+        _data: nodeRowsFiltered,
+        _type: nodeType,
+        _hash: nodeHash
+      }
+    };
+    if (route.isRoot) {
+      if (route.hasPropertyKey) {
+        return this.isolatePropertyFromComponents(node, route.propertyKey);
+      }
+      return node;
+    }
+    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 childrenRefs = await nodeController.getChildRefs(
+        nodeRow._hash
+      );
+      const rowChildren = await this._get(
+        childrenRoute,
+        childrenWhere,
+        controllers,
+        childrenRefs
+      );
+      if (rowChildren[childrenTableKey]._data.length === 0) continue;
+      nodeChildrenArray.push(rowChildren);
+      if (childrenThroughProperty) {
+        const childrenHashes = rowChildren[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 (childrenHashes.includes(th)) {
+                nodeRowsMatchingChildrenRefs.set(nr._hash, nr);
+              }
+            }
+          }
+        }
+      }
+    }
+    const nodeChildren = merge(...nodeChildrenArray);
+    if (childrenThroughProperty) {
+      const matchedNodeRows = Array.from(nodeRowsMatchingChildrenRefs.values());
+      return {
+        ...node,
+        ...{
+          [nodeTableKey]: {
+            _data: matchedNodeRows,
+            _type: nodeType,
+            _hash: nodeHash
+          }
+        },
+        ...nodeChildren
+      };
+    }
+    return { ...node, ...nodeChildren };
+  }
+  // ...........................................................................
+  /**
+   * Get the reference (hash) of a route segment, considering default refs and insertHistory refs
+   * @param segment - The route segment to get the reference for
+   * @returns
+   */
+  async _getReferenceOfRouteSegment(segment) {
+    if (Route.segmentHasRef(segment)) {
+      if (Route.segmentHasDefaultRef(segment)) {
+        return Route.segmentRef(segment);
+      } else {
+        return await this.getRefOfTimeId(
+          segment.tableKey,
+          Route.segmentRef(segment)
+        );
+      }
+    }
+    return null;
+  }
+  // ...........................................................................
+  /**
+   * Joins data from layers in an Rljson into a single dataset
+   * @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) {
+      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]
+      );
+      layers.set(layerKey, layer);
+    }
+    const components = /* @__PURE__ */ new Map();
+    for (const [tableKey, table] of Object.entries(data)) {
+      if (table._type !== "components") continue;
+      components.set(tableKey, table);
+    }
+    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();
+    let objectMap = {};
+    for (const [layerKey, layer] of layers.entries()) {
+      const componentKey = layer.componentsTable;
+      const componentResolved = await this._resolveComponent(
+        `${cakeKey}/${layerKey}/`,
+        componentKey
+      );
+      objectMap = { ...objectMap, ...componentResolved.objectMap };
+      columnInfos.set(componentKey, componentResolved.columnInfos);
+      columnCfgs.set(componentKey, componentResolved.columnCfgs);
+    }
+    const rowMap = /* @__PURE__ */ new Map();
+    const joinColumnInfos = /* @__PURE__ */ new Map();
+    for (const sliceId of mergedSliceIds) {
+      const 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 rowComponentProperties = componentsTable._data.find(
+          (r) => r._hash === componentRef
+        );
+        const resolvedProperties = this._resolveComponentProperties(
+          rowComponentProperties,
+          objectMap,
+          data
+        );
+        const joinColumns = [];
+        for (const [
+          resolvedPropertyKey,
+          resolvedPropertyValue
+        ] of Object.entries(resolvedProperties)) {
+          const propertyRoute = cakeKey + "/" + layerKey + "/" + componentKey + "/" + resolvedPropertyKey;
+          const propertyColumnInfo = columnInfos.get(componentKey).find((cI) => cI.route === propertyRoute);
+          if (!!propertyColumnInfo) {
+            const joinColumnRoute = Route.fromFlat(
+              `${cakeKey}@${cakeRef}/${layerKey}@${layerRef}/${componentKey}@${componentRef}`
+            );
+            joinColumnRoute.propertyKey = resolvedPropertyKey;
+            joinColumnInfos.set(resolvedPropertyKey, {
+              ...propertyColumnInfo,
+              key: resolvedPropertyKey,
+              route: joinColumnRoute.flatWithoutRefs.slice(1)
+            });
+            joinColumns.push({
+              route: joinColumnRoute,
+              value: resolvedPropertyValue ?? null,
+              insert: null
+            });
+          }
+        }
+        sliceIdRow.push(...joinColumns);
+      }
+      rowMap.set(sliceId, sliceIdRow);
+    }
+    const joinRows = {};
+    for (const [sliceId, joinColumns] of rowMap.entries()) {
+      Object.assign(joinRows, {
+        [sliceId]: joinColumns
+      });
+    }
+    return new Join(
+      joinRows,
+      new ColumnSelection(Array.from(joinColumnInfos.values())),
+      objectMap
+    ).select(columnSelection);
+  }
+  _resolveComponentProperties(componentData, objectMapOrRoute, baseData) {
+    let result = {};
+    for (const [propertyKey, propertyObjectMap] of Object.entries(
+      objectMapOrRoute
+    )) {
+      if (propertyKey === "_tableKey") continue;
+      if (typeof propertyObjectMap === "object") {
+        const refs = Array.isArray(componentData[propertyKey]) ? componentData[propertyKey] : [componentData[propertyKey]];
+        const refTableKey = propertyObjectMap["_tableKey"];
+        const refCompTable = baseData[refTableKey];
+        if (!refCompTable) continue;
+        const prefixedResolvedRefCompData = {};
+        for (const ref of refs) {
+          const refCompData = refCompTable._data.find((r) => r._hash === ref);
+          if (refCompData) {
+            const resolvedRefCompData = this._resolveComponentProperties(
+              refCompData,
+              propertyObjectMap,
+              baseData
+            );
+            for (const [refPropKey, value] of Object.entries(
+              resolvedRefCompData
+            )) {
+              if (!prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`]) {
+                prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`] = [];
+              }
+              prefixedResolvedRefCompData[`${refTableKey}/${refPropKey}`].push({
+                _ref: ref,
+                _value: value
+              });
+            }
+          }
+          result = {
+            ...result,
+            ...prefixedResolvedRefCompData
+          };
+        }
+      }
+      result = {
+        ...result,
+        ...{ [propertyKey]: componentData[propertyKey] }
+      };
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Resolve a component's columns, including referenced components
+   *
+   * @param baseRoute - The base route for the component
+   * @param componentKey - The component's table key
+   * @returns - The resolved column configurations, column infos, and object map
+   */
+  async _resolveComponent(baseRoute, componentKey) {
+    const { columns: colCfgs } = await this.core.tableCfg(componentKey);
+    const objectMap = {};
+    const columnCfgs = [];
+    const columnInfos = [];
+    for (let i = 0; i < colCfgs.length; i++) {
+      if (colCfgs[i].key === "_hash") continue;
+      const colCfg = colCfgs[i];
+      if (colCfg.ref) {
+        const columnCfgsAndInfosForRef = await this._resolveComponent(
+          baseRoute + `/${componentKey}`,
+          colCfg.ref.tableKey
+        );
+        objectMap[colCfg.key] = {
+          _tableKey: colCfg.ref.tableKey,
+          ...columnCfgsAndInfosForRef.objectMap
+        };
+        const columnCfgsForRef = columnCfgsAndInfosForRef.columnCfgs.map(
+          (cc) => ({
+            ...cc,
+            key: colCfg.ref.tableKey + "/" + cc.key
+          })
+        );
+        const columnInfosForRef = columnCfgsAndInfosForRef.columnInfos.map(
+          (cc) => ({
+            ...cc,
+            key: colCfg.ref.tableKey + "/" + cc.key
+          })
+        );
+        columnCfgs.push(...columnCfgsForRef);
+        columnInfos.push(...columnInfosForRef);
+      }
+      const columnRoute = Route.fromFlat(
+        baseRoute.length > 0 ? `${baseRoute}/${componentKey}/${colCfg.key}` : `/${componentKey}/${colCfg.key}`
+      ).flat.slice(1);
+      if (!objectMap[colCfg.key]) objectMap[colCfg.key] = columnRoute;
+      columnCfgs.push(colCfg);
+      columnInfos.push({
+        ...colCfg,
+        alias: `${colCfg.key}`,
+        route: columnRoute,
+        titleShort: colCfg.key,
+        titleLong: colCfg.key
+      });
+    }
+    return { columnCfgs, columnInfos, objectMap };
+  }
+  // ...........................................................................
+  /**
+   * 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 componentRoute = Route.fromFlat(colInfo.route);
+      const isolatedComponentRoute = await this.isolatePropertyKeyFromRoute(
+        componentRoute
+      );
+      uniqueComponentRoutes.add(
+        isolatedComponentRoute.toRouteWithoutProperty().flat
+      );
+    }
+    const data = {};
+    for (const compRouteFlat of uniqueComponentRoutes) {
+      const uniqueComponentRoute = Route.fromFlat(compRouteFlat);
+      const componentData = await this.get(uniqueComponentRoute, {});
+      Object.assign(data, componentData);
+    }
+    return data;
+  }
+  // ...........................................................................
+  /**
+   * Runs an Insert by executing the appropriate controller(s) based on the Insert's route
+   * @param Insert - The Insert to run
+   * @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)}`
+      );
+    }
+    return this._insert(insert, initialRoute, runs, options);
+  }
+  // ...........................................................................
+  /**
+   * Recursively runs controllers based on the route of the Insert
+   * @param insert - The Insert to run
+   * @param route - The route of the Insert
+   * @param runFns - A record of controller run functions, keyed by table name
+   * @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 results;
+    let tableKey;
+    const segment = route.segment(0);
     tableKey = segment.tableKey;
     let previous = [];
     if (Route.segmentHasRef(segment)) {
       const routeRef = Route.segmentRef(segment);
-      if (Route.segmentHasProtocolRef(segment)) {
+      if (Route.segmentHasInsertHistoryRef(segment)) {
         previous = [...previous, routeRef];
       }
       if (Route.segmentHasDefaultRef(segment)) {
@@ -621,47 +2729,74 @@ ${JSON.stringify(errors, null, 2)}`);
     }
     if (!route.isRoot) {
       const childRoute = route.deeper(1);
-      const childKeys = this._childKeys(route, edit.value);
+      const childKeys = this._childKeys(insert.value);
       const childRefs = {};
       for (const k of childKeys) {
-        const childValue = edit.value[k];
-        const childEdit = { ...edit, value: childValue };
-        const childResult = await this._run(childEdit, childRoute, runFns);
+        const childValue = insert.value[k];
+        const childInsert = { ...insert, value: childValue };
+        const childResults = await this._insert(
+          childInsert,
+          childRoute,
+          runFns
+        );
         const childRefKey = childRoute.top.tableKey + "Ref";
-        const childRef = childResult[childRefKey];
-        childRefs[k] = childRef;
+        const childRefArray = childResults.map(
+          (childResult) => childResult[childRefKey]
+        );
+        childRefs[k] = childRefArray;
       }
       const runFn = runFns[tableKey];
-      result = {
-        ...await runFn(
-          edit.command,
+      results = [
+        ...(await runFn(
+          insert.command,
           {
-            ...edit.value,
+            ...insert.value,
             ...childRefs
           },
-          edit.origin
-        ),
-        previous
-      };
+          insert.origin
+        )).map((r) => ({ ...r, ...{ previous } }))
+      ];
     } else {
       tableKey = route.root.tableKey;
       const runFn = runFns[tableKey];
-      result = {
-        ...await runFn(edit.command, edit.value, edit.origin),
-        previous
-      };
+      const insertValue = insert.value;
+      for (const [propertyKey, propertyValue] of Object.entries(insert.value)) {
+        if (propertyValue && typeof propertyValue === "object" && !!propertyValue._tableKey) {
+          const referenceRoute = propertyValue._tableKey;
+          delete propertyValue._tableKey;
+          const referenceInsert = {
+            command: insert.command,
+            route: referenceRoute,
+            value: propertyValue
+          };
+          const referencesWritten = (await this._insert(
+            referenceInsert,
+            Route.fromFlat(referenceRoute),
+            runFns
+          )).map((h) => h[referenceRoute + "Ref"]);
+          insertValue[propertyKey] = referencesWritten.length === 1 ? referencesWritten[0] : referencesWritten;
+        }
+      }
+      results = [
+        ...(await runFn(insert.command, insertValue, insert.origin)).map(
+          (r) => ({ ...r, previous })
+        )
+      ];
     }
-    result.route = edit.route;
-    await this._writeProtocol(tableKey, result);
-    if (!options?.skipNotification)
-      this.notify.notify(Route.fromFlat(edit.route), result);
-    return result;
+    for (const result of results) {
+      result.route = insert.route;
+      if (!options?.skipHistory)
+        await this._writeInsertHistory(tableKey, result);
+      if (!options?.skipNotification)
+        this.notify.notify(Route.fromFlat(insert.route), result);
+    }
+    return results;
   }
   // ...........................................................................
   /**
-   * Registers a callback to be called when an edit is made on the given route
+   * Registers a callback to be called when an Insert is made on the given route
    * @param route - The route to register the callback on
-   * @param callback - The callback to be called when an edit is made
+   * @param callback - The callback to be called when an Insert is made
    */
   registerObserver(route, callback) {
     this.notify.register(route, callback);
@@ -677,34 +2812,42 @@ ${JSON.stringify(errors, null, 2)}`);
   }
   // ...........................................................................
   /**
-   * Resolves an edit by returning the run functions of all controllers involved in the edit's route
-   * @param edit - The edit to resolve
+   * 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 _resolveRuns(edit) {
+  async _resolveInsert(Insert2) {
     const controllers = await this._indexedControllers(
-      Route.fromFlat(edit.route)
+      Route.fromFlat(Insert2.route)
     );
+    const referencedComponentTableKeys = /* @__PURE__ */ new Set();
+    traverse(Insert2.value, ({ key, parent }) => {
+      if (key == "_tableKey")
+        referencedComponentTableKeys.add(parent[key]);
+    });
+    for (const tableKey of referencedComponentTableKeys) {
+      controllers[tableKey] ??= await this.getController(tableKey);
+    }
     const runFns = {};
     for (const tableKey of Object.keys(controllers)) {
-      runFns[tableKey] = controllers[tableKey].run.bind(controllers[tableKey]);
+      runFns[tableKey] = controllers[tableKey].insert.bind(
+        controllers[tableKey]
+      );
     }
     return runFns;
   }
   // ...........................................................................
   /**
    * Returns the keys of child refs in a value based on a route
-   * @param route - The route to check
    * @param value - The value to check
    * @returns An array of keys of child refs in the value
    */
-  _childKeys(route, value) {
+  _childKeys(value) {
     const keys = Object.keys(value);
     const childKeys = [];
     for (const k of keys) {
       if (typeof value[k] !== "object") continue;
-      if (k.endsWith("Ref") && route.next?.tableKey + "Ref" !== k) continue;
       childKeys.push(k);
     }
     return childKeys;
@@ -718,25 +2861,19 @@ ${JSON.stringify(errors, null, 2)}`);
    * @throws {Error} If the table does not exist or if the table type is not supported
    */
   async getController(tableKey, refs) {
-    if (typeof tableKey !== "string" || tableKey.length === 0) {
-      throw new Error("TableKey must be a non-empty string.");
-    }
-    const tableExists = this.core.hasTable(tableKey);
-    if (!tableExists) {
-      throw new Error(`Table ${tableKey} does not exist.`);
+    const hasTable = await this.core.hasTable(tableKey);
+    if (!hasTable) {
+      throw new Error(`Db.getController: Table ${tableKey} does not exist.`);
     }
     const contentType = await this.core.contentType(tableKey);
-    if (!contentType) {
-      throw new Error(`Table ${tableKey} does not have a valid content type.`);
-    }
     return createController(contentType, this.core, tableKey, refs);
   }
   // ...........................................................................
   async _indexedControllers(route) {
-    if (!route.isValid) throw new Error(`Route ${route.flat} is not valid.`);
     const controllers = {};
-    for (let i = 0; i < route.segments.length; i++) {
-      const segment = route.segments[i];
+    const isolatedRoute = await this.isolatePropertyKeyFromRoute(route);
+    for (let i = 0; i < isolatedRoute.segments.length; i++) {
+      const segment = isolatedRoute.segments[i];
       const tableKey = segment.tableKey;
       const segmentRef = Route.segmentRef(segment);
       const base = segmentRef ? isTimeId(segmentRef) ? await this.getRefOfTimeId(tableKey, segmentRef) : segmentRef : null;
@@ -749,85 +2886,79 @@ ${JSON.stringify(errors, null, 2)}`);
   }
   // ...........................................................................
   /**
-   * Adds an edit protocol row to the edits table of a table
-   * @param table - The table the edit was made on
-   * @param editProtocolRow - The edit protocol row to add
-   * @throws {Error} If the edits table does not exist
+   * Adds an InsertHistory row to the InsertHistory table of a table
+   * @param table - The table the Insert was made on
+   * @param InsertHistoryRow - The InsertHistory row to add
+   * @throws {Error} If the InsertHistory table does not exist
    */
-  async _writeProtocol(table, editProtocolRow) {
-    const protocolTable = table + "Edits";
-    const hasTable = await this.core.hasTable(protocolTable);
-    if (!hasTable) {
-      throw new Error(`Table ${table} does not exist`);
-    }
+  async _writeInsertHistory(table, insertHistoryRow) {
+    const insertHistoryTable = table + "InsertHistory";
     await this.core.import({
-      [protocolTable]: {
-        _data: [editProtocolRow],
-        _type: "edits"
+      [insertHistoryTable]: {
+        _data: [insertHistoryRow],
+        _type: "insertHistory"
       }
     });
   }
   // ...........................................................................
   /**
-   * Get the edit protocol of a table
-   * @param table - The table to get the edit protocol for
-   * @throws {Error} If the edits table does not exist
+   * Get the InsertHistory of a table
+   * @param table - The table to get the InsertHistory for
+   * @throws {Error} If the InsertHistory table does not exist
    */
-  async getProtocol(table, options) {
-    const protocolTable = table + "Edits";
-    const hasTable = await this.core.hasTable(protocolTable);
+  async getInsertHistory(table, options) {
+    const insertHistoryTable = table + "InsertHistory";
+    const hasTable = await this.core.hasTable(insertHistoryTable);
     if (!hasTable) {
-      throw new Error(`Table ${table} does not exist`);
+      throw new Error(`Db.getInsertHistory: Table ${table} does not exist`);
     }
     if (options === void 0) {
       options = { sorted: false, ascending: true };
     }
     if (options.sorted) {
-      const dumpedTable = await this.core.dumpTable(protocolTable);
-      const tableData = dumpedTable[protocolTable]._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);
-        }
-      });
-      return { [protocolTable]: { _data: tableData, _type: "edits" } };
+      const dumpedTable = await this.core.dumpTable(insertHistoryTable);
+      const tableData = dumpedTable[insertHistoryTable]._data;
+      tableData.sort(
+        (a, b) => options.ascending ? a.timeId.localeCompare(b.timeId) : b.timeId.localeCompare(a.timeId)
+      );
+      return {
+        [insertHistoryTable]: { _data: tableData, _type: "insertHistory" }
+      };
     }
-    return this.core.dumpTable(protocolTable);
+    return this.core.dumpTable(insertHistoryTable);
   }
   // ...........................................................................
   /**
-   * Get a specific edit protocol row from a table
-   * @param table - The table to get the edit protocol row from
-   * @param ref - The reference of the edit protocol row to get
-   * @returns The edit protocol row or null if it does not exist
-   * @throws {Error} If the edits table does not exist
+   * Get a specific InsertHistory row from a table
+   * @param table - The table to get the InsertHistory row from
+   * @param ref - The reference of the InsertHistory row to get
+   * @returns The InsertHistory row or null if it does not exist
+   * @throws {Error} If the Inserts table does not exist
    */
-  async getProtocolRowsByRef(table, ref) {
-    const protocolTable = table + "Edits";
+  async getInsertHistoryRowsByRef(table, ref) {
+    const insertHistoryTable = table + "InsertHistory";
     const {
-      [protocolTable]: { _data: protocol }
-    } = await this.core.readRows(protocolTable, { [table + "Ref"]: ref });
-    return protocol || null;
+      [insertHistoryTable]: { _data: insertHistory }
+    } = await this.core.readRows(insertHistoryTable, { [table + "Ref"]: ref });
+    return insertHistory;
   }
   // ...........................................................................
   /**
-   * Get a specific edit protocol row from a table by its timeId
-   * @param table - The table to get the edit protocol row from
-   * @param timeId - The timeId of the edit protocol row to get
-   * @returns The edit protocol row or null if it does not exist
-   * @throws {Error} If the edits table does not exist
+   * Get a specific InsertHistory row from a table by its timeId
+   * @param table - The table to get the InsertHistory row from
+   * @param timeId - The timeId of the InsertHistory row to get
+   * @returns The InsertHistory row or null if it does not exist
+   * @throws {Error} If the Inserts table does not exist
    */
-  async getProtocolRowByTimeId(table, timeId2) {
-    const protocolTable = table + "Edits";
-    const { [protocolTable]: result } = await this.core.readRows(
-      protocolTable,
-      { timeId: timeId2 }
+  async getInsertHistoryRowByTimeId(table, timeId2) {
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        timeId: timeId2
+      }
     );
-    return result._data?.[0] || null;
+    return result._data?.[0];
   }
   // ...........................................................................
   /**
@@ -835,15 +2966,17 @@ ${JSON.stringify(errors, null, 2)}`);
    * @param table - The table to get the timeIds from
    * @param ref - The reference to get the timeIds for
    * @returns An array of timeIds
-   * @throws {Error} If the edits table does not exist
+   * @throws {Error} If the Inserts table does not exist
    */
   async getTimeIdsForRef(table, ref) {
-    const protocolTable = table + "Edits";
-    const { [protocolTable]: result } = await this.core.readRows(
-      protocolTable,
-      { [table + "Ref"]: ref }
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        [table + "Ref"]: ref
+      }
     );
-    return result._data?.map((r) => r.timeId) || [];
+    return result._data?.map((r) => r.timeId);
   }
   // ...........................................................................
   /**
@@ -851,24 +2984,75 @@ ${JSON.stringify(errors, null, 2)}`);
    * @param table - The table to get the ref from
    * @param timeId - The timeId to get the ref for
    * @returns The ref or null if it does not exist
-   * @throws {Error} If the edits table does not exist
+   * @throws {Error} If the Inserts table does not exist
    */
   async getRefOfTimeId(table, timeId2) {
-    const protocolTable = table + "Edits";
-    const { [protocolTable]: result } = await this.core.readRows(
-      protocolTable,
-      { timeId: timeId2 }
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        timeId: timeId2
+      }
     );
-    return result._data?.[0]?.[table + "Ref"] || null;
+    return result._data?.[0]?.[table + "Ref"];
   }
+  // ...........................................................................
   /**
-   * Example
-   * @returns A new Db instance for test purposes
+   * Isolates the property key from the last segment of a route if it is a property of a component
+   * @param route - The route to extract property key from
+   * @returns A route with extracted property key
    */
-  static example = async () => {
-    const io = new IoMem();
-    return new Db(io);
-  };
+  async isolatePropertyKeyFromRoute(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;
+  }
+  // ...........................................................................
+  /**
+   * Isolates a property from all components in an Rljson
+   * @param rljson - The Rljson to isolate the property from
+   * @param propertyKey - The property key to isolate
+   * @returns A new Rljson with only the isolated property
+   */
+  isolatePropertyFromComponents(rljson, propertyKey) {
+    const result = {};
+    for (const tableKey of Object.keys(rljson)) {
+      const table = rljson[tableKey];
+      const newData = table._data.map((row) => {
+        if (row.hasOwnProperty(propertyKey)) {
+          return {
+            [propertyKey]: row[propertyKey],
+            _hash: row._hash
+          };
+        } else {
+          return row;
+        }
+      });
+      result[tableKey] = {
+        _type: table._type,
+        _data: newData
+      };
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Get the current cache of the Db instance
+   */
+  get cache() {
+    return this._cache;
+  }
 }
 export {
   Db as RljsonDb