@rljson/db 0.0.6 → 0.0.7

package/dist/db.d.ts

@@ -1,6 +1,6 @@
 import { Io } from '@rljson/io';
 import { Json } from '@rljson/json';
-import { Insert, InsertHistoryRow, InsertHistoryTimeId, Ref, Rljson, Route } from '@rljson/rljson';
+import { Insert, InsertHistoryRow, InsertHistoryTimeId, Ref, Rljson, Route, TableKey } from '@rljson/rljson';
 import { Controller, ControllerRefs } from './controller/controller.ts';
 import { Core } from './core.ts';
 import { Join } from './join/join.ts';
@@ -33,7 +33,21 @@ export declare class Db {
      * @throws {Error} If the route is not valid or if any controller cannot be created
      */
     get(route: Route, where: string | Json): Promise<Rljson>;
-    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any>>, segmentLevel?: number): Promise<Rljson>;
+    /**
+     * 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
+     */
+    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any>>, filter?: Array<{
+        tableKey: TableKey;
+        columnKey?: string;
+        ref: Ref;
+    }>): Promise<Rljson>;
     /**
      * Get the reference (hash) of a route segment, considering default refs and insertHistory refs
      * @param segment - The route segment to get the reference for
@@ -45,6 +59,15 @@ export declare class Db {
      * @param rljson - The Rljson to join data for
      */
     join(columnSelection: ColumnSelection, cakeKey: string, cakeRef: Ref): Promise<Join>;
