@hotmeshio/hotmesh 0.0.8 → 0.0.10

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

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

@@ -1,314 +0,0 @@
-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) {
-            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

@@ -1,66 +0,0 @@
-/**
- * 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

@@ -1,124 +0,0 @@
-/**
- * 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

@@ -1,27 +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/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

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