@rljson/db 0.0.9 → 0.0.11

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,29 @@
+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?;
+    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

@@ -17,6 +17,11 @@ export type Container = {
     tree: Json;
     cell: Cell[];
 };
+export type GetOptions = {
+    skipRljson?: boolean;
+    skipTree?: boolean;
+    skipCell?: boolean;
+};
 export type ContainerWithControllers = Container & {
     controllers: Record<string, Controller<any, any, any>>;
 };
@@ -48,7 +53,7 @@ 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, filter?: ControllerChildProperty[], sliceIds?: SliceId[]): Promise<ContainerWithControllers>;
+    get(route: Route, where: string | Json, filter?: ControllerChildProperty[], sliceIds?: SliceId[], options?: GetOptions): Promise<ContainerWithControllers>;
     /**
      * Resolves the route and returns corresponding data for any segment of the route,
      * matching recursive filters and where clauses
@@ -58,9 +63,11 @@ export declare class Db {
      * @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
+     * @param routeAccumulator - The accumulated route up to the current segment
+     * @param options - Additional options for fetching data
      * @returns - An Rljson object matching the route and filters
      */
-    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any, any>>, filter?: ControllerChildProperty[], sliceIds?: SliceId[], routeAccumulator?: Route): Promise<Container>;
+    _get(route: Route, where: string | Json, controllers: Record<string, Controller<any, any, any>>, filter?: ControllerChildProperty[], sliceIds?: SliceId[], routeAccumulator?: Route, options?: GetOptions): 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
@@ -104,6 +111,10 @@ export declare class Db {
      * @param callback - The callback to be unregistered
      */
     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
@@ -216,8 +227,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;
 }