@rljson/db 0.0.8 → 0.0.10

package/dist/connector/connector.d.ts

@@ -0,0 +1,30 @@
+import { Socket } from '@rljson/io';
+import { Route } from '@rljson/rljson';
+import { Db } from '../db.ts';
+export type ConnectorPayload = {
+    o: string;
+    r: string;
+};
+export type ConnectorCallback = (ref: string) => Promise<any>;
+export declare class Connector {
+    private readonly _db;
+    private readonly _route;
+    private readonly _socket;
+    private _origin;
+    private _callbacks;
+    private _isListening;
+    private _sentRefs;
+    private _receivedRefs;
+    constructor(_db: Db, _route: Route, _socket: Socket);
+    send(ref: string): void;
+    listen(callback: (editHistoryRef: string) => Promise<void>): void;
+    private _init;
+    teardown(): void;
+    private _notifyCallbacks;
+    private _registerSocketObserver;
+    private _registerDbObserver;
+    get socket(): Socket;
+    get route(): Route;
+    get origin(): string;
+    get isListening(): boolean;
+}

package/dist/controller/base-controller.d.ts

@@ -0,0 +1,49 @@
+import { Json, JsonValue } from '@rljson/json';
+import { ContentType, InsertHistoryRow, Ref, Rljson, TableCfg, TableKey, TableType } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { CakeControllerCommands } from './cake-controller.ts';
+import { Controller, ControllerChildProperty, ControllerRefs } from './controller.ts';
+export declare abstract class BaseController<T extends TableType, C extends JsonValue> implements Controller<T, C, string> {
+    protected readonly _core: Core;
+    protected readonly _tableKey: TableKey;
+    protected _contentType?: ContentType;
+    protected _tableCfg?: TableCfg;
+    constructor(_core: Core, _tableKey: TableKey);
+    abstract insert(command: CakeControllerCommands, value: C, origin?: Ref, refs?: ControllerRefs): Promise<InsertHistoryRow<any>[]>;
+    abstract init(): Promise<void>;
+    abstract getChildRefs(where: string | Json, filter?: Json): Promise<ControllerChildProperty[]>;
+    abstract filterRow(row: Json, key: string, value: JsonValue): Promise<boolean>;
+    /**
+     * Retrieves the current state of the table.
+     * @returns A promise that resolves to the current state of the table.
+     */
+    table(): Promise<T>;
+    /**
+     * 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.
+     */
+    get(where: string | Json, filter?: Json): Promise<Rljson>;
+    /**
+     * 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.
+     */
+    protected _getByHash(hash: string, filter?: Json): Promise<Rljson>;
+    /**
+     * 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.
+     */
+    protected _getByWhere(where: Json, filter?: Json): Promise<Rljson>;
+    /**
+     * Gets the content type of the controller.
+     * @returns The content type managed by the controller.
+     */
+    contentType(): ContentType;
+    /**
+     * Gets the table configuration of the controller.
+     * @returns The table configuration managed by the controller.
+     */
+    tableCfg(): TableCfg;
+}

package/dist/controller/cake-controller.d.ts

@@ -0,0 +1,30 @@
+import { Json, JsonValue } from '@rljson/json';
+import { Cake, CakesTable, InsertHistoryRow, LayerRef, Ref, Rljson, SliceIdsRef, TableKey } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { BaseController } from './base-controller.ts';
+import { Controller, ControllerChildProperty, ControllerCommands, ControllerRefs } from './controller.ts';
+export interface CakeValue extends Json {
+    layers: {
+        [layerTable: TableKey]: LayerRef;
+    };
+    id?: string;
+}
+export type CakeControllerCommands = ControllerCommands | `add@${string}`;
+export interface CakeControllerRefs extends Partial<Cake> {
+    sliceIdsTable: TableKey;
+    sliceIdsRow: SliceIdsRef;
+    base?: Ref;
+}
+export declare class CakeController<N extends string, C extends Cake> extends BaseController<CakesTable, C> implements Controller<CakesTable, C, N> {
+    protected readonly _core: Core;
+    protected readonly _tableKey: TableKey;
+    private _refs?;
+    private _table;
+    constructor(_core: Core, _tableKey: TableKey, _refs?: CakeControllerRefs | undefined);
+    private _baseLayers;
+    init(): Promise<void>;
+    getChildRefs(where: string | Json, filter?: Json): Promise<ControllerChildProperty[]>;
+    insert(command: CakeControllerCommands, value: C, origin?: Ref, refs?: ControllerRefs): Promise<InsertHistoryRow<any>[]>;
+    get(where: string | Json, filter?: Json): Promise<Rljson>;
+    filterRow(row: Json, key: string, value: JsonValue): Promise<boolean>;
+}

package/dist/controller/component-controller.d.ts

