@hotmeshio/hotmesh 0.0.4 → 0.0.5

package/build/esm/services/signaler/stream.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" />
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { StreamService } from '../stream';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { ReclaimedMessageType, StreamConfig, StreamData, StreamDataResponse, StreamRole } from '../../types/stream';
+declare class StreamSignaler {
+    static signalers: Set<StreamSignaler>;
+    appId: string;
+    guid: string;
+    role: StreamRole;
+    topic: string | undefined;
+    store: StoreService<RedisClient, RedisMulti>;
+    stream: StreamService<RedisClient, RedisMulti>;
+    reclaimDelay: number;
+    reclaimCount: number;
+    logger: ILogger;
+    throttle: number;
+    errorCount: number;
+    currentTimerId: NodeJS.Timeout | null;
+    shouldConsume: boolean;
+    constructor(config: StreamConfig, stream: StreamService<RedisClient, RedisMulti>, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
+    createGroup(stream: string, group: string): Promise<void>;
+    publishMessage(topic: string, streamData: StreamData | StreamDataResponse, multi?: RedisMulti): Promise<string | RedisMulti>;
+    consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
+    isStreamMessage(result: any): boolean;
+    consumeOne(stream: string, group: string, id: string, message: string[], callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
+    execStreamLeg(input: StreamData, stream: string, id: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<StreamDataResponse>;
+    ackAndDelete(stream: string, group: string, id: string): Promise<void>;
+    publishResponse(input: StreamData, output: StreamDataResponse | void): Promise<string>;
+    shouldRetry(input: StreamData, output: StreamDataResponse): [boolean, number];
+    structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
+    structureUnacknowledgedError(input: StreamData): StreamDataResponse;
+    structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
+    static stopConsuming(): Promise<void>;
+    stopConsuming(): Promise<void>;
+    cancelThrottle(): void;
+    setThrottle(delayInMillis: number): void;
+    claimUnacknowledged(stream: string, group: string, consumer: string, idleTimeMs?: number, limit?: number): Promise<[string, [string, string]][]>;
+    expireUnacknowledged(reclaimedMessage: ReclaimedMessageType, stream: string, group: string, consumer: string, id: string, count: number): Promise<void>;
+    parseStreamData(str: string): [undefined, StreamData] | [Error];
+}
+export { StreamSignaler };

package/build/esm/services/signaler/stream.js

@@ -0,0 +1,315 @@
+import { KeyType } from '../../modules/key';
+import { XSleepFor, sleepFor } from '../../modules/utils';
+import { TelemetryService } from '../telemetry';
+import { StreamDataType, StreamRole, StreamStatus } from '../../types/stream';
+const MAX_RETRIES = 4; //max delay (10s using exponential backoff);
+const MAX_TIMEOUT_MS = 60000;
+const GRADUATED_INTERVAL_MS = 5000;
+const BLOCK_DURATION = 15000; //Set to `15` so SIGINT/SIGTERM can interrupt; set to `0` to BLOCK indefinitely
+const TEST_BLOCK_DURATION = 1000; //Set to `1000` so tests can interrupt quickly
+const BLOCK_TIME_MS = process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BLOCK_DURATION;
+const SYSTEM_STATUS_CODE = 999;
+const UNKNOWN_STATUS_CODE = 500;
+const UNKNOWN_STATUS_MESSAGE = 'unknown';
+const XCLAIM_DELAY_MS = 1000 * 60; //max time a message can be unacked before it is claimed by another
+const XCLAIM_COUNT = 3; //max number of times a message can be claimed by another before it is dead-lettered
+const XPENDING_COUNT = 10;
+class StreamSignaler {
+    constructor(config, stream, store, logger) {
+        this.throttle = 0;
+        this.errorCount = 0;
+        this.currentTimerId = null;
+        this.appId = config.appId;
+        this.guid = config.guid;
+        this.role = config.role;
+        this.topic = config.topic;
+        this.stream = stream;
+        this.store = store;
+        this.reclaimDelay = config.reclaimDelay || XCLAIM_DELAY_MS;
+        this.reclaimCount = config.reclaimCount || XCLAIM_COUNT;
+        this.logger = logger;
+    }
+    async createGroup(stream, group) {
+        try {
+            await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
+        }
+        catch (err) {
+            this.logger.info('consumer-group-exists', { stream, group });
+        }
+    }
+    async publishMessage(topic, streamData, multi) {
+        const stream = this.store.mintKey(KeyType.STREAMS, { appId: this.store.appId, topic });
+        return await this.store.xadd(stream, '*', 'message', JSON.stringify(streamData), multi);
+    }
+    async consumeMessages(stream, group, consumer, callback) {
+        this.logger.info(`stream-consumer-starting`, { group, consumer, stream });
+        StreamSignaler.signalers.add(this);
+        this.shouldConsume = true;
+        await this.createGroup(stream, group);
+        let lastCheckedPendingMessagesAt = Date.now();
+        async function consume() {
+            let sleep = XSleepFor(this.throttle);
+            this.currentTimerId = sleep.timerId;
+            await sleep.promise;
+            if (!this.shouldConsume) {
+                this.logger.info(`stream-consumer-stopping`, { group, consumer, stream });
+                return;
+            }
+            try {
+                const result = await this.stream.xreadgroup('GROUP', group, consumer, 'BLOCK', BLOCK_TIME_MS, 'STREAMS', stream, '>');
+                if (this.isStreamMessage(result)) {
+                    const [[, messages]] = result;
+                    for (const [id, message] of messages) {
+                        await this.consumeOne(stream, group, id, message, callback);
+                    }
+                }
+                // Check for pending messages (note: Redis 6.2 simplifies)
+                const now = Date.now();
+                if (now - lastCheckedPendingMessagesAt > this.reclaimDelay) {
+                    lastCheckedPendingMessagesAt = now;
+                    const pendingMessages = await this.claimUnacknowledged(stream, group, consumer);
+                    for (const [id, message] of pendingMessages) {
+                        await this.consumeOne(stream, group, id, message, callback);
+                    }
+                }
+                setImmediate(consume.bind(this));
+            }
+            catch (err) {
+                if (this.shouldConsume && process.env.NODE_ENV !== 'test') {
+                    this.logger.error(`stream-consume-message-error`, { err, stream, group, consumer });
+                    this.errorCount++;
+                    const timeout = Math.min(GRADUATED_INTERVAL_MS * (2 ** this.errorCount), MAX_TIMEOUT_MS);
+                    setTimeout(consume.bind(this), timeout);
+                }
+            }
+        }
+        consume.call(this);
+    }
+    isStreamMessage(result) {
+        return Array.isArray(result) && Array.isArray(result[0]);
+    }
+    async consumeOne(stream, group, id, message, callback) {
+        this.logger.debug(`stream-consume-one`, { group, stream, id });
+        const [err, input] = this.parseStreamData(message[1]);
+        let output;
+        let telemetry;
+        try {
+            telemetry = new TelemetryService(this.appId);
+            telemetry.startStreamSpan(input, this.role);
+            output = await this.execStreamLeg(input, stream, id, callback.bind(this));
+            if (output?.status === StreamStatus.ERROR) {
+                telemetry.setStreamError(`Function Status Code ${output.code || UNKNOWN_STATUS_CODE}`);
+            }
+            this.errorCount = 0;
+        }
+        catch (err) {
+            this.logger.error(`stream-consume-one-error`, { group, stream, id, err });
+            telemetry.setStreamError(err.message);
+        }
+        const messageId = await this.publishResponse(input, output);
+        telemetry.setStreamAttributes({ 'app.worker.mid': messageId });
+        await this.ackAndDelete(stream, group, id);
+        telemetry.endStreamSpan();
+        this.logger.debug(`stream-consume-one-end`, { group, stream, id });
+    }
+    async execStreamLeg(input, stream, id, callback) {
+        let output;
+        try {
+            output = await callback(input);
+        }
+        catch (err) {
+            console.error(err);
+            this.logger.error(`stream-call-function-error`, { stream, id, err });
+            output = this.structureUnhandledError(input, err);
+        }
+        return output;
+    }
+    async ackAndDelete(stream, group, id) {
+        const multi = this.stream.getMulti();
+        await this.stream.xack(stream, group, id, multi);
+        await this.stream.xdel(stream, id, multi);
+        await multi.exec();
+    }
+    async publishResponse(input, output) {
+        if (output && typeof output === 'object') {
+            if (output.status === 'error') {
+                const [shouldRetry, timeout] = this.shouldRetry(input, output);
+                if (shouldRetry) {
+                    await sleepFor(timeout);
+                    return await this.publishMessage(input.metadata.topic, {
+                        data: input.data,
+                        metadata: { ...input.metadata, try: (input.metadata.try || 0) + 1 },
+                        policies: input.policies,
+                    });
+                }
+                else {
+                    output = this.structureError(input, output);
+                }
+            }
+            output.type = StreamDataType.RESPONSE;
+            return await this.publishMessage(null, output);
+        }
+    }
+    shouldRetry(input, output) {
+        const policies = input.policies?.retry;
+        const errorCode = output.code.toString();
+        const policy = policies?.[errorCode];
+        const maxRetries = policy?.[0];
+        const tryCount = Math.min(input.metadata.try || 0, MAX_RETRIES);
+        if (maxRetries >= tryCount) {
+            return [true, Math.pow(10, tryCount)];
+        }
+        return [false, 0];
+    }
+    structureUnhandledError(input, err) {
+        let error = {};
+        if (typeof err.message === 'string') {
+            error.message = err.message;
+        }
+        else {
+            error.message = UNKNOWN_STATUS_MESSAGE;
+        }
+        if (typeof err.stack === 'string') {
+            error.stack = err.stack;
+        }
+        if (typeof err.name === 'string') {
+            error.name = err.name;
+        }
+        return {
+            status: 'error',
+            code: UNKNOWN_STATUS_CODE,
+            metadata: { ...input.metadata },
+            data: error
+        };
+    }
+    structureUnacknowledgedError(input) {
+        const message = 'stream message max delivery count exceeded';
+        const code = SYSTEM_STATUS_CODE;
+        const data = { message, code };
+        const output = {
+            metadata: { ...input.metadata },
+            status: StreamStatus.ERROR,
+            code,
+            data,
+        };
+        //send unacknowleded errors to the engine (it has no topic)
+        delete output.metadata.topic;
+        return output;
+    }
+    structureError(input, output) {
+        const message = output.data?.message ? output.data?.message.toString() : UNKNOWN_STATUS_MESSAGE;
+        const statusCode = output.code || output.data?.code;
+        const code = isNaN(statusCode) ? UNKNOWN_STATUS_CODE : parseInt(statusCode.toString());
+        const data = { message, code };
+        if (typeof output.data?.error === 'object') {
+            data.error = { ...output.data.error };
+        }
+        return {
+            status: StreamStatus.ERROR,
+            code,
+            metadata: { ...input.metadata },
+            data
+        };
+    }
+    static async stopConsuming() {
+        for (const instance of [...StreamSignaler.signalers]) {
+            instance.stopConsuming();
+        }
+        await sleepFor(BLOCK_TIME_MS);
+    }
+    async stopConsuming() {
+        this.shouldConsume = false;
+        this.logger.info(`stream-consumer-stopping`, this.topic ? { topic: this.topic } : undefined);
+        this.cancelThrottle();
+        await sleepFor(BLOCK_TIME_MS);
+    }
+    cancelThrottle() {
+        if (this.currentTimerId !== undefined) {
+            clearTimeout(this.currentTimerId);
+            this.currentTimerId = undefined;
+        }
+    }
+    setThrottle(delayInMillis) {
+        if (!Number.isInteger(delayInMillis) || delayInMillis < 0) {
+            throw new Error('Throttle must be a non-negative integer');
+        }
+        this.throttle = delayInMillis;
+        this.logger.info(`stream-throttle-reset`, { delay: this.throttle, topic: this.topic });
+    }
+    async claimUnacknowledged(stream, group, consumer, idleTimeMs = this.reclaimDelay, limit = XPENDING_COUNT) {
+        let pendingMessages = [];
+        const pendingMessagesInfo = await this.stream.xpending(stream, group, '-', '+', limit); //[[ '1688768134881-0', 'testConsumer1', 1017, 1 ]]
+        for (const pendingMessageInfo of pendingMessagesInfo) {
+            if (Array.isArray(pendingMessageInfo)) {
+                const [id, , elapsedTimeMs, deliveryCount] = pendingMessageInfo;
+                if (elapsedTimeMs > idleTimeMs) {
+                    const reclaimedMessage = await this.stream.xclaim(stream, group, consumer, idleTimeMs, id);
+                    if (reclaimedMessage.length) {
+                        if (deliveryCount <= this.reclaimCount) {
+                            pendingMessages = pendingMessages.concat(reclaimedMessage);
+                        }
+                        else {
+                            await this.expireUnacknowledged(reclaimedMessage, stream, group, consumer, id, deliveryCount);
+                        }
+                    }
+                }
+            }
+        }
+        return pendingMessages;
+    }
+    async expireUnacknowledged(reclaimedMessage, stream, group, consumer, id, count) {
+        //The stream activity was not processed within established limits. Possibilities Include:
+        // 1) user error: the workers were not properly configured and are timing out
+        // 2a) system error: JSON is corrupt
+        //     i) bad/unwitting actor
+        //     ii) corrupt hardware/network/transport/etc
+        // 3b) system error: Redis unable to accept `xadd` request
+        // 4c) system error: Redis unable to accept `xdel`/`xack` request
+        this.logger.error('stream-message-max-delivery-count-exceeded', { id, stream, group, consumer, code: SYSTEM_STATUS_CODE, count });
+        const streamData = reclaimedMessage[0]?.[1]?.[1];
+        //fatal risk point 1 of 3): json is corrupt
+        const [err, input] = this.parseStreamData(streamData);
+        if (err) {
+            return this.logger.error('expire-unacknowledged-parse-fatal-error', { id, err });
+        }
+        else if (!input || !input.metadata) {
+            return this.logger.error('expire-unacknowledged-parse-fatal-error', { id });
+        }
+        let telemetry;
+        let messageId;
+        try {
+            telemetry = new TelemetryService(this.appId);
+            telemetry.startStreamSpan(input, StreamRole.SYSTEM);
+            telemetry.setStreamError(`Stream Message Max Delivery Count Exceeded`);
+            //fatal risk point 2 of 3): unable to publish error message (to notify the parent job)
+            const output = this.structureUnacknowledgedError(input);
+            messageId = await this.publishResponse(input, output);
+            telemetry.setStreamAttributes({ 'app.worker.mid': messageId });
+            //fatal risk point 3 of 3): unable to ack and delete stream message
+            await this.ackAndDelete(stream, group, id);
+        }
+        catch (err) {
+            if (messageId) {
+                this.logger.error('expire-unacknowledged-pub-fatal-error', { id, err, ...input.metadata });
+                telemetry.setStreamAttributes({ 'app.system.fatal': 'expire-unacknowledged-pub-fatal-error' });
+            }
+            else {
+                this.logger.error('expire-unacknowledged-ack-fatal-error', { id, err, ...input.metadata });
+                telemetry.setStreamAttributes({ 'app.system.fatal': 'expire-unacknowledged-ack-fatal-error' });
+            }
+        }
+        finally {
+            telemetry.endStreamSpan();
+        }
+    }
+    parseStreamData(str) {
+        try {
+            return [, JSON.parse(str)];
+        }
+        catch (e) {
+            return [e];
+        }
+    }
+}
+StreamSignaler.signalers = new Set();
+export { StreamSignaler };

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

@@ -0,0 +1,66 @@
+/**
+ * The Cache is a key/value store and used to store commonly accessed Redis metadata
+ * (mainly the execution rules for the app) to save time accessing them as they
+ * are immutable per verison. The only time the rules are ejected are when
+ * a new version is deployed to the quorum and the cache is invalidated/cleared.
+ */
+import { ActivityType } from "../../types/activity";
+import { HookRule } from "../../types/hook";
+import { HotMeshApp, HotMeshSettings } from "../../types/hotmesh";
+import { Symbols } from "../../types/serializer";
+import { Transitions } from "../../types/transition";
+declare class Cache {
+    settings: HotMeshSettings;
+    appId: string;
+    apps: Record<string, HotMeshApp>;
+    schemas: Record<string, ActivityType>;
+    subscriptions: Record<string, Record<string, string>>;
+    symbols: Record<string, Symbols>;
+    symvals: Record<string, Symbols>;
+    transitions: Record<string, Record<string, unknown>>;
+    hookRules: Record<string, Record<string, HookRule[]>>;
+    workItems: Record<string, string>;
+    /**
+     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
+     * @param settings
+     * @param apps
+     * @param schemas
+     * @param subscriptions
+     * @param transitions
+     * @param hookRules
+     */
+    constructor(appId: string, settings: HotMeshSettings, apps?: Record<string, HotMeshApp>, schemas?: Record<string, ActivityType>, subscriptions?: Record<string, Record<string, string>>, symbols?: Record<string, Symbols>, symvals?: Record<string, Symbols>, transitions?: Record<string, Record<string, unknown>>, hookRules?: Record<string, Record<string, HookRule[]>>, workItems?: Record<string, string>);
+    /**
+     * invalidate the cache; settings are not invalidated!
+     */
+    invalidate(): void;
+    getSettings(): HotMeshSettings;
+    setSettings(settings: HotMeshSettings): void;
+    getApps(): Record<string, HotMeshApp>;
+    getApp(appId: string): HotMeshApp;
+    setApps(apps: Record<string, HotMeshApp>): void;
+    setApp(appId: string, app: HotMeshApp): void;
+    getSchemas(appId: string, version: string): Record<string, ActivityType>;
+    getSchema(appId: string, version: string, activityId: string): ActivityType;
+    setSchemas(appId: string, version: string, schemas: Record<string, ActivityType>): void;
+    setSchema(appId: string, version: string, activityId: string, schema: ActivityType): void;
+    getSubscriptions(appId: string, version: string): Record<string, string>;
+    getSubscription(appId: string, version: string, topic: string): unknown;
+    setSubscriptions(appId: string, version: string, subscriptions: Record<string, string>): void;
+    getSymbols(appId: string, targetEntityId: string): Symbols;
+    setSymbols(appId: string, targetEntityId: string, symbols: Symbols): void;
+    deleteSymbols(appId: string, targetEntityId: string): void;
+    getSymbolValues(appId: string): Symbols;
+    setSymbolValues(appId: string, symvals: Symbols): void;
+    deleteSymbolValues(appId: string): void;
+    getTransitions(appId: string, version: string): Transitions;
+    setTransitions(appId: string, version: string, transitions: Transitions): void;
+    getHookRules(appId: string): Record<string, HookRule[]>;
+    setHookRules(appId: string, hookRules: Record<string, HookRule[]>): void;
+    getSignals(appId: string, version: string): Record<string, unknown>;
+    setSignals(appId: string, version: string): Record<string, unknown>;
+    getActiveTaskQueue(appId: string): string;
+    setWorkItem(appId: string, workItem: string): void;
+    removeWorkItem(appId: string): void;
+}
+export { Cache };

package/build/esm/services/store/cache.js

@@ -0,0 +1,124 @@
+/**
+ * The Cache is a key/value store and used to store commonly accessed Redis metadata
+ * (mainly the execution rules for the app) to save time accessing them as they
+ * are immutable per verison. The only time the rules are ejected are when
+ * a new version is deployed to the quorum and the cache is invalidated/cleared.
+ */
+class Cache {
+    /**
+     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
+     * @param settings
+     * @param apps
+     * @param schemas
+     * @param subscriptions
+     * @param transitions
+     * @param hookRules
+     */
+    constructor(appId, settings, apps = {}, schemas = {}, subscriptions = {}, symbols = {}, symvals = {}, transitions = {}, hookRules = {}, workItems = {}) {
+        this.appId = appId;
+        this.settings = settings;
+        this.apps = apps;
+        this.schemas = schemas;
+        this.subscriptions = subscriptions;
+        this.symbols = symbols;
+        this.symvals = symvals;
+        this.transitions = transitions;
+        this.hookRules = hookRules;
+        this.workItems = workItems;
+    }
+    /**
+     * invalidate the cache; settings are not invalidated!
+     */
+    invalidate() {
+        this.apps = {};
+        this.schemas = {};
+        this.subscriptions = {};
+        this.transitions = {};
+        this.hookRules = {};
+    }
+    getSettings() {
+        return this.settings;
+    }
+    setSettings(settings) {
+        this.settings = settings;
+    }
+    getApps() {
+        return this.apps;
+    }
+    getApp(appId) {
+        return this.apps[appId];
+    }
+    setApps(apps) {
+        this.apps = apps;
+    }
+    setApp(appId, app) {
+        this.apps[appId] = app;
+    }
+    getSchemas(appId, version) {
+        return this.schemas[`${appId}/${version}`];
+    }
+    getSchema(appId, version, activityId) {
+        return this.schemas?.[`${appId}/${version}`]?.[activityId];
+    }
+    setSchemas(appId, version, schemas) {
+        this.schemas[`${appId}/${version}`] = schemas;
+    }
+    setSchema(appId, version, activityId, schema) {
+        this.schemas[`${appId}/${version}`][activityId] = schema;
+    }
+    getSubscriptions(appId, version) {
+        return this.subscriptions[`${appId}/${version}`];
+    }
+    getSubscription(appId, version, topic) {
+        return this.subscriptions?.[`${appId}/${version}`]?.[topic];
+    }
+    setSubscriptions(appId, version, subscriptions) {
+        this.subscriptions[`${appId}/${version}`] = subscriptions;
+    }
+    getSymbols(appId, targetEntityId) {
+        return this.symbols[`${appId}/${targetEntityId}`];
+    }
+    setSymbols(appId, targetEntityId, symbols) {
+        this.symbols[`${appId}/${targetEntityId}`] = symbols;
+    }
+    deleteSymbols(appId, targetEntityId) {
+        delete this.symbols[`${appId}/${targetEntityId}`];
+    }
+    getSymbolValues(appId) {
+        return this.symvals[`${appId}`];
+    }
+    setSymbolValues(appId, symvals) {
+        this.symvals[`${appId}`] = symvals;
+    }
+    deleteSymbolValues(appId) {
+        delete this.symvals[`${appId}`];
+    }
+    getTransitions(appId, version) {
+        return this.transitions[`${appId}/${version}`];
+    }
+    setTransitions(appId, version, transitions) {
+        this.transitions[`${appId}/${version}`] = transitions;
+    }
+    getHookRules(appId) {
+        return this.hookRules[`${appId}`];
+    }
+    setHookRules(appId, hookRules) {
+        this.hookRules[`${appId}`] = hookRules;
+    }
+    getSignals(appId, version) {
+        throw new Error("SIGNAL (getHooks) is not supported");
+    }
+    setSignals(appId, version) {
+        throw new Error("SIGNAL (setHook) is not supported");
+    }
+    getActiveTaskQueue(appId) {
+        return this.workItems[appId];
+    }
+    setWorkItem(appId, workItem) {
+        this.workItems[appId] = workItem;
+    }
+    removeWorkItem(appId) {
+        delete this.workItems[appId];
+    }
+}
+export { Cache };

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

@@ -0,0 +1,27 @@
+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/ioredisclient';
+import { ReclaimedMessageType } from '../../../types/stream';
+declare class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    cache: Cache;
+    namespace: string;
+    appId: string;
+    logger: ILogger;
+    serializer: Serializer;
+    constructor(redisClient: RedisClientType);
+    getMulti(): RedisMultiType;
+    hGetAllResult(result: any): any;
+    addTaskQueues(keys: string[]): Promise<void>;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    xadd(key: string, id: string, messageId: string, messageValue: string, multi?: RedisMultiType): 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] | unknown[]>;
+    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 { IORedisStoreService };

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

@@ -0,0 +1,93 @@
+import { KeyType } from '../../../modules/key';
+import { StoreService } from '../index';
+class IORedisStoreService extends StoreService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    getMulti() {
+        return this.redisClient.multi();
+    }
+    hGetAllResult(result) {
+        //ioredis response signature is [null, {}] or [null, null]
+        return result[1];
+    }
+    async addTaskQueues(keys) {
+        const multi = this.redisClient.multi();
+        const zsetKey = this.mintKey(KeyType.WORK_ITEMS, { appId: this.appId });
+        for (const key of keys) {
+            multi.zadd(zsetKey, 'NX', Date.now(), key);
+        }
+        await multi.exec();
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const status = await this.redisClient.publish(topic, JSON.stringify(message));
+        return status === 1;
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        if (mkStream === 'MKSTREAM') {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+        else {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+    }
+    async xadd(key, id, messageId, messageValue, multi) {
+        try {
+            return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            return await this.redisClient.xpending(key, group, start, end, count, consumer);
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.xclaim(key, group, consumer, minIdleTime, 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 {
+            return await (multi || this.redisClient).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 {
+            return await (multi || this.redisClient).xdel(key, id);
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+export { IORedisStoreService };