@hotmeshio/hotmesh 0.0.8 → 0.0.9

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

@@ -1,29 +0,0 @@
-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

@@ -1,140 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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 };