@@ -0,0 +1,68 @@
+import { Json, JsonValue } from '@rljson/json';
+import { ComponentsTable, InsertHistoryRow, Ref, Rljson, TableKey } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { BaseController } from './base-controller.ts';
+import { Controller, ControllerChildProperty, ControllerCommands, ControllerRefs } from './controller.ts';
+export declare class ComponentController<N extends string, C extends Json, T extends Json> extends BaseController<ComponentsTable<T>, C> implements Controller<ComponentsTable<T>, C, N> {
+    protected readonly _core: Core;
+    protected readonly _tableKey: TableKey;
+    private _refs?;
+    private _allowedContentTypes;
+    private _resolvedColumns;
+    private _refTableKeyToColumnKeyMap;
+    constructor(_core: Core, _tableKey: TableKey, _refs?: ControllerRefs | undefined);
+    init(): Promise<void>;
+    insert(command: ControllerCommands, value: Json, origin?: Ref, refs?: ControllerRefs): Promise<InsertHistoryRow<N>[]>;
+    /**
+     * 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
+     */
+    getChildRefs(where: string | Json, filter?: Json): Promise<ControllerChildProperty[]>;
+    /**
+     * 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.
+     */
+    protected _getByWhere(where: Json, filter?: Json): Promise<Rljson>;
+    private _referencesToWhereClauses;
+    private _createRefTableKeyToColumnKeyMap;
+    /**
+     * 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.
+     */
+    private _getWhereReferences;
+    /**
+     * 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.
+     */
+    private _getWhereBase;
+    /**
+     * Retrieves all reference columns from the resolved columns.
+     * @returns An array of ColumnCfg representing the reference columns.
+     */
+    private get _referenceColumns();
+    /**
+     * 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.
+     */
+    private _hasReferenceColumns;
+    /**
+     * 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.
+     */
+    private _resolveReferenceColumns;
+    /**
+     * 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.
+     */
+    private _resolveReferences;
+    private _readRowsWithReferences;
+    filterRow(row: Json, key: string, value: JsonValue): Promise<boolean>;
+}

package/dist/controller/controller.d.ts

@@ -0,0 +1,48 @@
+import { Json, JsonValue } from '@rljson/json';
+import { ContentType, InsertCommand, InsertHistoryRow, Ref, Rljson, SliceId, TableCfg, TableKey, TableType } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { CakeControllerRefs } from './cake-controller.ts';
+import { LayerControllerRefs } from './layer-controller.ts';
+export type ControllerRefs = CakeControllerRefs | LayerControllerRefs;
+export type ControllerCommands = InsertCommand;
+export type ControllerRunFn<N extends string, C extends JsonValue> = (command: ControllerCommands, value: C, origin?: Ref, refs?: ControllerRefs) => Promise<InsertHistoryRow<N>[]>;
+export type ControllerChildProperty = {
+    tableKey: TableKey;
+    columnKey?: string;
+    ref: Ref;
+    sliceIds?: SliceId[];
+};
+/**
+ * Generic interface for a controller that manages a specific table in the database.
+ * @template T The type of the table being managed.
+ * @template C The type of the Insert.
+ * @template N The name of the table being managed.
+ * @property {ControllerRunFn<N>} insert - Function to execute a command on the table.
+ * @property {() => Promise<void>} init - Initializes the controller.
+ * @property {() => Promise<T>} table - Retrieves the current state of the table.
+ * @property {(where: string | { [column: string]: JsonValue }) => Promise<Rljson>} get - Fetches data from the table based on a condition.
+ * @property {(where: string | Json, filter?: Json) => Promise<Array<{ tableKey: TableKey; ref: Ref }>>} getChildRefs - Retrieves references to child entries in related tables based on a condition.
+ * @param {string | Json }} where - The condition to filter the data.
+ * @returns {Promise<Json[] | null>} A promise that resolves to an array of JSON objects or null if no data is found.
+ * @throws {Error} If the data is invalid.
+ */
+export interface Controller<T extends TableType, C extends JsonValue, N extends string> {
+    insert: ControllerRunFn<N, C>;
+    init(): Promise<void>;
+    table(): Promise<T>;
+    get(where: string | Json, filter?: Json): Promise<Rljson>;
+    getChildRefs(where: string | Json, filter?: Json): Promise<ControllerChildProperty[]>;
+    filterRow(row: Json, key: string, value: JsonValue): Promise<boolean>;
+    contentType(): ContentType;
+    tableCfg(): TableCfg;
+}
+/**
+ * Factory function to create a controller based on the content type.
+ * @param {ContentType} type - The type of content (e.g., 'layers', 'components', 'cakes').
+ * @param {Core} core - The core instance managing the database.
+ * @param {TableKey} tableKey - The key identifying the table to be managed.
+ * @param {ControllerRefs} [refs] - Optional references for the controller.
+ * @returns {Promise<Controller<any, string>>} A promise that resolves to the created controller.
+ * @throws {Error} If the controller for the specified type is not implemented.
+ */
+export declare const createController: (type: ContentType, core: Core, tableKey: TableKey, refs?: ControllerRefs) => Promise<Controller<TableType, any, string>>;

