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

A Relational Redis Store

import { AsyncResult } from 'ts-async-results';
export declare type UnidentifiableModel<T extends {}> = Omit<T, 'id'>;
export declare type ModelWithoutTimestamps<T extends {}> = Omit<T, 'createdAt' | 'updatedAt'>;
export declare type UnknownRecord = Record<string, unknown>;
export declare type CollectionItemOrReply<T> = {
    index: number;
    length: number;
    item: T;
};
export declare type ForeignKeys<T extends {}, CollectionsMap extends {}> = {
    [k in keyof Partial<UnidentifiableModel<T>>]: ForeignOneToOneKeys<CollectionsMap> | ForeignOneToManyKeys<CollectionsMap>;
};
declare type ForeignOneToOneKeys<CollectionsMap extends {}> = {
    type: 'oneToOne';
    collection: keyof CollectionsMap;
};
declare type ForeignOneToManyKeys<CollectionsMap extends {}> = {
    type: 'oneToMany';
    collection: keyof CollectionsMap;
};
export declare type CollectionMapBase = {
    [key: string]: {
        id: string;
    } & object;
};
export declare type QueueMapBase = {
    [key: string]: object;
};
export declare type CollectionItemRemovalReply = CollectionItemOrReply<void>;
export declare type CollectionItemMetadata<T, CollectionMap extends CollectionMapBase> = {
    val: CollectionItem<UnidentifiableModel<T>>;
    id: string;
    foreignKeys?: ForeignKeys<T, CollectionMap>;
    indexedIn?: {
        [collection: string]: string;
    };
};
export declare type CollectionItemMetadataReply<T extends {}, CollectionMap extends CollectionMapBase> = CollectionItemMetadata<T, CollectionMap> & {
    foreignItems: Partial<{
        oneToOne: {
            [index in keyof OnlyKeysOfType<ForeignOneToOneKeys<CollectionMap>, NonNullable<CollectionItemMetadata<T, CollectionMap>['foreignKeys']>>]: CollectionItemMetadataReply<CollectionMap[keyof CollectionMap], CollectionMap>;
        };
        oneToMany: {
            [index in keyof OnlyKeysOfType<ForeignOneToManyKeys<CollectionMap>, NonNullable<CollectionItemMetadata<T, CollectionMap>['foreignKeys']>>]: CollectionItemMetadataReply<CollectionMap[keyof CollectionMap], CollectionMap>;
        };
    }>;
};
declare type NewObjKeysMap<Obj extends {}> = {
    [F in keyof Obj]: {
        [key: string]: null;
    };
};
declare type NewObjSingleKey<Obj extends {}> = {
    [F in keyof Obj]: string;
};
declare type NewObjKeysFromForeignKeys<T extends {}, CollectionMap extends CollectionMapBase, FKs extends ForeignKeys<T, CollectionMap>> = Omit<T, keyof ObjectWithOnlyKeysOfType<ForeignOneToManyKeys<CollectionMap>, FKs> | keyof ObjectWithOnlyKeysOfType<ForeignOneToOneKeys<CollectionMap>, FKs>> & NewObjKeysMap<ObjectWithOnlyKeysOfType<ForeignOneToManyKeys<CollectionMap>, FKs>> & NewObjSingleKey<ObjectWithOnlyKeysOfType<ForeignOneToOneKeys<CollectionMap>, FKs>>;
export declare type CollectionItemWithForeignKeys<T extends {}, CollectionsMap extends {}, FKs extends ForeignKeys<T, CollectionsMap>> = NewObjKeysFromForeignKeys<T, CollectionsMap, FKs>;
export declare type CollectionItemWithoutForeignKeys<T extends {}> = T;
export declare type CollectionItem<T extends {}, CollectionsMap extends CollectionMapBase = {}, FKs extends ForeignKeys<T, CollectionsMap> = any> = CollectionItemWithForeignKeys<T, CollectionsMap, FKs>;
export declare type IsOfType<U, T, K> = T extends U ? K : never;
export declare type OnlyKeysOfType<T, O extends {}> = {
    [K in keyof O]: IsOfType<T, O[K], K>;
}[keyof O];
declare type ObjectWithOnlyKeysOfType<T, O extends {}> = Pick<O, OnlyKeysOfType<T, O>>;
export declare type CollectionItemUpdateableProps<T extends {}> = Partial<CollectionItemWithoutForeignKeys<UnidentifiableModel<T>>>;
export declare type CollectionItemUpdateablePrev<T extends {}> = CollectionItemWithoutForeignKeys<UnidentifiableModel<T>>;
export declare type UpdateableCollectionPropsGetter<T extends {}> = CollectionItemUpdateableProps<T> | ((prev: CollectionItemUpdateablePrev<T>) => CollectionItemUpdateableProps<T> | AsyncResult<CollectionItemUpdateableProps<T>, unknown>);
export declare const toCollectionId: (collection: string, id: string) => string;
export declare const toQueueName: (queue: string) => string;
export declare const toIndexedCollectionName: (collection: string, byField: string | number) => string;
export declare const getByFieldNameFromIndexedCollection: (indexedCollection: string) => string;
export declare const objectKeys: <O extends object>(o: O) => (keyof O)[];
export declare const delay: (ms: number) => Promise<unknown>;
export {};