relational-redis-store/dist/lib/Store.d.ts

A Relational Redis Store

/// <reference types="node" />
/// <reference types="node" />
import { AsyncResult, AsyncResultWrapper } from 'ts-async-results';
import { IHandyRedis } from 'handy-redis';
import { UnidentifiableModel, OnlyKeysOfType, CollectionItemOrReply, CollectionItem, CollectionItemRemovalReply, ForeignKeys, CollectionMapBase, QueueMapBase, UpdateableCollectionPropsGetter } from './util';
export declare type StoreErrors = 'CollectionFieldInexistent' | 'CollectionAdditionFailure' | 'CollectionDeletionFailure' | 'CollectionUpdateFailure' | 'CollectionUpdateFailure:MismatchingForeignKeys' | 'CollectionOrFieldInexistent' | 'QueueItemNotFound' | 'GenericRedisFailure';
export declare type StoreConfig = {
    namespace?: string;
    logger?: typeof console;
};
export declare class Store<CollectionMap extends CollectionMapBase, QueueMap extends QueueMapBase = {}, CollectionKey extends keyof CollectionMap & string = keyof CollectionMap & string, QueueKey extends keyof QueueMap & string = keyof QueueMap & string> {
    private redis;
    namespace: string;
    redisClient: IHandyRedis;
    private redisLock;
    private logger;
    constructor(redis: IHandyRedis, config?: StoreConfig);
    lockCollection<K extends CollectionKey>(collection: K): Promise<(done?: (() => void) | undefined) => void>;
    lockCollectionItem<K extends CollectionKey>(collection: K, id: string): Promise<(done?: (() => void) | undefined) => void>;
    private toNamespacedCollection;
    addItemToCollection<K extends CollectionKey, T extends CollectionMap[K], IndexBy extends OnlyKeysOfType<string | number, UnidentifiableModel<T>>, FKs extends ForeignKeys<T, CollectionMap>>(collection: K, val: CollectionItem<UnidentifiableModel<T>, CollectionMap, FKs>, id?: string, opts?: {
        indexBy?: IndexBy[];
        foreignKeys: FKs;
    }): AsyncResult<CollectionItemOrReply<T>, StoreErrors>;
    getCollectionIndex<K extends CollectionKey>(collection: K): AsyncResult<number, StoreErrors>;
    getCollectionLength<K extends CollectionKey>(collection: K): AsyncResult<number, StoreErrors>;
    private compactAllForeignKeys;
    private resolveForeignItems;
    private getItemsInCollectionWithMetadata;
    private getShallowItemsInCollectionWithMetadata;
    getItemInCollection<K extends CollectionKey, T extends CollectionMap[K]>(collection: K, id: string): AsyncResult<T, StoreErrors>;
    getItemInCollectionBy<K extends CollectionKey, T extends CollectionMap[K], F extends OnlyKeysOfType<string | number, UnidentifiableModel<T>>>(collection: K, byKey: F, keyVal: string | number): AsyncResult<T, StoreErrors>;
    private getIndexedItemReference;
    getItemsInCollection<K extends CollectionKey, T extends CollectionMap[K]>(collection: K, ids: string[]): AsyncResult<T[], StoreErrors>;
    private metadataReplyToCollectionItem;
    getAllItemsInCollection<K extends CollectionKey, T extends CollectionMap[K]>(collection: K): AsyncResult<T[], StoreErrors>;
    isItemInCollection<K extends CollectionKey>(collection: K, id: string): AsyncResult<boolean, never>;
    isItemInCollectionBy<K extends CollectionKey, T extends CollectionMap[K], F extends OnlyKeysOfType<string | number, UnidentifiableModel<T>>>(collection: K, byKey: F, keyVal: string | number): AsyncResult<boolean, never>;
    updateItemInCollection<K extends CollectionKey, T extends CollectionMap[K], FKs extends ForeignKeys<T, CollectionMap>>(collection: K, id: string, itemModelGetter: UpdateableCollectionPropsGetter<T>, opts: {
        foreignKeys: FKs;
    }): AsyncResult<T, StoreErrors>;
    private getIndexedInValueRecords;
    removeCollection<K extends CollectionKey>(collection: K): AsyncResult<void, StoreErrors>;
    removeItemInCollection<K extends CollectionKey>(collection: K, id: string): AsyncResult<CollectionItemRemovalReply, StoreErrors>;
    removeItemInCollectionBy<K extends CollectionKey, T extends CollectionMap[K], F extends OnlyKeysOfType<string | number, UnidentifiableModel<T>>>(collection: K, byKey: F, keyVal: string | number): AsyncResult<CollectionItemRemovalReply, StoreErrors>;
    enqueue<Q extends QueueKey, T extends QueueMap[Q]>(q: Q, item: UnidentifiableModel<T>): AsyncResult<void, StoreErrors>;
    dequeue<Q extends QueueKey, T extends QueueMap[Q]>(q: Q): AsyncResultWrapper<T | void, StoreErrors>;
    removeFromQueue<Q extends QueueKey, T extends QueueMap[Q]>(q: Q, item: T): AsyncResultWrapper<void, StoreErrors>;
    removeFromQueueIfExists<Q extends QueueKey, T extends QueueMap[Q]>(q: Q, item: T): AsyncResultWrapper<void, never>;
    getQueueSize<Q extends QueueKey>(q: Q): AsyncResultWrapper<number, StoreErrors>;
    flush(): AsyncResultWrapper<boolean, "GenericRedisFailure">;
}