@rljson/db 0.0.3 → 0.0.6

package/dist/db.js

@@ -1,22 +1,644 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { equals, merge } from "@rljson/json";
+import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, validateInsert, isTimeId } from "@rljson/rljson";
+import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
 import { IoMem } from "@rljson/io";
-import { validate } from "@rljson/validate";
-// @license
-const _Core = class _Core {
+import { compileExpression } from "filtrex";
+class BaseController {
+  constructor(_core, _tableKey) {
+    this._core = _core;
+    this._tableKey = _tableKey;
+  }
+  // ...........................................................................
+  /**
+   * Retrieves the current state of the table.
+   * @returns A promise that resolves to the current state of the table.
+   */
+  async table() {
+    const rljson = await this._core.dumpTable(this._tableKey);
+    return rljson[this._tableKey];
+  }
+  // ...........................................................................
+  /**
+   * Fetches a specific entry from the table by its reference or by a partial match.
+   * @param where A string representing the reference of the entry to fetch, or 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 get(where, filter) {
+    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({});
+    }
+  }
+  // ...........................................................................
+  /**
+   * Fetches a specific entry from the table by its reference.
+   * @param hash A string representing the reference of the entry to fetch.
+   * @returns A promise that resolves to the entry matching the reference, or null if no entry is found.
+   */
+  async _getByHash(hash, filter) {
+    let result = {};
+    if (!filter || equals(filter, {})) {
+      result = await this._core.readRow(this._tableKey, hash);
+    } else {
+      result = await this._core.readRows(this._tableKey, {
+        _hash: hash,
+        ...filter
+      });
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Fetches entries from the table that match the specified criteria.
+   * @param where An object representing the criteria to 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 rows = await this._core.readRows(this._tableKey, {
+      ...where,
+      ...filter
+    });
+    return rows;
+  }
+}
+class CakeController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+  }
+  _table = null;
+  _baseLayers = {};
+  async init() {
+    if (this._tableKey.endsWith("Cake") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by CakeController.`
+      );
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    this._table = rljson[this._tableKey];
+    if (this._table._type !== "cakes") {
+      throw new Error(`Table ${this._tableKey} is not of type cakes.`);
+    }
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: baseCakes }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      if (baseCakes.length === 0) {
+        throw new Error(`Base cake ${this._refs.base} does not exist.`);
+      }
+      const baseCake = baseCakes[0];
+      this._baseLayers = rmhsh(baseCake.layers);
+    } else {
+      const cake = this._table._data[0];
+      this._refs = {
+        sliceIdsTable: cake.sliceIdsTable,
+        sliceIdsRow: cake.sliceIdsRow
+      };
+    }
+  }
+  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 insert(command, value, origin, refs) {
+    if (!command.startsWith("add")) {
+      throw new Error(`Command ${command} is not supported by CakeController.`);
+    }
+    const cake = {
+      layers: { ...this._baseLayers, ...value },
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [cake] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(cake)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return result;
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else if (typeof where === "object" && where !== null) {
+      return this._getByWhere(where, filter);
+    } else {
+      return Promise.resolve({});
+    }
+  }
+  filterRow(row, key, value) {
+    const cake = row;
+    for (const [layerKey, layerRef] of Object.entries(cake.layers)) {
+      if (layerKey === key && layerRef === value) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+class ComponentController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    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.`);
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    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 insert(command, value, origin, refs) {
+    if (!command.startsWith("add")) {
+      throw new Error(
+        `Command ${command} is not supported by ComponentController.`
+      );
+    }
+    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);
+    return {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(component)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+  }
+  // ...........................................................................
+  /**
+   * 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 {
+      [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;
+  }
+}
+class LayerController extends BaseController {
+  constructor(_core, _tableKey, _refs) {
+    super(_core, _tableKey);
+    this._core = _core;
+    this._tableKey = _tableKey;
+    this._refs = _refs;
+  }
+  async init() {
+    if (this._tableKey.endsWith("Layer") === false) {
+      throw new Error(
+        `Table ${this._tableKey} is not supported by LayerController.`
+      );
+    }
+    const rljson = await this._core.dumpTable(this._tableKey);
+    const table = rljson[this._tableKey];
+    if (table._type !== "layers") {
+      throw new Error(`Table ${this._tableKey} is not of type layers.`);
+    }
+    if (this._refs && this._refs.base) {
+      const {
+        [this._tableKey]: { _data: baseLayers }
+      } = await this._core.readRow(this._tableKey, this._refs.base);
+      if (baseLayers.length === 0) {
+        throw new Error(`Base layer ${this._refs.base} does not exist.`);
+      }
+      const baseLayer = baseLayers[0];
+      if (!this._refs.sliceIdsTable || !this._refs.sliceIdsRow || !this._refs.componentsTable) {
+        this._refs = {
+          sliceIdsTable: baseLayer.sliceIdsTable,
+          sliceIdsTableRow: baseLayer.sliceIdsTableRow,
+          componentsTable: baseLayer.componentsTable
+        };
+      }
+    } else {
+      const layer = table._data[0];
+      this._refs = {
+        sliceIdsTable: layer.sliceIdsTable,
+        sliceIdsTableRow: layer.sliceIdsTableRow,
+        componentsTable: layer.componentsTable
+      };
+    }
+  }
+  async insert(command, value, origin, refs) {
+    if (!command.startsWith("add") && !command.startsWith("remove")) {
+      throw new Error(
+        `Command ${command} is not supported by LayerController.`
+      );
+    }
+    const layer = command.startsWith("add") === true ? {
+      add: value,
+      ...refs || this._refs
+    } : {
+      add: {},
+      remove: value,
+      ...refs || this._refs
+    };
+    const rlJson = { [this._tableKey]: { _data: [layer] } };
+    await this._core.import(rlJson);
+    const result = {
+      //Ref to component
+      [this._tableKey + "Ref"]: hsh(layer)._hash,
+      //Data from edit
+      route: "",
+      origin,
+      //Unique id/timestamp
+      timeId: timeId()
+    };
+    return result;
+  }
+  async get(where, filter) {
+    if (typeof where === "string") {
+      return this._getByHash(where, filter);
+    } else {
+      return this._getByWhere(where, filter);
+    }
+  }
+  async getChildRefs(where, filter) {
+    const { [this._tableKey]: table } = await this.get(where, filter);
+    const childRefs = [];
+    for (const row of table._data) {
+      const layer = row;
+      for (const [sliceId, compRef] of Object.entries(layer.add)) {
+        if (sliceId.startsWith("_")) continue;
+        childRefs.push({
+          tableKey: layer.componentsTable,
+          ref: compRef
+        });
+      }
+    }
+    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 false;
+  }
+}
+const createController = async (type, core, tableKey, refs) => {
+  let ctrl;
+  switch (type) {
+    case "layers":
+      ctrl = new LayerController(core, tableKey, refs);
+      break;
+    case "components":
+      ctrl = new ComponentController(core, tableKey, refs);
+      break;
+    case "cakes":
+      ctrl = new CakeController(core, tableKey, refs);
+      break;
+    default:
+      throw new Error(`Controller for type ${type} is not implemented yet.`);
+  }
+  await ctrl.init();
+  return ctrl;
+};
+class Core {
   // ...........................................................................
   constructor(_io) {
     this._io = _io;
   }
+  static example = async () => {
+    return new Core(await IoMem.example());
+  };
   // ...........................................................................
+  /**
+   * Creates a table and an insertHistory for the table
+   * @param tableCfg TableCfg of table to create
+   */
+  async createTableWithInsertHistory(tableCfg) {
+    await this.createTable(tableCfg);
+    await this.createInsertHistory(tableCfg);
+  }
   /**
    * Creates a table
-   * @param name The name of the table.
-   * @param type The type of the table.
+   * @param tableCfg TableCfg of table to create
+   */
+  async createTable(tableCfg) {
+    return this._io.createOrExtendTable({ tableCfg });
+  }
+  /**
+   * Creates an insertHistory table for a given table
+   * @param tableCfg TableCfg of table
    */
-  async createTable(name, type) {
-    return this._io.createTable({ name, type });
+  async createInsertHistory(tableCfg) {
+    const cfg = createInsertHistoryTableCfg(tableCfg);
+    await this.createTable(cfg);
   }
   // ...........................................................................
   /**
@@ -30,17 +652,20 @@ const _Core = class _Core {
    * @returns a dump of a table.
    * @throws when table name does not exist
    */
-  dumpTable(name) {
-    return this._io.dumpTable({ name });
+  dumpTable(table) {
+    return this._io.dumpTable({ table });
   }
   // ...........................................................................
   /**
    * Imports data into the memory.
+   * @param data - The rljson data to import.
    * @throws {Error} If the data is invalid.
    */
   async import(data) {
-    const result = validate(data);
-    if (result.hasErrors) {
+    const validate = new Validate();
+    validate.addValidator(new BaseValidator());
+    const result = await validate.run(data);
+    if ((result.hasErrors || result.base && result.base.hasErrors) && !result.base.refsNotFound) {
       throw new Error(
         "The imported rljson data is not valid:\n" + JSON.stringify(result, null, 2)
       );
@@ -49,51 +674,1969 @@ const _Core = class _Core {
   }
   // ...........................................................................
   async tables() {
-    return this._io.tables();
+    return await this._io.dump();
   }
   // ...........................................................................
   async hasTable(table) {
-    const tables = await this._io.tables();
-    return tables.includes(table);
+    return await this._io.tableExists(table);
+  }
+  // ...........................................................................
+  async contentType(table) {
+    const t = await this._io.dumpTable({ table });
+    const contentType = t[table]?._type;
+    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.readRow({ table, rowHash });
+    return this._io.readRows({ table, where: { _hash: rowHash } });
   }
   // ...........................................................................
   readRows(table, where) {
     return this._io.readRows({ table, where });
   }
-};
-__publicField(_Core, "example", async () => {
-  return new _Core(IoMem.example());
-});
-let Core = _Core;
-// @license
-const _Db = class _Db {
+}
+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);
+  }
+  // ...........................................................................
   /**
-   * Constructor
-   * @param _io - The Io instance used to read and write data
+   * Returns unique routes from a list of routes
+   * @param routes - The list of routes
+   * @returns Unique routes
    */
-  constructor(_io) {
-    /**
-     * Core functionalities like importing data, setting and getting tables
-     */
-    __publicField(this, "core");
-    this._io = _io;
-    this.core = new Core(this._io);
+  static uniqueRoutes(routes) {
+    return Array.from(new Set(routes.map((r) => r.flat))).map(
+      (flat) => Route.fromFlat(flat)
+    );
+  }
+  // ...........................................................................
+  /**
+   * Returns a ColumnSelection from a list of route segments
+   * @param routeSegmentsList - A list of route segments
+   * @returns A ColumnSelection object
+   */
+  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);
+  }
+  // ...........................................................................
+  columns;
+  routes;
+  aliases;
+  routeHashes;
+  metadata(key) {
+    return this.columns.map((column) => column[key]);
+  }
+  // ...........................................................................
+  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))
+    );
+  }
+  // ...........................................................................
+  static calcHash(str) {
+    return Hash.default.calcHash(str);
+  }
+  route(aliasRouteOrHash) {
+    return this.column(aliasRouteOrHash).route;
+  }
+  // ...........................................................................
+  alias(aliasRouteOrHash) {
+    return this.column(aliasRouteOrHash).alias;
+  }
+  // ...........................................................................
+  columnIndex(hashAliasOrRoute, throwIfNotExisting = true) {
+    if (typeof hashAliasOrRoute === "number") {
+      return hashAliasOrRoute;
+    }
+    const str = Array.isArray(hashAliasOrRoute) ? hashAliasOrRoute.join("/") : hashAliasOrRoute;
+    const hashIndex = this.routeHashes.indexOf(str);
+    if (hashIndex >= 0) {
+      return hashIndex;
+    }
+    const aliasIndex = this.aliases.indexOf(str);
+    if (aliasIndex >= 0) {
+      return aliasIndex;
+    }
+    const routeIndex = this.routes.indexOf(str);
+    if (routeIndex < 0) {
+      if (throwIfNotExisting) {
+        throw new Error(`Unknown column alias or route: ${str}`);
+      }
+      return -1;
+    }
+    return routeIndex;
+  }
+  /***
+   * Returns the column config for a specific alias, route or hash.
+   */
+  column(aliasRouteOrHash) {
+    const index = this.columnIndex(aliasRouteOrHash);
+    return this.columns[index];
+  }
+  // ...........................................................................
+  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([
+      {
+        route: "carCake/carGeneralLayer/carGeneral/brand",
+        key: "brand",
+        alias: "brand",
+        titleShort: "Brand",
+        titleLong: "Car Brand",
+        type: "string"
+      },
+      {
+        route: "carCake/carGeneralLayer/carGeneral/type",
+        key: "type",
+        alias: "type",
+        titleShort: "Type",
+        titleLong: "Car Type",
+        type: "string"
+      },
+      {
+        route: "carCake/carGeneralLayer/carGeneral/isElectric",
+        key: "isElectric",
+        alias: "isElectric",
+        titleShort: "Is Electric",
+        titleLong: "This Car is Electric",
+        type: "boolean"
+      },
+      {
+        route: "carCake/carTechnicalLayer/carTechnical/transmission",
+        key: "transmission",
+        alias: "transmission",
+        titleShort: "Transmission",
+        titleLong: "Type of Transmission",
+        type: "string"
+      },
+      {
+        route: "carCake/carColorLayer/carColor/sides",
+        key: "sides",
+        alias: "sides",
+        titleShort: "Sides",
+        titleLong: "Car Sides Color",
+        type: "string"
+      }
+    ]);
+  }
+  // ...........................................................................
+  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;
 };
