@rljson/db 0.0.5 → 0.0.7

package/dist/cars-example.d.ts

@@ -1,4 +1,4 @@
-import { Json, JsonH } from '@rljson/json';
+import { Json, JsonH, JsonValueH } from '@rljson/json';
 import { CakesTable, ComponentsTable, LayersTable, Rljson, SliceIdsTable, TablesCfgTable } from '@rljson/rljson';
 export interface CarsExample extends Rljson {
     carSliceId: SliceIdsTable;
@@ -22,6 +22,10 @@ export interface CarGeneral extends JsonH {
     brand: string;
     type: string;
     doors: number;
+    energyConsumption: number;
+    units: JsonValueH;
+    serviceIntervals: number[];
+    isElectric: boolean;
 }
 export interface CarDimension extends JsonH {
     height: number;

package/dist/core.d.ts

@@ -7,20 +7,20 @@ export declare class Core {
     constructor(_io: Io);
     static example: () => Promise<Core>;
     /**
-     * Creates a table and an edit protocol for the table
+     * Creates a table and an insertHistory for the table
      * @param tableCfg TableCfg of table to create
      */
-    createEditable(tableCfg: TableCfg): Promise<void>;
+    createTableWithInsertHistory(tableCfg: TableCfg): Promise<void>;
     /**
      * Creates a table
      * @param tableCfg TableCfg of table to create
      */
     createTable(tableCfg: TableCfg): Promise<void>;
     /**
-     * Creates an edit protocol table for a given table
+     * Creates an insertHistory table for a given table
      * @param tableCfg TableCfg of table
      */
-    createEditProtocol(tableCfg: TableCfg): Promise<void>;
+    createInsertHistory(tableCfg: TableCfg): Promise<void>;
     /**
      * Returns a dump of the database
      */
@@ -39,7 +39,8 @@ export declare class Core {
     import(data: Rljson): Promise<void>;
     tables(): Promise<Rljson>;
     hasTable(table: string): Promise<boolean>;
-    contentType(table: string): Promise<ContentType | null>;
+    contentType(table: string): Promise<ContentType>;
+    tableCfg(table: string): Promise<TableCfg>;
     /** Reads a specific row from a database table */
     readRow(table: string, rowHash: string): Promise<Rljson>;
     readRows(table: string, where: {

package/dist/db.d.ts

@@ -1,8 +1,10 @@
 import { Io } from '@rljson/io';
 import { Json } from '@rljson/json';
-import { Edit, EditProtocolRow, EditProtocolTimeId, 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';
+import { ColumnSelection } from './join/selection/column-selection.ts';
 import { Notify } from './notify.ts';
 /**
  * Access Rljson data
@@ -22,6 +24,7 @@ export declare class Db {
      * Notification system to register callbacks on data changes
      */
     readonly notify: Notify;
+    private _cache;
     /**
      * Get data from a route with optional filtering
      * @param route - The route to get data from
@@ -29,55 +32,87 @@ export declare class Db {
      * @returns An array of Rljson objects matching the route and filter
      * @throws {Error} If the route is not valid or if any controller cannot be created
      */
-    get(route: Route, where: string | Json): Promise<Rljson[]>;
+    get(route: Route, where: string | Json): Promise<Rljson>;
     /**
-     * Recursively fetches data from the given route using the provided controllers
-     * @param route - The route to fetch data from
-     * @param where - The filter to apply to the root table
-     * @param controllers - A record of controllers keyed by table name
-     * @returns An array of Rljson objects matching the route and filter
+     * 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
+     * @returns
+     */
+    private _getReferenceOfRouteSegment;
+    /**
+     * Joins data from layers in an Rljson into a single dataset
+     * @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
      */
-    private _get;
+    private _getBaseDataForColumnSelection;
     /**
-     * Runs an edit by executing the appropriate controller(s) based on the edit's route
-     * @param edit - The edit to run
-     * @returns The result of the edit as an EditProtocolRow
-     * @throws {Error} If the edit is not valid or if any controller cannot be created
+     * 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
      */
-    run(edit: Edit<any>, options?: {
+    insert(insert: Insert<any>, options?: {
         skipNotification?: boolean;
-    }): Promise<EditProtocolRow<any>>;
+        skipHistory?: boolean;
+    }): Promise<InsertHistoryRow<any>[]>;
     /**
-     * Recursively runs controllers based on the route of the edit
-     * @param edit - The edit to run
-     * @param route - The route of the edit
+     * 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 edit
+     * @returns The result of the Insert
      * @throws {Error} If the route is not valid or if any controller cannot be created
      */
-    private _run;
+    private _insert;
     /**
-     * Registers a callback to be called when an edit is made on the given route
+     * Registers a callback to be called when an Insert is made on the given route
      * @param route - The route to register the callback on
-     * @param callback - The callback to be called when an edit is made
+     * @param callback - The callback to be called when an Insert is made
      */
-    registerObserver(route: Route, callback: (EditProtocolRow: EditProtocolRow<any>) => void): void;
+    registerObserver(route: Route, callback: (InsertHistoryRow: InsertHistoryRow<any>) => void): void;
     /**
      * 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: Route, callback: (EditProtocolRow: EditProtocolRow<any>) => void): void;
+    unregisterObserver(route: Route, callback: (InsertHistoryRow: InsertHistoryRow<any>) => void): void;
     /**
-     * Resolves an edit by returning the run functions of all controllers involved in the edit's route
-     * @param edit - The edit to resolve
+     * Resolves an Insert by returning the run functions of all controllers involved in the Insert's route
+     * @param Insert - The Insert to resolve
      * @returns A record of controller run functions, keyed by table name
      * @throws {Error} If the route is not valid or if any controller cannot be created
      */
-    private _resolveRuns;
+    private _resolveInsert;
     /**
      * Returns the keys of child refs in a value based on a route
-     * @param route - The route to check
      * @param value - The value to check
      * @returns An array of keys of child refs in the value
      */
@@ -92,56 +127,68 @@ export declare class Db {
     getController(tableKey: string, refs?: ControllerRefs): Promise<Controller<any, string>>;
     private _indexedControllers;
     /**
-     * Adds an edit protocol row to the edits table of a table
-     * @param table - The table the edit was made on
-     * @param editProtocolRow - The edit protocol row to add
-     * @throws {Error} If the edits table does not exist
+     * Adds an InsertHistory row to the InsertHistory table of a table
+     * @param table - The table the Insert was made on
+     * @param InsertHistoryRow - The InsertHistory row to add
+     * @throws {Error} If the InsertHistory table does not exist
      */
-    private _writeProtocol;
+    private _writeInsertHistory;
     /**
-     * Get the edit protocol of a table
-     * @param table - The table to get the edit protocol for
-     * @throws {Error} If the edits table does not exist
+     * Get the InsertHistory of a table
+     * @param table - The table to get the InsertHistory for
+     * @throws {Error} If the InsertHistory table does not exist
      */
-    getProtocol(table: string, options?: {
+    getInsertHistory(table: string, options?: {
         sorted?: boolean;
         ascending?: boolean;
     }): Promise<Rljson>;
     /**
-     * Get a specific edit protocol row from a table
-     * @param table - The table to get the edit protocol row from
-     * @param ref - The reference of the edit protocol row to get
-     * @returns The edit protocol row or null if it does not exist
-     * @throws {Error} If the edits table does not exist
+     * Get a specific InsertHistory row from a table
+     * @param table - The table to get the InsertHistory row from
+     * @param ref - The reference of the InsertHistory row to get
+     * @returns The InsertHistory row or null if it does not exist
+     * @throws {Error} If the Inserts table does not exist
      */
-    getProtocolRowsByRef(table: string, ref: string): Promise<EditProtocolRow<any>[] | null>;
+    getInsertHistoryRowsByRef(table: string, ref: string): Promise<InsertHistoryRow<any>[]>;
     /**
-     * Get a specific edit protocol row from a table by its timeId
-     * @param table - The table to get the edit protocol row from
-     * @param timeId - The timeId of the edit protocol row to get
-     * @returns The edit protocol row or null if it does not exist
-     * @throws {Error} If the edits table does not exist
+     * Get a specific InsertHistory row from a table by its timeId
+     * @param table - The table to get the InsertHistory row from
+     * @param timeId - The timeId of the InsertHistory row to get
+     * @returns The InsertHistory row or null if it does not exist
+     * @throws {Error} If the Inserts table does not exist
      */
-    getProtocolRowByTimeId(table: string, timeId: EditProtocolTimeId): Promise<EditProtocolRow<any> | null>;
+    getInsertHistoryRowByTimeId(table: string, timeId: InsertHistoryTimeId): Promise<InsertHistoryRow<any>>;
     /**
      * 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 edits table does not exist
+     * @throws {Error} If the Inserts table does not exist
      */
-    getTimeIdsForRef(table: string, ref: Ref): Promise<EditProtocolTimeId[]>;
+    getTimeIdsForRef(table: string, ref: Ref): Promise<InsertHistoryTimeId[]>;
     /**
      * 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 edits table does not exist
+     * @throws {Error} If the Inserts table does not exist
+     */
+    getRefOfTimeId(table: string, timeId: InsertHistoryTimeId): Promise<Ref | null>;
+    /**
+     * 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
+     */
+    isolatePropertyKeyFromRoute(route: Route): Promise<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
      */
-    getRefOfTimeId(table: string, timeId: EditProtocolTimeId): Promise<Ref | null>;
+    isolatePropertyFromComponents(rljson: Rljson, propertyKey: string): Rljson;
     /**
-     * Example
-     * @returns A new Db instance for test purposes
+     * Get the current cache of the Db instance
      */
-    static example: () => Promise<Db>;
+    get cache(): Map<string, Rljson>;
 }