@hotmeshio/hotmesh 0.0.3 → 0.0.5

package/build/esm/services/store/clients/redis.d.ts

@@ -0,0 +1,29 @@
+import { KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { SerializerService as Serializer } from '../../serializer';
+import { Cache } from '../cache';
+import { StoreService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
+import { ReclaimedMessageType } from '../../../types/stream';
+declare class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    cache: Cache;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    serializer: Serializer;
+    commands: Record<string, string>;
+    constructor(redisClient: RedisClientType);
+    getMulti(): RedisMultiType;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: RedisMultiType): Promise<any>;
+    zRangeByScoreWithScores(key: string, score: number | string, value: string | number): Promise<string | null>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    xadd(key: string, id: string, ...args: any[]): Promise<string | RedisMultiType>;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+}
+export { RedisStoreService };

package/build/esm/services/store/clients/redis.js

@@ -0,0 +1,140 @@
+import { StoreService } from '../index';
+class RedisStoreService extends StoreService {
+    constructor(redisClient) {
+        super(redisClient);
+        this.commands = {
+            setnx: 'SETNX',
+            del: 'DEL',
+            expire: 'EXPIRE',
+            hset: 'HSET',
+            hsetnx: 'HSETNX',
+            hincrby: 'HINCRBY',
+            hdel: 'HDEL',
+            hget: 'HGET',
+            hmget: 'HMGET',
+            hgetall: 'HGETALL',
+            hincrbyfloat: 'HINCRBYFLOAT',
+            zrange: 'ZRANGE',
+            zrangebyscore_withscores: 'ZRANGEBYSCORE_WITHSCORES',
+            zrangebyscore: 'ZRANGEBYSCORE',
+            zrem: 'ZREM',
+            zadd: 'ZADD',
+            lmove: 'LMOVE',
+            lrange: 'LRANGE',
+            llen: 'LLEN',
+            lpop: 'LPOP',
+            rename: 'RENAME',
+            rpush: 'RPUSH',
+            xack: 'XACK',
+            xdel: 'XDEL',
+        };
+    }
+    getMulti() {
+        const multi = this.redisClient.MULTI();
+        return multi;
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const status = await this.redisClient.publish(topic, JSON.stringify(message));
+        return this.isSuccessful(status);
+    }
+    async zAdd(key, score, value, redisMulti) {
+        return await (redisMulti || this.redisClient)[this.commands.zadd](key, { score: score, value: value.toString() });
+    }
+    async zRangeByScoreWithScores(key, score, value) {
+        const result = await this.redisClient[this.commands.zrangebyscore_withscores](key, score, value);
+        if (result?.length > 0) {
+            return result[0];
+        }
+        return null;
+    }
+    async zRangeByScore(key, score, value) {
+        const result = await this.redisClient[this.commands.zrangebyscore](key, score, value);
+        if (result?.length > 0) {
+            return result[0];
+        }
+        return null;
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
+        try {
+            return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
+        }
+        catch (err) {
+            const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
+            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, err);
+            throw err;
+        }
+    }
+    async xadd(key, id, ...args) {
+        let multi;
+        if (typeof args[args.length - 1] !== 'string') {
+            multi = args.pop();
+        }
+        try {
+            return await (multi || this.redisClient).XADD(key, id, { [args[0]]: args[1] });
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            const args = [key, group];
+            if (start)
+                args.push(start);
+            if (end)
+                args.push(end);
+            if (count !== undefined)
+                args.push(count.toString());
+            if (consumer)
+                args.push(consumer);
+            return await this.redisClient.sendCommand(['XPENDING', ...args]);
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.sendCommand(['XCLAIM', key, group, consumer, minIdleTime.toString(), id, ...args]);
+        }
+        catch (err) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xack(key, group, id, multi) {
+        try {
+            if (multi) {
+                multi[this.commands.xack](key, group, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient[this.commands.xack](key, group, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xdel(key, id, multi) {
+        try {
+            if (multi) {
+                multi[this.commands.xdel](key, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient[this.commands.xdel](key, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+export { RedisStoreService };

package/build/esm/services/store/index.d.ts

@@ -0,0 +1,88 @@
+import { KeyStoreParams, KeyType } from '../../modules/key';
+import { ILogger } from '../logger';
+import { SerializerService as Serializer } from '../serializer';
+import { Cache } from './cache';
+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 { SymbolSets, StringStringType, StringAnyType, Symbols } from '../../types/serializer';
+import { IdsData, JobStatsRange, StatsType } from '../../types/stats';
+import { Transitions } from '../../types/transition';
+import { ReclaimedMessageType } from '../../types/stream';
+interface AbstractRedisClient {
+    exec(): any;
+}
+declare abstract class StoreService<T, U extends AbstractRedisClient> {
+    redisClient: T;
+    cache: Cache;
+    serializer: Serializer;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    commands: Record<string, string>;
+    abstract getMulti(): U;
+    abstract publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    abstract xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    abstract xadd(key: string, id: string, messageId: string, messageValue: string, multi?: U): Promise<string | U>;
+    abstract xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+    abstract xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    abstract xack(key: string, group: string, id: string, multi?: U): Promise<number | U>;
+    abstract xdel(key: string, id: string, multi?: U): Promise<number | U>;
+    constructor(redisClient: T);
+    init(namespace: string, appId: string, logger: ILogger): Promise<HotMeshApps>;
+    isSuccessful(result: any): boolean;
+    zAdd(key: string, score: number | string, value: string | number, redisMulti?: U): Promise<any>;
+    zRangeByScoreWithScores(key: string, score: number | string, value: string | number): Promise<string | null>;
+    zRangeByScore(key: string, score: number | string, value: string | number): Promise<string | null>;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    invalidateCache(): void;
+    reserveEngineId(engineId: string): Promise<boolean>;
+    getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
+    setSettings(manifest: HotMeshSettings): Promise<any>;
+    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY'): Promise<[number, number, 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, multi?: U): 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, multi?: U): Promise<any>;
+    getStatus(jobId: string, appId: string): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, multi?: U): Promise<string>;
+    getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, multi?: U): Promise<number>;
+    setStateNX(jobId: string, appId: string): 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, multi?: U): 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): Promise<void>;
+    processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
+    expireJob(jobId: string, inSeconds: number): Promise<void>;
+    registerTimeHook(jobId: string, activityId: string, type: 'sleep' | 'expire' | 'cron', deletionTime: number, multi?: U): Promise<void>;
+    getNextTimeJob(listKey?: string): Promise<[listKey: string, jobId: string, activityId: string] | void>;
+    scrub(jobId: string): Promise<void>;
+}
+export { StoreService };