harperdb/resources/databases.d.ts

HarperDB is a distributed database, caching service, streaming broker, and application development platform focused on performance and ease of use.

import { makeTable } from './Table';
export type Table = ReturnType<typeof makeTable>;
export interface Tables {
    [table_name: string]: Table;
}
export interface Databases {
    [database_name: string]: Tables;
}
export declare const tables: Tables;
export declare const databases: Databases;
export declare const database_envs: Map<string, any>;
/**
 * This gets the set of tables from the default database ("data").
 */
export declare function getTables(): Tables;
/**
 * This provides the main entry point for getting the set of all HarperDB tables (organized by schemas/databases).
 * This proactively scans the known
 * databases/schemas directories and finds any databases and opens them. This done proactively so that there is a fast
 * object available to all consumers that doesn't require runtime checks for database open states.
 * This also attaches the audit store associated with table. Note that legacy tables had a single audit table per db table
 * but in newer multi-table databases, there is one consistent, integrated audit table for the database since transactions
 * can span any tables in the database.
 */
export declare function getDatabases(): Databases;
export declare function resetDatabases(): Databases;
/**
 * This is responsible for reading the internal dbi of a single database file to get a list of all the tables and
 * their indexed or registered attributes
 * @param path
 * @param default_table
 * @param database_name
 */
export declare function readMetaDb(path: string, default_table?: string, database_name?: string, audit_path?: string, is_legacy?: boolean): any;
interface TableDefinition {
    table: string;
    database?: string;
    path?: string;
    expiration?: number;
    eviction?: number;
    scanInterval?: number;
    audit?: boolean;
    sealed?: boolean;
    splitSegments?: boolean;
    replicate?: boolean;
    trackDeletes?: boolean;
    attributes: any[];
    schemaDefined?: boolean;
    origin?: string;
}
/**
 * Get root store for a database
 * @param options
 * @returns
 */
export declare function database({ database: database_name, table: table_name }: {
    database: any;
    table: any;
}): any;
/**
 * Delete the database
 * @param database_name
 */
export declare function dropDatabase(database_name: any): Promise<void>;
/**
 * This can be called to ensure that the specified table exists and if it does not exist, it should be created.
 * @param table_name
 * @param database_name
 * @param custom_path
 * @param expiration
 * @param eviction
 * @param scanInterval
 * @param attributes
 * @param audit
 * @param sealed
 * @param splitSegments
 * @param replicate
 */
