hamok/lib/collections/HamokRecord.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { EventEmitter } from 'events';
import { HamokConnection } from './HamokConnection';
import { HamokRecordSnapshot } from '../HamokSnapshot';
import { HamokCodec } from '../common/HamokCodec';
export type HamokRecordObject = Record<string, unknown>;
type InsertRemovePayload<T, K extends keyof T> = {
    key: K;
    value: T[K];
};
type UpdatePayload<T, K extends keyof T> = {
    key: K;
    oldValue: T[K];
    newValue: T[K];
};
export type HamokRecordEventMap<T> = {
    'insert': [InsertRemovePayload<T, keyof T>];
    'update': [UpdatePayload<T, keyof T>];
    'remove': [InsertRemovePayload<T, keyof T>];
    'clear': [];
    'close': [];
};
export declare interface HamokRecord<T extends HamokRecordObject> {
    on<U extends keyof HamokRecordEventMap<T>>(event: U, listener: (...args: HamokRecordEventMap<T>[U]) => void): this;
    off<U extends keyof HamokRecordEventMap<T>>(event: U, listener: (...args: HamokRecordEventMap<T>[U]) => void): this;
    once<U extends keyof HamokRecordEventMap<T>>(event: U, listener: (...args: HamokRecordEventMap<T>[U]) => void): this;
    emit<U extends keyof HamokRecordEventMap<T>>(event: U, ...args: HamokRecordEventMap<T>[U]): boolean;
}
/**
 * Replicated storage replicates all entries on all distributed storages
 */
export declare class HamokRecord<T extends HamokRecordObject> extends EventEmitter {
    readonly connection: HamokConnection<string, string>;
    private _payloadsCodec?;
    private _closed;
    equalValues: <K extends keyof T>(a: T[K], b: T[K]) => boolean;
    private _object;
    private _initializing?;
    constructor(connection: HamokConnection<string, string>, setup?: {
        equalValues?: <K extends keyof T>(a: T[K], b: T[K]) => boolean;
        payloadsCodec?: Map<keyof T, HamokCodec<T[keyof T], string>>;
        initalObject?: Partial<T>;
    });
    get id(): string;
    get ready(): Promise<this>;
    get closed(): boolean;
    get instance(): T;
    close(): void;
    clear(): Promise<void>;
    get<K extends keyof T>(key: K): T[K] | undefined;
    set<K extends keyof T>(key: K, value: T[K]): Promise<T[K] | undefined>;
    insert<K extends keyof T>(key: K, value: T[K]): Promise<T[K] | undefined>;
    insertInstance(instance: Partial<T>): Promise<Partial<T> | undefined>;
    updateIf<K extends keyof T>(key: K, value: T[K], oldValue: T[K]): Promise<boolean>;
    updateInstanceIf(newValue: Partial<T>, oldValue: Partial<T>): Promise<boolean>;
    delete<K extends keyof T>(key: K): Promise<boolean>;
    /**
     * Exports the storage data
     */
    export(): HamokRecordSnapshot;
    import(data: HamokRecordSnapshot, eventing?: boolean): void;
    private _import;
    private _encodeValue;
    private _decodeValue;
}
export {};
//# sourceMappingURL=HamokRecord.d.ts.map