@hotmeshio/hotmesh 0.4.0 → 0.4.1

package/build/services/store/providers/redis/_base.d.ts

@@ -0,0 +1,137 @@
+import { KeyStoreParams, KeyType } from '../../../../modules/key';
+import { ILogger } from '../../../logger';
+import { ActivityType, Consumes } from '../../../../types/activity';
+import { AppVID } from '../../../../types/app';
+import { HookRule, HookSignal } from '../../../../types/hook';
+import { HotMeshApp, HotMeshApps, HotMeshSettings } from '../../../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../../../types/provider';
+import { SymbolSets, StringStringType, StringAnyType, Symbols } from '../../../../types/serializer';
+import { IdsData, JobStatsRange, StatsType } from '../../../../types/stats';
+import { Transitions } from '../../../../types/transition';
+import { JobInterruptOptions } from '../../../../types/job';
+import { WorkListTaskType } from '../../../../types/task';
+import { ThrottleOptions } from '../../../../types/quorum';
+import { StoreService } from '../..';
+declare abstract class RedisStoreBase<ClientProvider extends ProviderClient, TransactionProvider extends ProviderTransaction> extends StoreService<ClientProvider, TransactionProvider> {
+    commands: Record<string, string>;
+    abstract transact(): TransactionProvider;
+    abstract exec(...args: any[]): Promise<any>;
+    abstract setnxex(key: string, value: string, expireSeconds: number): Promise<boolean>;
+    constructor(storeClient: ClientProvider);
+    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    isSuccessful(result: any): boolean;
+    delistSignalKey(key: string, target: string): Promise<void>;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: TransactionProvider): Promise<any>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    invalidateCache(): void;
+    /**
+     * At any given time only a single engine will
+     * check for and process work items in the
+     * time and signal task queues.
+     */
+    reserveScoutRole(scoutType: 'time' | 'signal' | 'activate', delay?: number): Promise<boolean>;
+    releaseScoutRole(scoutType: 'time' | 'signal' | 'activate'): Promise<boolean>;
+    getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
+    setSettings(manifest: HotMeshSettings): Promise<any>;
+    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY', tryCount?: number): Promise<[number, number, Symbols]>;
+    getAllSymbols(): Promise<Symbols>;
+    getSymbols(activityId: string): Promise<Symbols>;
+    addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
+    seedSymbols(target: string, type: 'JOB' | 'ACTIVITY', startIndex: number): StringStringType;
+    seedJobSymbols(startIndex: number): StringStringType;
+    seedActivitySymbols(startIndex: number, activityId: string): StringStringType;
+    getSymbolValues(): Promise<Symbols>;
+    addSymbolValues(symvals: Symbols): Promise<boolean>;
+    getSymbolKeys(symbolNames: string[]): Promise<SymbolSets>;
+    getApp(id: string, refresh?: boolean): Promise<HotMeshApp>;
+    setApp(id: string, version: string): Promise<HotMeshApp>;
+    activateAppVersion(id: string, version: string): Promise<boolean>;
+    registerAppVersion(appId: string, version: string): Promise<any>;
+    setStats(jobKey: string, jobId: string, dateTime: string, stats: StatsType, appVersion: AppVID, transaction?: TransactionProvider): Promise<any>;
+    hGetAllResult(result: any): any;
+    getJobStats(jobKeys: string[]): Promise<JobStatsRange>;
+    getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
+    setStatus(collationKeyStatus: number, jobId: string, appId: string, transaction?: TransactionProvider): Promise<any>;
+    getStatus(jobId: string, appId: string): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, transaction?: TransactionProvider): Promise<string>;
+    /**
+     * Returns custom search fields and values.
+     * NOTE: The `fields` param should NOT prefix items with an underscore.
+     * NOTE: Literals are allowed if quoted.
+     */
+    getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
+    getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    getRaw(jobId: string): Promise<StringStringType>;
+    /**
+     * collate is a generic method for incrementing a value in a hash
+     * in order to track their progress during processing.
+     */
+    collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, transaction?: TransactionProvider): Promise<number>;
+    /**
+     * Synthentic collation affects those activities in the graph
+     * that represent the synthetic DAG that was materialized during compilation;
+     * Synthetic collation distinguishes `re-entry due to failure` from
+     * `purposeful re-entry`.
+     */
+    collateSynthetic(jobId: string, guid: string, amount: number, transaction?: TransactionProvider): Promise<number>;
+    setStateNX(jobId: string, appId: string, status?: number): Promise<boolean>;
+    getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
+    getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;
+    setSchemas(schemas: Record<string, ActivityType>, appVersion: AppVID): Promise<any>;
+    setSubscriptions(subscriptions: Record<string, any>, appVersion: AppVID): Promise<boolean>;
+    getSubscriptions(appVersion: AppVID): Promise<Record<string, string>>;
+    getSubscription(topic: string, appVersion: AppVID): Promise<string | undefined>;
+    setTransitions(transitions: Record<string, any>, appVersion: AppVID): Promise<any>;
+    getTransitions(appVersion: AppVID): Promise<Transitions>;
+    setHookRules(hookRules: Record<string, HookRule[]>): Promise<any>;
+    getHookRules(): Promise<Record<string, HookRule[]>>;
+    setHookSignal(hook: HookSignal, transaction?: TransactionProvider): Promise<any>;
+    getHookSignal(topic: string, resolved: string): Promise<string | undefined>;
+    deleteHookSignal(topic: string, resolved: string): Promise<number | undefined>;
+    addTaskQueues(keys: string[]): Promise<void>;
+    getActiveTaskQueue(): Promise<string | null>;
+    deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string, scrub?: boolean): Promise<void>;
+    processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
+    expireJob(jobId: string, inSeconds: number, redisMulti?: TransactionProvider): Promise<void>;
+    getDependencies(jobId: string): Promise<string[]>;
+    /**
+     * registers a hook activity to be awakened (uses ZSET to
+     * store the 'sleep group' and LIST to store the events
+     * for the given sleep group. Sleep groups are
+     * organized into 'n'-second blocks (LISTS))
+     */
+    registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, deletionTime: number, dad: string, transaction?: TransactionProvider): Promise<void>;
+    getNextTask(listKey?: string): Promise<[
+        listKey: string,
+        jobId: string,
+        gId: string,
+        activityId: string,
+        type: WorkListTaskType
+    ] | boolean>;
+    /**
+     * when processing time jobs, the target LIST ID returned
+     * from the ZSET query can be prefixed to denote what to
+     * do with the work list. (not everything is known in advance,
+     * so the ZSET key defines HOW to approach the work in the
+     * generic LIST (lists typically contain target job ids)
+     * @param {string} listKey - composite key
+     */
+    resolveTaskKeyContext(listKey: string): [WorkListTaskType, string];
+    /**
+     * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
+     * This method is called by the engine and not by an activity and is
+     * followed by a call to execute job completion/cleanup tasks
+     * associated with a job completion event.
+     *
+     * Todo: move most of this logic to the engine (too much logic for the store)
+     */
+    interrupt(topic: string, jobId: string, options?: JobInterruptOptions): Promise<void>;
+    scrub(jobId: string): Promise<void>;
+    findJobs(queryString?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, string[]]>;
+    findJobFields(jobId: string, fieldMatchPattern?: string, limit?: number, batchSize?: number, cursor?: string): Promise<[string, StringStringType]>;
+    setThrottleRate(options: ThrottleOptions): Promise<void>;
+    getThrottleRates(): Promise<StringStringType>;
+    getThrottleRate(topic: string): Promise<number>;
+}
+export { RedisStoreBase };