export declare function table(table_definition: TableDefinition): {
    new (identifier: import("./ResourceInterface").Id, source: any): {
        #record: any;
        #changes: any;
        #version: number;
        #entry: {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        #saveMode: boolean;
        #loadedFromSource: boolean;
        ensureLoaded(): any;
        get(query?: import("./ResourceInterface").Query | string): Promise<object | void> | object | void;
        allowRead(user: any, query: any): any;
        allowUpdate(user: any, updated_data: any): boolean;
        allowCreate(user: any, new_data: {}): boolean;
        allowDelete(user: any): boolean;
        update(updates?: any, full_update?: boolean): /*elided*/ any;
        addTo(property: any, value: any): void;
        subtractFrom(property: any, value: any): void;
        getMetadata(): {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        getRecord(): any;
        getChanges(): any;
        _setChanges(changes: any): void;
        setRecord(record: any): void;
        invalidate(): void;
        _writeInvalidate(partial_record?: any, options?: any): void;
        _writeRelocate(options: any): void;
        lock(): void;
        put(record: any): void;
        patch(record_update: any): void;
        _writeUpdate(record_update: any, full_update: boolean, options?: any): void;
        delete(request?: import("./ResourceInterface").Query | string): Promise<boolean>;
        _writeDelete(options?: any): boolean;
        search(request: import("./ResourceInterface").Query): AsyncIterable<any>;
        subscribe(request: import("./ResourceInterface").SubscriptionRequest): Promise<{
            listener: (key: any) => any;
            subscriptions: [];
            startTime?: number;
            end(): void;
            toJSON(): {
                name: string;
            };
            resolveNext: Function;
            queue: any[];
            hasDataListeners: boolean;
            drainCloseListener: boolean;
            currentDrainResolver: Function;
            push(message: any): void;
            send(message: any): void;
            getNextMessage(): any;
            waitForDrain(): Promise<boolean>;
            on(event_name: any, listener: any): /*elided*/ any;
            [Symbol.asyncIterator](): {
                queue: import("./IterableEventQueue").IterableEventQueue;
                push(message: any): void;
                next(): Promise<unknown> | {
                    value: any;
                };
                return(value: any): {
                    value: any;
                    done: boolean;
                };
                throw(error: any): {
                    done: boolean;
                };
            };
            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
            setMaxListeners(n: number): /*elided*/ any;
            getMaxListeners(): number;
            listeners<K>(eventName: string | symbol): Function[];
            rawListeners<K>(eventName: string | symbol): Function[];
            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            eventNames(): (string | symbol)[];
        }>;
        doesExist(): boolean;
        publish(message: any, options?: any): void;
        _writePublish(message: any, options?: any): void;
        validate(record: any, patch?: any): void;
        getUpdatedTime(): number;
        wasLoadedFromSource(): boolean | void;
        readonly #id: import("./ResourceInterface").Id;
        readonly #context: import("./ResourceInterface").Context;
        #isCollection: boolean;
        post(new_record: any): Promise<any>;
        get isCollection(): boolean;
        connect(incomingMessages: import("./IterableEventQueue").IterableEventQueue, query?: {}): AsyncIterable<any>;
        getId(): import("./ResourceInterface").Id;
        getContext(): import("./ResourceInterface").Context;
    };
    name: any;
    primaryStore: any;
    auditStore: any;
    primaryKey: any;
    tableName: any;
    tableId: any;
    indices: any;
    audit: any;
    databasePath: any;
    databaseName: any;
    attributes: any;
    replicate: any;
    sealed: any;
    splitSegments: any;
    createdTimeProperty: {
        name: string;
        type: string;
        assignCreatedTime?: boolean;
        assignUpdatedTime?: boolean;
        expiresAt?: boolean;
        isPrimaryKey?: boolean;
    };
    updatedTimeProperty: {
        name: string;
        type: string;
        assignCreatedTime?: boolean;
        assignUpdatedTime?: boolean;
        expiresAt?: boolean;
        isPrimaryKey?: boolean;
    };
    propertyResolvers: any;
    userResolvers: {};
    sources: any[];
    getResidencyById: (id: import("./ResourceInterface").Id) => number | void;
    get expirationMS(): any;
    dbisDB: any;
    schemaDefined: any;
    sourcedFrom(source: any, options: any): /*elided*/ any;
    get isCaching(): any;
    get shouldRevalidateEvents(): boolean;
    getResource(id: import("./ResourceInterface").Id, request: import("./ResourceInterface").Context, resource_options?: any): Promise<{
        #record: any;
        #changes: any;
        #version: number;
        #entry: {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        #saveMode: boolean;
        #loadedFromSource: boolean;
        ensureLoaded(): any;
        get(query?: import("./ResourceInterface").Query | string): Promise<object | void> | object | void;
        allowRead(user: any, query: any): any;
        allowUpdate(user: any, updated_data: any): boolean;
        allowCreate(user: any, new_data: {}): boolean;
        allowDelete(user: any): boolean;
        update(updates?: any, full_update?: boolean): /*elided*/ any;
        addTo(property: any, value: any): void;
        subtractFrom(property: any, value: any): void;
        getMetadata(): {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        getRecord(): any;
        getChanges(): any;
        _setChanges(changes: any): void;
        setRecord(record: any): void;
        invalidate(): void;
        _writeInvalidate(partial_record?: any, options?: any): void;
        _writeRelocate(options: any): void;
        lock(): void;
        put(record: any): void;
        patch(record_update: any): void;
        _writeUpdate(record_update: any, full_update: boolean, options?: any): void;
        delete(request?: import("./ResourceInterface").Query | string): Promise<boolean>;
        _writeDelete(options?: any): boolean;
        search(request: import("./ResourceInterface").Query): AsyncIterable<any>;
        subscribe(request: import("./ResourceInterface").SubscriptionRequest): Promise<{
            listener: (key: any) => any;
            subscriptions: [];
            startTime?: number;
            end(): void;
            toJSON(): {
                name: string;
            };
            resolveNext: Function;
            queue: any[];
            hasDataListeners: boolean;
            drainCloseListener: boolean;
            currentDrainResolver: Function;
            push(message: any): void;
            send(message: any): void;
            getNextMessage(): any;
            waitForDrain(): Promise<boolean>;
            on(event_name: any, listener: any): /*elided*/ any;
            [Symbol.asyncIterator](): {
                queue: import("./IterableEventQueue").IterableEventQueue;
                push(message: any): void;
                next(): Promise<unknown> | {
                    value: any;
                };
                return(value: any): {
                    value: any;
                    done: boolean;
                };
                throw(error: any): {
                    done: boolean;
                };
            };
            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
            setMaxListeners(n: number): /*elided*/ any;
            getMaxListeners(): number;
            listeners<K>(eventName: string | symbol): Function[];
            rawListeners<K>(eventName: string | symbol): Function[];
            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            eventNames(): (string | symbol)[];
        }>;
        doesExist(): boolean;
        publish(message: any, options?: any): void;
        _writePublish(message: any, options?: any): void;
        validate(record: any, patch?: any): void;
        getUpdatedTime(): number;
        wasLoadedFromSource(): boolean | void;
        readonly #id: import("./ResourceInterface").Id;
        readonly #context: import("./ResourceInterface").Context;
        #isCollection: boolean;
        post(new_record: any): Promise<any>;
        get isCollection(): boolean;
        connect(incomingMessages: import("./IterableEventQueue").IterableEventQueue, query?: {}): AsyncIterable<any>;
        getId(): import("./ResourceInterface").Id;
        getContext(): import("./ResourceInterface").Context;
    }> | {
        #record: any;
        #changes: any;
        #version: number;
        #entry: {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        #saveMode: boolean;
        #loadedFromSource: boolean;
        ensureLoaded(): any;
        get(query?: import("./ResourceInterface").Query | string): Promise<object | void> | object | void;
        allowRead(user: any, query: any): any;
        allowUpdate(user: any, updated_data: any): boolean;
        allowCreate(user: any, new_data: {}): boolean;
        allowDelete(user: any): boolean;
        update(updates?: any, full_update?: boolean): /*elided*/ any;
        addTo(property: any, value: any): void;
        subtractFrom(property: any, value: any): void;
        getMetadata(): {
            key: any;
            value: any;
            version: number;
            localTime: number;
            expiresAt: number;
            deref?: () => any;
        };
        getRecord(): any;
        getChanges(): any;
        _setChanges(changes: any): void;
        setRecord(record: any): void;
        invalidate(): void;
        _writeInvalidate(partial_record?: any, options?: any): void;
        _writeRelocate(options: any): void;
        lock(): void;
        put(record: any): void;
        patch(record_update: any): void;
        _writeUpdate(record_update: any, full_update: boolean, options?: any): void;
        delete(request?: import("./ResourceInterface").Query | string): Promise<boolean>;
        _writeDelete(options?: any): boolean;
        search(request: import("./ResourceInterface").Query): AsyncIterable<any>;
        subscribe(request: import("./ResourceInterface").SubscriptionRequest): Promise<{
            listener: (key: any) => any;
            subscriptions: [];
            startTime?: number;
            end(): void;
            toJSON(): {
                name: string;
            };
            resolveNext: Function;
            queue: any[];
            hasDataListeners: boolean;
            drainCloseListener: boolean;
            currentDrainResolver: Function;
            push(message: any): void;
            send(message: any): void;
            getNextMessage(): any;
            waitForDrain(): Promise<boolean>;
            on(event_name: any, listener: any): /*elided*/ any;
            [Symbol.asyncIterator](): {
                queue: import("./IterableEventQueue").IterableEventQueue;
                push(message: any): void;
                next(): Promise<unknown> | {
                    value: any;
                };
                return(value: any): {
                    value: any;
                    done: boolean;
                };
                throw(error: any): {
                    done: boolean;
                };
            };
            [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
            addListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            once<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            off<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            removeAllListeners(eventName?: string | symbol): /*elided*/ any;
            setMaxListeners(n: number): /*elided*/ any;
            getMaxListeners(): number;
            listeners<K>(eventName: string | symbol): Function[];
            rawListeners<K>(eventName: string | symbol): Function[];
            emit<K>(eventName: string | symbol, ...args: any[]): boolean;
            listenerCount<K>(eventName: string | symbol, listener?: Function): number;
            prependListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            prependOnceListener<K>(eventName: string | symbol, listener: (...args: any[]) => void): /*elided*/ any;
            eventNames(): (string | symbol)[];
        }>;
        doesExist(): boolean;
        publish(message: any, options?: any): void;
        _writePublish(message: any, options?: any): void;
        validate(record: any, patch?: any): void;
        getUpdatedTime(): number;
        wasLoadedFromSource(): boolean | void;
        readonly #id: import("./ResourceInterface").Id;
        readonly #context: import("./ResourceInterface").Context;
        #isCollection: boolean;
        post(new_record: any): Promise<any>;
        get isCollection(): boolean;
        connect(incomingMessages: import("./IterableEventQueue").IterableEventQueue, query?: {}): AsyncIterable<any>;
        getId(): import("./ResourceInterface").Id;
        getContext(): import("./ResourceInterface").Context;
    };
    _updateResource(resource: any, entry: any): void;
    getNewId(): any;
    setTTLExpiration(expiration: number | {
        expiration: number;
        eviction?: number;
        scanInterval?: number;
    }): void;
    getResidencyRecord(id: any): any;
    setResidency(getResidency?: (record: object, context: import("./ResourceInterface").Context) => number | void | string[]): void;
    setResidencyById(getResidencyById?: (id: import("./ResourceInterface").Id) => number | void): void;
    getResidency(record: object, context: import("./ResourceInterface").Context): number | void | string[];
    enableAuditing(audit_enabled?: boolean): void;
    coerceId(id: string): number | string;
    dropTable(): Promise<void>;
    _recordRelocate(existing_entry: any, entry: any): boolean;
    evict(id: any, existing_record: any, existing_version: any): Promise<void>;
    operation(operation: any, context: any): any;
    transformToOrderedSelect(entries: any[], select: (string | import("./ResourceInterface").SubSelect)[], sort: import("./ResourceInterface").Sort, context: import("./ResourceInterface").Context, read_txn: any, transformToRecord: Function): any;
    transformEntryForSelect(select: any, context: any, read_txn: any, filtered: any, ensure_loaded?: any, can_skip?: any): (entry: any) => any;
    subscribeOnThisThread(worker_index: any, options: any): boolean;
    addAttributes(attributes_to_add: any): Promise<any>;
    removeAttributes(names: string[]): Promise<any>;
    getSize(): number;
    getAuditSize(): number;
    getStorageStats(): {
        available: number;
        free: number;
        size: number;
    };
    getRecordCount(options?: any): Promise<{
        recordCount: number;
        estimatedRange: number[];
    } | {
        recordCount: number;
        estimatedRange?: undefined;
    }>;
    updatedAttributes(): void;
    setComputedAttribute(attribute_name: any, resolver: any): void;
    deleteHistory(end_time?: number, cleanup_deleted_records?: boolean): Promise<void>;
    getHistory(start_time?: number, end_time?: number): AsyncGenerator<{
        id: import("ordered-binary").Key;
        localTime: any;
        version: any;
        type: any;
        value: any;
        user: import("ordered-binary").Key;
        operation: any;
    }, void, unknown>;
    getHistoryOfRecord(id: any): Promise<any[]>;
    cleanup(): void;
    transactions: import("./DatabaseTransaction").Transaction[] & {
        timestamp: number;
    };
    directURLMapping: boolean;
    get(identifier: import("./ResourceInterface").Id, context?: import("./ResourceInterface").Context): Promise<import("./Resource").Resource>;
    get(query: import("./ResourceInterface").Query, context?: import("./ResourceInterface").Context): Promise<AsyncIterable<object>>;
    put: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    patch: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    delete(identifier: import("./ResourceInterface").Id, context?: import("./ResourceInterface").Context): Promise<boolean>;
    delete(request: import("./ResourceInterface").Context, context?: import("./ResourceInterface").Context): Promise<object>;
    create(id_prefix: import("./ResourceInterface").Id, record: any, context: import("./ResourceInterface").Context): Promise<import("./ResourceInterface").Id>;
    create(record: any, context: import("./ResourceInterface").Context): Promise<import("./ResourceInterface").Id>;
    invalidate: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    post: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    connect: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    subscribe(request: import("./ResourceInterface").SubscriptionRequest): Promise<AsyncIterable<{
        id: any;
        operation: string;
        value: object;
    }>>;
    publish: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    search: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    query: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    copy: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    move: {
        (id_or_query: string | import("./ResourceInterface").Id, data_or_context?: any, context?: import("./ResourceInterface").Context): any;
        reliesOnPrototype: boolean;
    };
    isCollection(resource: any): any;
    parseQuery(search: any): any;
    parsePath(path: any, context: any, query: any): any;
};
export declare function dropTableMeta({ table: table_name, database: database_name }: {
    table: any;
    database: any;
}): Promise<any[]>;
export declare function onUpdatedTable(listener: any): {
    remove(): void;
};
export declare function onRemovedDB(listener: any): {
    remove(): void;
};
export declare function getDefaultCompression(): {
    startingOffset: number;
};
export {};