@getanthill/datastore/dist/sdk/Datastore.d.ts

Event-Sourced Datastore

import type { RawAxiosRequestHeaders, AxiosResponse, RawAxiosResponseHeaders, AxiosResponseHeaders } from 'axios';
import type { DatastoreImportFixture, ModelConfig, Telemetry } from '../typings';
import { EventEmitter } from 'events';
import Core from './Core';
import Streams, { StreamClose, StreamHandler } from './Streams';
import { Iteration, MultiQuery } from './utils';
export declare const ERROR_MISSING_MODEL_NAME: Error;
export declare const ERROR_MISSING_CORRELATION_ID: Error;
export declare const ERROR_MISSING_JSON_PATCH: Error;
export declare const ERROR_STREAM_MAX_RECONNECTION_ATTEMPTS_REACHED: Error;
export interface DatastoreConfig {
    /**
     * Datastore API base URL
     * default: http://localhost:3001
     */
    baseUrl?: string;
    /**
     * API Access token
     */
    token?: string;
    /**
     * Requests timeout in milliseconds
     */
    timeout?: number;
    /**
     * Log HTTP errors
     */
    debug?: boolean;
    /**
     * Telemetry instance of logging and metrics
     */
    telemetry?: Telemetry;
    /**
     * Type of the stream connector:
     * - 'http': Server Sent Events HTTP Stream
     * - 'amqp': RabbitMQ stream
     */
    connector?: 'http' | 'amqp';
    /**
     * Force to fetch documents from primary to guarantee
     * accessing the most up-to-date data.
     */
    forcePrimary?: true;
    walk?: {
        maxPageSize?: number;
    };
}
export default class Datastore extends EventEmitter {
    name: string;
    config: DatastoreConfig;
    telemetry?: Telemetry;
    core: Core;
    streams: Streams;
    constructor(config?: DatastoreConfig);
    heartbeat(): Promise<AxiosResponse>;
    _checkCorrelationIdExistence(correlationId: string): void;
    _checkModelNameExistence(model: Partial<ModelConfig> | undefined): void;
    getModels(): Promise<AxiosResponse>;
    getGraph(): Promise<AxiosResponse>;
    getModel(model: string): Promise<AxiosResponse>;
    rotateEncryptionKeys(models?: string[]): Promise<AxiosResponse>;
    createModel(modelConfig: ModelConfig): Promise<AxiosResponse>;
    updateModel(modelConfig: Partial<ModelConfig>): Promise<AxiosResponse>;
    createModelIndexes(modelConfig?: ModelConfig): Promise<AxiosResponse>;
    getSchema(modelName: string): Promise<AxiosResponse>;
    encrypt(modelName: string, data: object[], fields?: string[]): Promise<AxiosResponse>;
    decrypt(modelName: string, data: object[], fields?: string[]): Promise<AxiosResponse>;
    create(modelName: string, payload: object, headers?: RawAxiosRequestHeaders): Promise<AxiosResponse>;
    apply(modelName: string, correlationId: string, eventType: string, eventVersion: string, payload: object, headers?: RawAxiosRequestHeaders): Promise<AxiosResponse>;
    update<T>(modelName: string, correlationId: string, payload: T, headers?: RawAxiosRequestHeaders): Promise<AxiosResponse>;
    patch(modelName: string, correlationId: string, jsonPatch: object[], headers?: RawAxiosRequestHeaders): Promise<AxiosResponse>;
    get(modelName: string, correlationId: string, headers?: {
        'force-primary'?: true;
    }): Promise<AxiosResponse>;
    count(model: string, query: object, source?: string): Promise<number>;
    find(model: string, query: object, page?: number, pageSize?: number, headers?: {
        page?: number;
        'page-size'?: number;
        'cursor-last-id'?: string;
        'force-primary'?: true;
    }): Promise<AxiosResponse>;
    events(model: string, correlationId: string, page?: number, pageSize?: number): Promise<AxiosResponse>;
    allEvents(model: string, query?: object, page?: number, pageSize?: number, headers?: {
        page?: number;
        'page-size'?: number;
        'cursor-last-id'?: string;
    }): Promise<AxiosResponse>;
    firstEventVersion(model: string, query: object, sort: any, defaultValue: number, headers?: {
        page?: number;
        'page-size'?: number;
        'cursor-last-id'?: string;
    }): Promise<number>;
    minEventsVersion(model: string, query: object, headers?: {
        page?: number;
        'page-size'?: number;
        'cursor-last-id'?: string;
    }): Promise<number>;
    maxEventsVersion(model: string, query: object, headers?: {
        page?: number;
        'page-size'?: number;
        'cursor-last-id'?: string;
    }): Promise<number>;
    version(model: string, correlationId: string, version: number | Date | string): Promise<AxiosResponse>;
    at(model: string, correlationId: string, date: Date | string): Promise<AxiosResponse>;
    restore(model: string, correlationId: string, version: number): Promise<AxiosResponse>;
    snapshot(model: string, correlationId: string, options?: {
        /**
         * Version of the state to snapshot.
         */
        version?: number | Date | string;
        /**
         * If true, delete past events from the database.
         */
        clean?: boolean;
    }): Promise<AxiosResponse>;
    data(model: string, correlationId: string, models?: string[]): Promise<AxiosResponse>;
    archive(model: string, correlationId: string, deep?: boolean, models?: string[]): Promise<AxiosResponse>;
    unarchive(model: string, correlationId: string, deep?: boolean, models?: string[]): Promise<AxiosResponse>;
    delete(model: string, correlationId: string, deep?: boolean, models?: string[]): Promise<AxiosResponse>;
    aggregate(pipeline: any[], headers?: any): Promise<AxiosResponse>;
    _interpolate(str: string, params: any): string;
    import(data: DatastoreImportFixture[], modelConfigs: {
        [key: string]: ModelConfig;
    }, options?: {
        dryRun: boolean;
    }, entities?: Map<string, object>): Promise<Map<string, object>>;
    walkNext(model: string, query: object, source: string, page: number, pageSize: number, opts: {
        current_version: number;
        version_ordered?: boolean;
        cursor_last_id?: string;
        cursor_last_correlation_id: string;
        headers?: any;
    }): Promise<AxiosResponse<any, any, {}>>;
    static walkMulti(datastores: Map<string, Datastore>, queries: MultiQuery[], handler: (res: any, query: MultiQuery, queryIteration: Iteration) => any, opts?: {
        page_size: number;
        sort_handler?: (a: any, b: any) => any;
        sleep?: number;
        version_ordered?: boolean;
        handle_in_order?: boolean;
        handle_in_parallel?: boolean;
        chunk_size?: number;
        is_mutating?: boolean;
    }): Promise<void>;
    walk(model: string, query: object, handler: (...args: any[]) => Promise<void> | void, pageSize?: number, source?: MultiQuery['source'], headers?: any, opts?: {
        sleep?: number;
        version_ordered?: boolean;
        handle_in_order?: boolean;
        handle_in_parallel?: boolean;
        chunk_size?: number;
        is_mutating?: boolean;
    }): Promise<void>;
    updateOverwhelmingly<T>(model: string, query: object, handler: (entity: T) => Promise<T>, progress: (stats: {
        total: number;
        done: number;
        error: number;
        progress: number;
        restored: number;
    }, entity: T, headers: RawAxiosResponseHeaders | AxiosResponseHeaders) => void, pageSize?: number): Promise<{
        total: number;
        done: number;
        error: number;
        progress: number;
        restored: number;
    }>;
    /**
     * @deprecated in favor to `datastore.streams.getStreamId`
     */
    _streamId(model: string, source: string, query?: object): string;
    /**
     * @deprecated in favor to `datastore.streams.listen`
     */
    listen(model: string, source: 'events' | 'entities', query?: object, options?: any): Promise<StreamClose>;
    /**
     * @deprecated in favor to `datastore.streams.close`
     */
    close(streamId: string): void;
    /**
     * @deprecated in favor to `datastore.streams.closeAll`
     */
    closeAll(): void;
    /**
     * @deprecated in favor to `datastore.streams.stream`
     */
    stream(handler: StreamHandler, model?: string, source?: 'entities' | 'events', data?: object[]): Promise<StreamClose>;
}