+    private _resolveComponentProperties;
+    /**
+     * 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
+     */
+    private _resolveComponent;
     /**
      * Fetches data for the given ColumnSelection
      * @param columnSelection - The ColumnSelection to fetch data for
@@ -58,7 +81,8 @@ export declare class Db {
      */
     insert(insert: Insert<any>, options?: {
         skipNotification?: boolean;
-    }): Promise<InsertHistoryRow<any>>;
+        skipHistory?: boolean;
+    }): Promise<InsertHistoryRow<any>[]>;
     /**
      * Recursively runs controllers based on the route of the Insert
      * @param insert - The Insert to run

package/dist/db.js

@@ -1,5 +1,6 @@
 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 { compileExpression } from "filtrex";
@@ -87,7 +88,7 @@ class CakeController extends BaseController {
     if (this._table._type !== "cakes") {
       throw new Error(`Table ${this._tableKey} is not of type cakes.`);
     }
-    if (this._refs && this._refs.base) {
+    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);
@@ -102,6 +103,7 @@ class CakeController extends BaseController {
         sliceIdsTable: cake.sliceIdsTable,
         sliceIdsRow: cake.sliceIdsRow
       };
+      this._baseLayers = rmhsh(cake.layers);
     }
   }
   async getChildRefs(where, filter) {
@@ -126,8 +128,20 @@ class CakeController extends BaseController {
     if (!command.startsWith("add")) {
       throw new Error(`Command ${command} is not supported by CakeController.`);
     }
+    if (this._refs?.base) delete this._refs.base;
+    const normalizedValue = {};
+    for (const [layerTable, layerRef] of Object.entries(
+      value
+    )) {
+      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] } };
@@ -141,7 +155,7 @@ class CakeController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
@@ -196,18 +210,49 @@ 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);
-    return {
-      //Ref to component
-      [this._tableKey + "Ref"]: hsh(component)._hash,
-      //Data from edit
-      route: "",
-      origin,
-      //Unique id/timestamp
-      timeId: timeId()
-    };
+    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;
   }
   // ...........................................................................
   /**
@@ -536,12 +581,23 @@ class LayerController extends BaseController {
         `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] } };
@@ -555,7 +611,7 @@ class LayerController extends BaseController {
       //Unique id/timestamp
       timeId: timeId()
     };
-    return result;
+    return [result];
   }
   async get(where, filter) {
     if (typeof where === "string") {
@@ -975,44 +1031,134 @@ class ColumnSelection {
   static exampleCarsColumnSelection() {
     return new ColumnSelection([
       {
-        route: "carCake/carGeneralLayer/carGeneral/brand",
         key: "brand",
+        route: "carCake/carGeneralLayer/carGeneral/brand",
         alias: "brand",
-        titleShort: "Brand",
         titleLong: "Car Brand",
-        type: "string"
+        titleShort: "Brand",
+        type: "string",
+        _hash: ""
       },
       {
-        route: "carCake/carGeneralLayer/carGeneral/type",
         key: "type",
+        route: "carCake/carGeneralLayer/carGeneral/type",
         alias: "type",
-        titleShort: "Type",
         titleLong: "Car Type",
-        type: "string"
+        titleShort: "Type",
+        type: "string",
+        _hash: ""
+      },
+      {
+        key: "serviceIntervals",
+        route: "carCake/carGeneralLayer/carGeneral/serviceIntervals",
+        alias: "serviceIntervals",
+        titleLong: "Car Service Intervals",
+        titleShort: "Service Intervals",
+        type: "jsonValue",
+        _hash: ""
       },
       {
-        route: "carCake/carGeneralLayer/carGeneral/isElectric",
         key: "isElectric",
+        route: "carCake/carGeneralLayer/carGeneral/isElectric",
         alias: "isElectric",
-        titleShort: "Is Electric",
-        titleLong: "This Car is Electric",
-        type: "boolean"
+        titleLong: "Is Electric Car",
+        titleShort: "Electric",
+        type: "boolean",
+        _hash: ""
       },
       {
-        route: "carCake/carTechnicalLayer/carTechnical/transmission",
-        key: "transmission",
-        alias: "transmission",
-        titleShort: "Transmission",
-        titleLong: "Type of Transmission",
-        type: "string"
+        key: "carDimensions/height",
+        route: "carCake/carTechnicalLayer/carTechnical/carDimensions/height",
+        alias: "height",
+        titleLong: "Car Height",
+        titleShort: "Height",
+        type: "number",
+        _hash: ""
       },
       {
-        route: "carCake/carColorLayer/carColor/sides",
-        key: "sides",
-        alias: "sides",
-        titleShort: "Sides",
-        titleLong: "Car Sides Color",
-        type: "string"
+        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: ""
       }
     ]);
   }
@@ -1493,8 +1639,25 @@ class RowFilterProcessor {
     }
     for (const i of remainingIndices) {
       const cellValue = join.value(i, columnIndex);
-      if (filter.matches(cellValue)) {
-        result.push(i);
+      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;
@@ -1545,7 +1708,7 @@ class RowFilterProcessor {
       const route = item.route;
       if (availableRoutes.includes(route) === false) {
         throw new Error(
-          `RowFilterProcessor: Error while applying filter to view: There is a column filter for route "${route}", but the view does not have a column with this route.
+          `RowFilterProcessor: Error while applying filter to join: There is a column filter for route "${route}", but the join does not have a column with this route.
 
 Available routes:
 ${availableRoutes.map((a) => `- ${a}`).join("\n")}`
@@ -1555,8 +1718,9 @@ ${availableRoutes.map((a) => `- ${a}`).join("\n")}`
   }
 }
 class Join {
-  constructor(baseRows, _baseColumnSelection) {
+  constructor(baseRows, _baseColumnSelection, _objectMap) {
     this._baseColumnSelection = _baseColumnSelection;
+    this._objectMap = _objectMap;
     this._base = this._hashedRows(baseRows);
   }
   _base = {};
@@ -1686,16 +1850,30 @@ class Join {
    * Returns insert Object of the join
    */
   insert() {
-    const cakeInserts = this._insertCakeObject(this.data);
-    const mergedCakeInsertObj = merge(...cakeInserts);
-    const route = mergedCakeInsertObj[this.cakeRoute.root.tableKey].route.flat;
-    const value = mergedCakeInsertObj[this.cakeRoute.root.tableKey].value;
-    const insert = {
-      command: "add",
-      route,
-      value
-    };
-    return insert;
+    const 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;
   }
   // ...........................................................................
   /**
@@ -1739,7 +1917,12 @@ class Join {
    */
   get layerRoutes() {
     return Array.from(
-      new Set(this.componentRoutes.map((r) => r.upper().flat))
+      new Set(
+        Object.values(this.columnSelection.columns).map((c) => [
+          Route.fromFlat(c.route).top,
+          Route.fromFlat(c.route).deeper(1).top
+        ]).map((segments) => new Route(segments).flat)
+      )
     ).map((r) => Route.fromFlat(r));
   }
   // ...........................................................................