-/**
- * Example
- * @returns A new Db instance for test purposes
- */
-__publicField(_Db, "example", async () => {
-  const io = new IoMem();
-  return new _Db(io);
+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: ""
 });
-let Db = _Db;
+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 (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 view: There is a column filter for route "${route}", but the view does not have a column with this route.
+
+Available routes:
+${availableRoutes.map((a) => `- ${a}`).join("\n")}`
+        );
+      }
+    }
+  }
+}
+class Join {
+  constructor(baseRows, _baseColumnSelection) {
+    this._baseColumnSelection = _baseColumnSelection;
+    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._insertCakeObject(this.data);
+    const mergedCakeInsertObj = merge(...cakeInserts);
+    const route = mergedCakeInsertObj[this.cakeRoute.root.tableKey].route.flat;
+    const value = mergedCakeInsertObj[this.cakeRoute.root.tableKey].value;
+    const insert = {
+      command: "add",
+      route,
+      value
+    };
+    return insert;
+  }
+  // ...........................................................................
+  /**
+   * 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(this.componentRoutes.map((r) => r.upper().flat))
+    ).map((r) => Route.fromFlat(r));
+  }
+  // ...........................................................................
+  /**
+   * Returns the cake route of the join
+   */
+  get cakeRoute() {
+    const cakeRoute = Array.from(
+      new Set(this.layerRoutes.map((r) => r.upper().flat))
+    ).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
+   */
+  _insertCakeObject(rows) {
+    const cakeInsertObjects = [];
+    const cakeRoute = this.cakeRoute;
+    for (const [sliceId, row] of Object.entries(rows)) {
+      const layerInsertObjectList = this._insertLayerObjects(
+        sliceId,
+        row.columns
+      );
+      for (const layerInsertObject of layerInsertObjectList) {
+        const cakeInsertObject = {};
+        for (const [layerRoute, layerInsertObj] of Object.entries(
+          layerInsertObject
+        )) {
+          cakeInsertObject[cakeRoute.root.tableKey] = {
+            route: layerInsertObj.route,
+            value: {
+              [layerRoute]: layerInsertObj.value
+            }
+          };
+        }
+        cakeInsertObjects.push(cakeInsertObject);
+      }
+    }
+    return cakeInsertObjects;
+  }
+  // ...........................................................................
+  /**
+   * Wraps component insert objects into layer insert objects
+   * @param sliceId - The slice id
+   * @param componentInsertObjects - The component insert objects
+   * @returns
+   */
+  _insertLayerObjects(sliceId, insertRow) {
+    const layerRoutes = this.layerRoutes;
+    const layerInsertObjects = [];
+    const insertComponentObjects = this._insertComponentObjects(
+      sliceId,
+      insertRow
+    );
+    for (const layerRoute of layerRoutes) {
+      for (const [compRouteFlat, compInsertObj] of Object.entries(
+        insertComponentObjects
+      )) {
+        const compRoute = Route.fromFlat(compRouteFlat);
+        if (layerRoute.includes(compRoute)) {
+          const layerInsertObj = {};
+          layerInsertObj[layerRoute.root.tableKey] = {
+            route: compInsertObj.route,
+            value: {
+              [sliceId]: compInsertObj.value
+            }
+          };
+          layerInsertObjects.push(layerInsertObj);
+        } else {
+          continue;
+        }
+      }
+    }
+    return layerInsertObjects;
+  }
+  // ...........................................................................
+  /**
+   * Merges columns into component insert objects
+   * @param insertColumns - The columns to merge
+   * @returns
+   */
+  _insertComponentObjects(sliceId, insertColumns) {
+    const componentRoutes = this.componentRoutes;
+    const columns = this._mergeInsertRow(sliceId, insertColumns);
+    const result = {};
+    for (const compRoute of componentRoutes) {
+      let compChanged = false;
+      const compInsert = {};
+      for (const c of columns) {
+        if (compRoute.includes(c.route)) {
+          if (c.insert !== null) {
+            compChanged = true;
+            compInsert[c.route.propertyKey] = c.insert;
+          } else {
+            compInsert[c.route.propertyKey] = c.value;
+          }
+        } else {
+          continue;
+        }
+      }
+      result[compRoute.flat] = {
+        route: compRoute,
+        value: compChanged ? compInsert : null
+      };
+    }
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * Merges the insert values into the base row
+   * @param sliceId - The slice id
+   * @param insertRow - The insert row
+   * @returns The merged join row
+   */
+  _mergeInsertRow(sliceId, insertRow) {
+    const baseColumns = this._base[sliceId].columns;
+    const mergedRow = [];
+    for (const baseCol of baseColumns) {
+      const insertCol = insertRow.find(
+        (col) => col.route.equalsWithoutRefs(baseCol.route)
+      );
+      if (insertCol) {
+        mergedRow.push({
+          route: baseCol.route,
+          value: baseCol.value,
+          insert: insertCol.insert
+        });
+      } else {
+        mergedRow.push(baseCol);
+      }
+    }
+    return mergedRow;
+  }
+  // ...........................................................................
+  /**
+   * Hashes the given join rows. If insert value is present, it is used for hashing.
+   *
+   * @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;
+    }
+  }
+  async _get(route, where, controllers, segmentLevel) {
+    if (segmentLevel === void 0) segmentLevel = 0;
+    const segment = route.segments[segmentLevel];
+    const segmentIsDeepest = segmentLevel === route.segments.length - 1;
+    const segmentController = controllers[segment.tableKey];
+    const segmentRef = await this._getReferenceOfRouteSegment(segment);
+    let segmentWhere = typeof where === "object" ? where : { _hash: where };
+    segmentWhere = segment.tableKey in segmentWhere ? segmentWhere[segment.tableKey] : segmentWhere;
+    segmentWhere = segmentRef ? { ...segmentWhere, ...{ _hash: segmentRef } } : segmentWhere;
+    const childSegmentLevel = segmentLevel + 1;
+    const childSegment = route.segments[childSegmentLevel];
+    const segmentWhereWithoutChildWhere = { ...segmentWhere };
+    if (!segmentIsDeepest && childSegment.tableKey in segmentWhere)
+      delete segmentWhereWithoutChildWhere[childSegment.tableKey];
+    let parent = await segmentController.get(segmentWhereWithoutChildWhere, {});
+    if (segmentIsDeepest && route.hasPropertyKey) {
+      parent = this.isolatePropertyFromComponents(parent, route.propertyKey);
+    }
+    const children = [];
+    const filteredParentRows = /* @__PURE__ */ new Map();
+    if (!segmentIsDeepest) {
+      const childRefs = await segmentController.getChildRefs(
+        segmentWhereWithoutChildWhere,
+        {}
+      );
+      for (const { tableKey, columnKey, ref } of childRefs) {
+        if (tableKey !== childSegment.tableKey) continue;
+        const child = await this._get(
+          route,
+          { ...segmentWhere, ...{ _hash: ref } },
+          controllers,
+          childSegmentLevel
+        );
+        children.push(child);
+        for (const childObjs of child[tableKey]._data) {
+          const childRef = childObjs["_hash"];
+          for (const row of parent[segment.tableKey]._data) {
+            if (filteredParentRows.has(row["_hash"]))
+              continue;
+            const includesChild = segmentController.filterRow(
+              row,
+              columnKey ?? tableKey,
+              childRef
+            );
+            if (includesChild) {
+              filteredParentRows.set(
+                row["_hash"],
+                row
+              );
+            }
+          }
+        }
+      }
+      const parentWithFilteredRows = {
+        [segment.tableKey]: {
+          ...parent[segment.tableKey],
+          ...{
+            _data: Array.from(filteredParentRows.values())
+          }
+        }
+      };
+      return merge(parentWithFilteredRows, ...children);
+    }
+    return parent;
+  }
+  // ...........................................................................
+  /**
+   * 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 mergedSliceIds = /* @__PURE__ */ new Set();
+    for (const layer of layers.values()) {
+      const sliceIdsTable = layer.sliceIdsTable;
+      const sliceIdsTableRow = layer.sliceIdsTableRow;
+      const {
+        [sliceIdsTable]: { _data: sliceIds }
+      } = await this.core.readRows(sliceIdsTable, { _hash: sliceIdsTableRow });
+      for (const sid of sliceIds) {
+        for (const s of sid.add) {
+          mergedSliceIds.add(s);
+        }
+      }
+    }
+    const columnCfgs = /* @__PURE__ */ new Map();
+    const columnInfos = /* @__PURE__ */ new Map();
+    for (const [layerKey, layer] of layers.entries()) {
+      const componentKey = layer.componentsTable;
+      const { columns: colCfgs } = await this.core.tableCfg(componentKey);
+      const columnCfg = [];
+      const columnInfo = [];
+      for (let i = 0; i < colCfgs.length; i++) {
+        if (colCfgs[i].key === "_hash") continue;
+        const colCfg = colCfgs[i];
+        columnCfg.push(colCfg);
+        columnInfo.push({
+          ...colCfg,
+          alias: `${colCfg.key}`,
+          route: Route.fromFlat(
+            `/${cakeKey}/${layerKey}/${componentKey}/${colCfg.key}`
+          ).flat.slice(1),
+          titleShort: colCfg.key,
+          titleLong: colCfg.key
+        });
+      }
+      columnInfos.set(componentKey, columnInfo);
+      columnCfgs.set(componentKey, columnCfg);
+    }
+    const rowMap = /* @__PURE__ */ new Map();
+    for (const sliceId of mergedSliceIds) {
+      let sliceIdRow = [];
+      for (const [layerKey, layer] of layers.entries()) {
+        const layerRef = layer._hash;
+        const componentKey = layer.componentsTable;
+        const componentRef = layer.add[sliceId];
+        const componentsTable = data[componentKey];
+        const component = componentsTable._data.find(
+          (r) => r._hash === componentRef
+        );
+        const colCfgs = columnCfgs.get(componentKey);
+        const joinColumns = [];
+        for (let i = 0; i < colCfgs.length; i++) {
+          const columnCfg = colCfgs[i];
+          joinColumns.push({
+            route: Route.fromFlat(
+              `${cakeKey}@${cakeRef}/${layerKey}@${layerRef}/${componentKey}@${componentRef}/${columnCfg.key}`
+            ).toRouteWithProperty(),
+            value: component[columnCfg.key] ?? null,
+            insert: null
+          });
+        }
+        sliceIdRow = [...sliceIdRow, ...joinColumns];
+      }
+      rowMap.set(sliceId, sliceIdRow);
+    }
+    const joinRows = {};
+    for (const [sliceId, joinColumns] of rowMap.entries()) {
+      Object.assign(joinRows, {
+        [sliceId]: joinColumns
+      });
+    }
+    const joinColumnInfos = Array.from(columnInfos.values()).flat();
+    const joinColumnSelection = new ColumnSelection(joinColumnInfos);
+    return new Join(joinRows, joinColumnSelection).select(columnSelection);
+  }
+  // ...........................................................................
+  /**
+   * Fetches data for the given ColumnSelection
+   * @param columnSelection - The ColumnSelection to fetch data for
+   */
+  async _getBaseDataForColumnSelection(columnSelection) {
+    const uniqueComponentRoutes = /* @__PURE__ */ new Set();
+    for (const colInfo of columnSelection.columns) {
+      const route = Route.fromFlat(colInfo.route).toRouteWithProperty();
+      uniqueComponentRoutes.add(route.toRouteWithoutProperty().flat);
+    }
+    const data = {};
+    for (const compRouteFlat of uniqueComponentRoutes) {
+      const uniqueComponentRoute = Route.fromFlat(compRouteFlat);
+      const componentData = await this.get(uniqueComponentRoute, {});
+      Object.assign(data, componentData);
+    }
+    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 result;
+    let tableKey;
+    const segment = route.segment(0);
+    tableKey = segment.tableKey;
+    let previous = [];
+    if (Route.segmentHasRef(segment)) {
+      const routeRef = Route.segmentRef(segment);
+      if (Route.segmentHasInsertHistoryRef(segment)) {
+        previous = [...previous, routeRef];
+      }
+      if (Route.segmentHasDefaultRef(segment)) {
+        const timeIds = await this.getTimeIdsForRef(
+          tableKey,
+          Route.segmentRef(segment)
+        );
+        previous = [...previous, ...timeIds];
+      }
+    }
+    if (!route.isRoot) {
+      const childRoute = route.deeper(1);
+      const childKeys = this._childKeys(insert.value);
+      const childRefs = {};
+      for (const k of childKeys) {
+        const childValue = insert.value[k];
+        const childInsert = { ...insert, value: childValue };
+        const childResult = await this._insert(childInsert, childRoute, runFns);
+        const childRefKey = childRoute.top.tableKey + "Ref";
+        const childRef = childResult[childRefKey];
+        childRefs[k] = childRef;
+      }
+      const runFn = runFns[tableKey];
+      result = {
+        ...await runFn(
+          insert.command,
+          {
+            ...insert.value,
+            ...childRefs
+          },
+          insert.origin
+        ),
+        previous
+      };
+    } else {
+      tableKey = route.root.tableKey;
+      const runFn = runFns[tableKey];
+      result = {
+        ...await runFn(insert.command, insert.value, insert.origin),
+        previous
+      };
+    }
+    result.route = insert.route;
+    await this._writeInsertHistory(tableKey, result);
+    if (!options?.skipNotification)
+      this.notify.notify(Route.fromFlat(insert.route), result);
+    return result;
+  }
+  // ...........................................................................
+  /**
+   * 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 Insert is made
+   */
+  registerObserver(route, callback) {
+    this.notify.register(route, callback);
+  }
+  // ...........................................................................
+  /**
+   * Unregisters a callback from the given route
+   * @param route - The route to unregister the callback from
+   * @param callback - The callback to be unregistered
+   */
+  unregisterObserver(route, callback) {
+    this.notify.unregister(route, callback);
+  }
+  // ...........................................................................
+  /**
+   * Resolves an Insert by returning the run functions of all controllers involved in the Insert's route
+   * @param Insert - The Insert to resolve
+   * @returns A record of controller run functions, keyed by table name
+   * @throws {Error} If the route is not valid or if any controller cannot be created
+   */
+  async _resolveInsert(Insert2) {
+    const controllers = await this._indexedControllers(
+      Route.fromFlat(Insert2.route)
+    );
+    const runFns = {};
+    for (const tableKey of Object.keys(controllers)) {
+      runFns[tableKey] = controllers[tableKey].insert.bind(
+        controllers[tableKey]
+      );
+    }
+    return runFns;
+  }
+  // ...........................................................................
+  /**
+   * Returns the keys of child refs in a value based on a route
+   * @param value - The value to check
+   * @returns An array of keys of child refs in the value
+   */
+  _childKeys(value) {
+    const keys = Object.keys(value);
+    const childKeys = [];
+    for (const k of keys) {
+      if (typeof value[k] !== "object") continue;
+      childKeys.push(k);
+    }
+    return childKeys;
+  }
+  // ...........................................................................
+  /**
+   * Get a controller for a specific table
+   * @param tableKey - The key of the table to get the controller for
+   * @param refs - Optional references required by some controllers
+   * @returns A controller for the specified table
+   * @throws {Error} If the table does not exist or if the table type is not supported
+   */
+  async getController(tableKey, refs) {
+    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);
+    return createController(contentType, this.core, tableKey, refs);
+  }
+  // ...........................................................................
+  async _indexedControllers(route) {
+    const controllers = {};
+    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;
+      controllers[tableKey] ??= await this.getController(
+        tableKey,
+        base ? { base } : void 0
+      );
+    }
+    return controllers;
+  }
+  // ...........................................................................
+  /**
+   * 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 _writeInsertHistory(table, insertHistoryRow) {
+    const insertHistoryTable = table + "InsertHistory";
+    await this.core.import({
+      [insertHistoryTable]: {
+        _data: [insertHistoryRow],
+        _type: "insertHistory"
+      }
+    });
+  }
+  // ...........................................................................
+  /**
+   * 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 getInsertHistory(table, options) {
+    const insertHistoryTable = table + "InsertHistory";
+    const hasTable = await this.core.hasTable(insertHistoryTable);
+    if (!hasTable) {
+      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(insertHistoryTable);
+      const tableData = dumpedTable[insertHistoryTable]._data;
+      tableData.sort((a, b) => {
+        const aTime = a.timeId.split(":")[1];
+        const bTime = b.timeId.split(":")[1];
+        if (options.ascending) {
+          return aTime.localeCompare(bTime);
+        } else {
+          return bTime.localeCompare(aTime);
+        }
+      });
+      return {
+        [insertHistoryTable]: { _data: tableData, _type: "insertHistory" }
+      };
+    }
+    return this.core.dumpTable(insertHistoryTable);
+  }
+  // ...........................................................................
+  /**
+   * 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 getInsertHistoryRowsByRef(table, ref) {
+    const insertHistoryTable = table + "InsertHistory";
+    const {
+      [insertHistoryTable]: { _data: insertHistory }
+    } = await this.core.readRows(insertHistoryTable, { [table + "Ref"]: ref });
+    return insertHistory;
+  }
+  // ...........................................................................
+  /**
+   * 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 getInsertHistoryRowByTimeId(table, timeId2) {
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        timeId: timeId2
+      }
+    );
+    return result._data?.[0];
+  }
+  // ...........................................................................
+  /**
+   * Get all timeIds for a specific ref in a table
+   * @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 Inserts table does not exist
+   */
+  async getTimeIdsForRef(table, ref) {
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        [table + "Ref"]: ref
+      }
+    );
+    return result._data?.map((r) => r.timeId);
+  }
+  // ...........................................................................
+  /**
+   * Get the ref for a specific timeId in a table
+   * @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 Inserts table does not exist
+   */
+  async getRefOfTimeId(table, timeId2) {
+    const insertHistoryTable = table + "InsertHistory";
+    const { [insertHistoryTable]: result } = await this.core.readRows(
+      insertHistoryTable,
+      {
+        timeId: timeId2
+      }
+    );
+    return result._data?.[0]?.[table + "Ref"];
+  }
+  // ...........................................................................
+  /**
+   * 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
+   */
+  async isolatePropertyKeyFromRoute(route) {
+    const lastSegment = route.segments[route.segments.length - 1];
+    const tableKey = lastSegment.tableKey;
+    const tableExists = await this._io.tableExists(tableKey);
+    if (!Route.segmentHasRef(lastSegment) && !tableExists) {
+      const result = route.upper();
+      result.propertyKey = lastSegment.tableKey;
+      return result;
+    }
+    return route;
+  }
+  // ...........................................................................
+  /**
+   * 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
 };