@rljson/db 0.0.7 → 0.0.9

package/dist/db.d.ts

@@ -1,11 +1,25 @@
 import { Io } from '@rljson/io';
-import { Json } from '@rljson/json';
-import { Insert, InsertHistoryRow, InsertHistoryTimeId, Ref, Rljson, Route, TableKey } from '@rljson/rljson';
-import { Controller, ControllerRefs } from './controller/controller.ts';
+import { Json, JsonValue } from '@rljson/json';
+import { Edit, EditHistory, InsertHistoryRow, InsertHistoryTimeId, MultiEdit, Ref, Rljson, Route, SliceId, TableType } from '@rljson/rljson';
+import { Controller, ControllerChildProperty, 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';
+import { Notify, NotifyCallback } from './notify.ts';
+export type Cell = {
+    route: Route;
+    value: JsonValue | JsonValue[] | null;
+    row: JsonValue | JsonValue[] | null;
+    path: Array<Array<string | number>>;
+};
+export type Container = {
+    rljson: Rljson;
+    tree: Json;
+    cell: Cell[];
+};
+export type ContainerWithControllers = Container & {
+    controllers: Record<string, Controller<any, any, any>>;
+};
 /**
  * Access Rljson data
  */
@@ -29,10 +43,12 @@ export declare class Db {
      * Get data from a route with optional filtering
      * @param route - The route to get data from
      * @param where - Optional filter to apply to the data
+     * @param filter - Optional filter to apply to child entries in related tables
+     * @param sliceIds - Optional slice IDs to filter the data
      * @returns An array of Rljson objects matching the route and filter
      * @throws {Error} If the route is not valid or if any controller cannot be created
      */
-    get(route: Route, where: string | Json): Promise<Rljson>;
+    get(route: Route, where: string | Json, filter?: ControllerChildProperty[], sliceIds?: SliceId[]): Promise<ContainerWithControllers>;
     /**
      * Resolves the route and returns corresponding data for any segment of the route,
      * matching recursive filters and where clauses
@@ -41,13 +57,10 @@ export declare class Db {
      * @param where - The recursive filtering key/value pairs to apply to the data
      * @param controllers - The controllers to use for fetching data
      * @param filter - Optional filter to apply to the data at the current route segment
+     * @param sliceIds - Optional slice IDs to filter the data at the current route segment
      * @returns - An Rljson object matching the route and filters
      */
-    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any>>, filter?: Array<{
-        tableKey: TableKey;
-        columnKey?: string;
-        ref: Ref;
-    }>): Promise<Rljson>;
+    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any, any>>, filter?: ControllerChildProperty[], sliceIds?: SliceId[], routeAccumulator?: Route): Promise<Container>;
     /**
      * Get the reference (hash) of a route segment, considering default refs and insertHistory refs
      * @param segment - The route segment to get the reference for
@@ -59,27 +72,14 @@ 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
-     */
-    private _getBaseDataForColumnSelection;
+    private _resolveSliceIds;
     /**
      * 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
      */
-    insert(insert: Insert<any>, options?: {
+    insert(route: Route, tree: Json, options?: {
         skipNotification?: boolean;
         skipHistory?: boolean;
     }): Promise<InsertHistoryRow<any>[]>;
@@ -97,26 +97,13 @@ export declare class Db {
      * @param route - The route to register the callback on
      * @param callback - The callback to be called when an Insert is made
      */
-    registerObserver(route: Route, callback: (InsertHistoryRow: InsertHistoryRow<any>) => void): void;
+    registerObserver(route: Route, callback: NotifyCallback<any>): 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: (InsertHistoryRow: InsertHistoryRow<any>) => void): void;
-    /**
-     * 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 _resolveInsert;
-    /**
-     * 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
-     */
-    private _childKeys;
+    unregisterObserver(route: Route, callback: NotifyCallback<any>): void;
     /**
      * Get a controller for a specific table
      * @param tableKey - The key of the table to get the controller for
@@ -124,8 +111,8 @@ export declare class Db {
      * @returns A controller for the specified table
      * @throws {Error} If the table does not exist or if the table type is not supported
      */
-    getController(tableKey: string, refs?: ControllerRefs): Promise<Controller<any, string>>;
-    private _indexedControllers;
+    getController(tableKey: string, refs?: ControllerRefs): Promise<Controller<TableType, any, string>>;
+    indexedControllers(route: Route): Promise<Record<string, Controller<any, any, any>>>;
     /**
      * Adds an InsertHistory row to the InsertHistory table of a table
      * @param table - The table the Insert was made on
@@ -133,6 +120,48 @@ export declare class Db {
      * @throws {Error} If the InsertHistory table does not exist
      */
     private _writeInsertHistory;
+    /**
+     * Add a head revision for a cake
+     * @param cakeKey - The cake table key
+     * @param cakeRef - The cake reference
+     */
+    addHeadRevision(cakeKey: string, cakeRef: Ref): Promise<InsertHistoryRow<string>[]>;
+    /**
+     * Add a multiEdit
+     * @param cakeKey - The cake table key
+     * @param multiEdit - The multiEdit to add
+     */
+    addMultiEdit(cakeKey: string, multiEdit: MultiEdit): Promise<InsertHistoryRow<any>[]>;
+    /**
+     * Get multiEdits
+     * @param cakeKey - The cake table key
+     * @param where - The where clause to filter multiEdits
+     */
+    getMultiEdits(cakeKey: string, where: string | Json): Promise<MultiEdit[]>;
+    /**
+     * Add an edit
+     * @param cakeKey - The cake table key
+     * @param edit - The edit to add
+     */
+    addEdit(cakeKey: string, edit: Edit): Promise<InsertHistoryRow<any>[]>;
+    /**
+     * Get edits
+     * @param cakeKey - The cake table key
+     * @param where - The where clause to filter edits
+     */
+    getEdits(cakeKey: string, where: string | Json): Promise<Edit[]>;
+    /**
+     * Add an edit history entry
+     * @param cakeKey - The cake table key
+     * @param editHistory - The edit history entry to add
+     */
+    addEditHistory(cakeKey: string, editHistory: EditHistory): Promise<InsertHistoryRow<any>[]>;
+    /**
+     * Get edit history entries
+     * @param cakeKey - The cake table key
+     * @param where - The where clause to filter edit history entries
+     */
+    getEditHistories(cakeKey: string, where: string | Json): Promise<EditHistory[]>;
     /**
      * Get the InsertHistory of a table
      * @param table - The table to get the InsertHistory for
@@ -190,5 +219,5 @@ export declare class Db {
     /**
      * Get the current cache of the Db instance
      */
-    get cache(): Map<string, Rljson>;
+    get cache(): Map<string, Container>;
 }