@@ -1748,7 +1931,11 @@ class Join {
    */
   get cakeRoute() {
     const cakeRoute = Array.from(
-      new Set(this.layerRoutes.map((r) => r.upper().flat))
+      new Set(
+        Object.values(this.columnSelection.columns).map(
+          (c) => Route.fromFlat(c.route).top.tableKey
+        )
+      )
     ).map((r) => Route.fromFlat(r));
     if (cakeRoute.length !== 1) {
       throw new Error(
@@ -1851,7 +2038,7 @@ class Join {
    * @param rows - The join rows
    * @returns The cake insert objects
    */
-  _insertCakeObject(rows) {
+  _insertCakeObjects(rows) {
     const cakeInsertObjects = [];
     const cakeRoute = this.cakeRoute;
     for (const [sliceId, row] of Object.entries(rows)) {
@@ -1894,13 +2081,14 @@ class Join {
       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: compInsertObj.route,
+            route: Route.fromFlat(compRouteFlat),
             value: {
-              [sliceId]: compInsertObj.value
+              [sliceId]: compInsertObj
             }
           };
           layerInsertObjects.push(layerInsertObj);
@@ -1918,28 +2106,60 @@ class Join {
    * @returns
    */
   _insertComponentObjects(sliceId, insertColumns) {
-    const componentRoutes = this.componentRoutes;
     const columns = this._mergeInsertRow(sliceId, insertColumns);
+    return this._denormalizeComponentInserts(columns, this._objectMap || {});
+  }
+  _denormalizeComponentInserts(columns, objectMap, refTableKey) {
     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;
+    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
+          }
+        };
       }
-      result[compRoute.flat] = {
-        route: compRoute,
-        value: compChanged ? compInsert : null
-      };
     }
     return result;
   }
@@ -2097,70 +2317,114 @@ class Db {
       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,
-        {}
+  // ...........................................................................
+  /**
+   * 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
       );
-      for (const { tableKey, columnKey, ref } of childRefs) {
-        if (tableKey !== childSegment.tableKey) continue;
-        const child = await this._get(
-          route,
-          { ...segmentWhere, ...{ _hash: ref } },
-          controllers,
-          childSegmentLevel
+      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
         );
-        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
-              );
+        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 parentWithFilteredRows = {
-        [segment.tableKey]: {
-          ...parent[segment.tableKey],
-          ...{
-            _data: Array.from(filteredParentRows.values())
+    }
+    const nodeChildren = merge(...nodeChildrenArray);
+    if (childrenThroughProperty) {
+      const matchedNodeRows = Array.from(nodeRowsMatchingChildrenRefs.values());
+      return {
+        ...node,
+        ...{
+          [nodeTableKey]: {
+            _data: matchedNodeRows,
+            _type: nodeType,
+            _hash: nodeHash
           }
-        }
+        },
+        ...nodeChildren
       };
-      return merge(parentWithFilteredRows, ...children);
     }
-    return parent;
+    return { ...node, ...nodeChildren };
   }
   // ...........................................................................
   /**
@@ -2204,6 +2468,11 @@ class Db {
       );
       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;
@@ -2219,52 +2488,59 @@ class Db {
     }
     const columnCfgs = /* @__PURE__ */ new Map();
     const columnInfos = /* @__PURE__ */ new Map();
+    let objectMap = {};
     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 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) {
-      let sliceIdRow = [];
+      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 component = componentsTable._data.find(
+        const rowComponentProperties = componentsTable._data.find(
           (r) => r._hash === componentRef
         );
-        const colCfgs = columnCfgs.get(componentKey);
+        const resolvedProperties = this._resolveComponentProperties(
+          rowComponentProperties,
+          objectMap,
+          data
+        );
         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
-          });
+        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 = [...sliceIdRow, ...joinColumns];
+        sliceIdRow.push(...joinColumns);
       }
       rowMap.set(sliceId, sliceIdRow);
     }
@@ -2274,9 +2550,111 @@ class Db {
         [sliceId]: joinColumns
       });
     }
-    const joinColumnInfos = Array.from(columnInfos.values()).flat();
-    const joinColumnSelection = new ColumnSelection(joinColumnInfos);
-    return new Join(joinRows, joinColumnSelection).select(columnSelection);
+    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 };
   }
   // ...........................................................................
   /**
@@ -2286,8 +2664,13 @@ class Db {
   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 componentRoute = Route.fromFlat(colInfo.route);
+      const isolatedComponentRoute = await this.isolatePropertyKeyFromRoute(
+        componentRoute
+      );
+      uniqueComponentRoutes.add(
+        isolatedComponentRoute.toRouteWithoutProperty().flat
+      );
     }
     const data = {};
     for (const compRouteFlat of uniqueComponentRoutes) {
@@ -2326,7 +2709,7 @@ ${JSON.stringify(errors, null, 2)}`
    * @throws {Error} If the route is not valid or if any controller cannot be created
    */
   async _insert(insert, route, runFns, options) {
-    let result;
+    let results;
     let tableKey;
     const segment = route.segment(0);
     tableKey = segment.tableKey;
@@ -2351,36 +2734,63 @@ ${JSON.stringify(errors, null, 2)}`
       for (const k of childKeys) {
         const childValue = insert.value[k];
         const childInsert = { ...insert, value: childValue };
-        const childResult = await this._insert(childInsert, childRoute, runFns);
+        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(
+      results = [
+        ...(await runFn(
           insert.command,
           {
             ...insert.value,
             ...childRefs
           },
           insert.origin
-        ),
-        previous
-      };
+        )).map((r) => ({ ...r, ...{ previous } }))
+      ];
     } else {
       tableKey = route.root.tableKey;
       const runFn = runFns[tableKey];
-      result = {
-        ...await runFn(insert.command, insert.value, insert.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 = insert.route;
-    await this._writeInsertHistory(tableKey, result);
-    if (!options?.skipNotification)
-      this.notify.notify(Route.fromFlat(insert.route), result);
-    return result;
+    for (const result of results) {
+      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;
   }
   // ...........................................................................
   /**
@@ -2411,6 +2821,14 @@ ${JSON.stringify(errors, null, 2)}`
     const controllers = await this._indexedControllers(
       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].insert.bind(
@@ -2500,15 +2918,9 @@ ${JSON.stringify(errors, null, 2)}`
     if (options.sorted) {
       const dumpedTable = await this.core.dumpTable(insertHistoryTable);
       const tableData = dumpedTable[insertHistoryTable]._data;
-      tableData.sort((a, b) => {
-        const aTime = a.timeId.split(":")[1];
-        const bTime = b.timeId.split(":")[1];
-        if (options.ascending) {
-          return aTime.localeCompare(bTime);
-        } else {
-          return bTime.localeCompare(aTime);
-        }
-      });
+      tableData.sort(
+        (a, b) => options.ascending ? a.timeId.localeCompare(b.timeId) : b.timeId.localeCompare(a.timeId)
+      );
       return {
         [insertHistoryTable]: { _data: tableData, _type: "insertHistory" }
       };
@@ -2591,15 +3003,20 @@ ${JSON.stringify(errors, null, 2)}`
    * @returns A route with extracted property key
    */
   async isolatePropertyKeyFromRoute(route) {
-    const lastSegment = route.segments[route.segments.length - 1];
-    const tableKey = lastSegment.tableKey;
-    const tableExists = await this._io.tableExists(tableKey);
-    if (!Route.segmentHasRef(lastSegment) && !tableExists) {
-      const result = route.upper();
-      result.propertyKey = lastSegment.tableKey;
-      return result;
-    }
-    return route;
+    const segmentLength = route.segments.length;
+    let propertyKey = "";
+    let result = route;
+    for (let i = segmentLength; i > 0; i--) {
+      const segment = route.segments[i - 1];
+      const tableKey = segment.tableKey;
+      const tableExists = await this._io.tableExists(tableKey);
+      if (!tableExists) {
+        propertyKey = propertyKey.length > 0 ? segment.tableKey + "/" + propertyKey : segment.tableKey;
+        result = result.upper();
+        result.propertyKey = propertyKey;
+      }
+    }
+    return result;
   }
   // ...........................................................................
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/db",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "A high level interface to read and write RLJSON data from and into a database",
   "homepage": "https://github.com/rljson/db",
   "bugs": "https://github.com/rljson/db/issues",
@@ -20,31 +20,31 @@
   ],
   "type": "module",
   "devDependencies": {
-    "@types/node": "^24.10.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.3",
-    "@typescript-eslint/parser": "^8.46.3",
-    "@vitest/coverage-v8": "^4.0.7",
+    "@types/node": "^24.10.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "@vitest/coverage-v8": "^4.0.8",
     "cross-env": "^10.1.0",
     "eslint": "^9.39.1",
     "eslint-plugin-jsdoc": "^61.1.12",
-    "eslint-plugin-tsdoc": "^0.4.0",
+    "eslint-plugin-tsdoc": "^0.5.0",
     "globals": "^16.5.0",
     "jsdoc": "^4.0.5",
-    "read-pkg": "^9.0.1",
+    "read-pkg": "^10.0.0",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.46.3",
-    "vite": "^7.2.0",
-    "vite-node": "^3.2.4",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.2",
+    "vite-node": "^5.0.0",
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^4.0.7",
+    "vitest": "^4.0.8",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {
     "@rljson/hash": "^0.0.17",
-    "@rljson/io": "^0.0.53",
+    "@rljson/io": "^0.0.55",
     "@rljson/json": "^0.0.23",
-    "@rljson/rljson": "^0.0.67",
+    "@rljson/rljson": "^0.0.69",
     "@rljson/validate": "^0.0.11",
     "filtrex": "^3.1.0",
     "object-traversal": "^1.0.1",