package/dist/controller/layer-controller.d.ts

@@ -0,0 +1,26 @@
+import { Json, JsonValue } from '@rljson/json';
+import { InsertCommand, InsertHistoryRow, Layer, LayerRef, LayersTable, Ref, Rljson, SliceId, SliceIdsRef, TableKey } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { BaseController } from './base-controller.ts';
+import { Controller, ControllerChildProperty, ControllerRefs } from './controller.ts';
+export interface LayerControllerRefs extends Partial<Layer> {
+    base?: LayerRef;
+    sliceIdsTable: TableKey;
+    sliceIdsTableRow: SliceIdsRef;
+    componentsTable: TableKey;
+}
+export declare class LayerController<N extends string, C extends Layer> extends BaseController<LayersTable, C> implements Controller<LayersTable, C, N> {
+    protected readonly _core: Core;
+    protected readonly _tableKey: TableKey;
+    private _refs?;
+    constructor(_core: Core, _tableKey: TableKey, _refs?: LayerControllerRefs | undefined);
+    init(): Promise<void>;
+    insert(command: InsertCommand, value: C, origin?: Ref, refs?: ControllerRefs): Promise<InsertHistoryRow<any>[]>;
+    get(where: string | Json, filter?: Json): Promise<Rljson>;
+    resolveBaseLayer(layer: Layer): Promise<{
+        add: Record<string, string>;
+        sliceIds: SliceId[];
+    }>;
+    getChildRefs(where: string | Json, filter?: Json): Promise<ControllerChildProperty[]>;
+    filterRow(row: Json, _: string, value: JsonValue): Promise<boolean>;
+}

package/dist/controller/slice-id-controller.d.ts

@@ -0,0 +1,22 @@
+import { Json, JsonValue } from '@rljson/json';
+import { InsertCommand, InsertHistoryRow, Ref, Rljson, SliceId, SliceIds, SliceIdsRef, SliceIdsTable, TableKey } from '@rljson/rljson';
+import { Core } from '../core.ts';
+import { BaseController } from './base-controller.ts';
+import { Controller, ControllerChildProperty, ControllerRefs } from './controller.ts';
+export interface SliceIdControllerRefs extends Partial<SliceIds> {
+    base?: SliceIdsRef;
+}
+export declare class SliceIdController<N extends string, C extends SliceId[]> extends BaseController<SliceIdsTable, C> implements Controller<SliceIdsTable, C, N> {
+    protected readonly _core: Core;
+    protected readonly _tableKey: TableKey;
+    private _refs?;
+    constructor(_core: Core, _tableKey: TableKey, _refs?: SliceIdControllerRefs | undefined);
+    init(): Promise<void>;
+    insert(command: InsertCommand, value: SliceId[], origin?: Ref, refs?: ControllerRefs): Promise<InsertHistoryRow<any>[]>;
+    get(where: string | Json, filter?: Json): Promise<Rljson>;
+    resolveBaseSliceIds(sliceIds: SliceIds): Promise<{
+        add: SliceId[];
+    }>;
+    getChildRefs(): Promise<ControllerChildProperty[]>;
+    filterRow(row: Json, _: string, value: JsonValue): Promise<boolean>;
+}

package/dist/db.d.ts

@@ -1,15 +1,15 @@
 import { Io } from '@rljson/io';
 import { Json, JsonValue } from '@rljson/json';
-import { InsertHistoryRow, InsertHistoryTimeId, Ref, Rljson, Route, SliceId, TableType } from '@rljson/rljson';
+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[] | null;
-    row: JsonValue[] | null;
+    value: JsonValue | JsonValue[] | null;
+    row: JsonValue | JsonValue[] | null;
     path: Array<Array<string | number>>;
 };
 export type Container = {
@@ -97,13 +97,17 @@ 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;
+    unregisterObserver(route: Route, callback: NotifyCallback<any>): void;
+    /**
+     * Unregisters all observers from all routes
+     */
+    unregisterAllObservers(route: Route): void;
     /**
      * Get a controller for a specific table
      * @param tableKey - The key of the table to get the controller for
@@ -120,6 +124,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
@@ -174,8 +220,19 @@ export declare class Db {
      * @returns A new Rljson with only the isolated property
      */
     isolatePropertyFromComponents(rljson: Rljson, propertyKey: string): Rljson;
+    /**
+     * Clone the Db instance with a new Io instance
+     * @param io - The new Io instance
+     * @returns A new Db instance with the same cache as the current instance
+     */
+    clone(io: Io): Db;
     /**
      * Get the current cache of the Db instance
      */
     get cache(): Map<string, Container>;
+    /**
+     * Set the cache of the Db instance
+     * @param cache - The new cache to set
+     */
+    setCache(cache: Map<string, Container>): void;
 }