@hotmeshio/hotmesh 0.6.0 → 0.6.1

package/build/services/sub/providers/redis/ioredis.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSubService = void 0;
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class IORedisSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+        this.subscriptions = new Map();
+        this.messageHandlerSet = false;
+        this.pmessageHandlerSet = false;
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        return this.eventClient.multi();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        // Add callback to set (supports multiple subscribers per topic)
+        let callbacks = this.subscriptions.get(topic);
+        const isFirstSubscription = !callbacks;
+        if (!callbacks) {
+            callbacks = new Set();
+            this.subscriptions.set(topic, callbacks);
+        }
+        callbacks.add(callback);
+        this.logger.debug('ioredis-subscribe', {
+            topic,
+            isFirstSubscription,
+            totalCallbacks: callbacks.size,
+            messageHandlerSet: this.messageHandlerSet,
+        });
+        // Set up message handler only once
+        if (!this.messageHandlerSet) {
+            this.eventClient.on('message', (channel, message) => {
+                try {
+                    const payload = JSON.parse(message);
+                    const cbs = this.subscriptions.get(channel);
+                    this.logger.debug('ioredis-message-received', {
+                        channel,
+                        callbackCount: cbs?.size || 0,
+                        payload,
+                    });
+                    if (cbs) {
+                        // Call all callbacks for this channel
+                        cbs.forEach(cb => {
+                            try {
+                                cb(channel, payload);
+                            }
+                            catch (err) {
+                                this.logger.error(`Error in callback for ${channel}`, err);
+                            }
+                        });
+                    }
+                }
+                catch (e) {
+                    this.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+            this.messageHandlerSet = true;
+        }
+        await this.eventClient.subscribe(topic, (err) => {
+            if (err) {
+                this.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const callbacks = this.subscriptions.get(topic);
+        this.logger.debug('ioredis-unsubscribe', {
+            topic,
+            hadCallbacks: !!callbacks,
+            callbackCount: callbacks?.size || 0,
+        });
+        // Only unsubscribe from Redis if no more callbacks exist
+        if (callbacks && callbacks.size > 0) {
+            this.subscriptions.delete(topic);
+            await this.eventClient.unsubscribe(topic);
+        }
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        // Add callback to set (supports multiple subscribers per topic)
+        let callbacks = this.subscriptions.get(topic);
+        if (!callbacks) {
+            callbacks = new Set();
+            this.subscriptions.set(topic, callbacks);
+        }
+        callbacks.add(callback);
+        // Set up pmessage handler only once
+        if (!this.pmessageHandlerSet) {
+            this.eventClient.on('pmessage', (pattern, channel, message) => {
+                try {
+                    const payload = JSON.parse(message);
+                    const cbs = this.subscriptions.get(pattern);
+                    if (cbs) {
+                        // Call all callbacks for this pattern
+                        cbs.forEach(cb => {
+                            try {
+                                cb(channel, payload);
+                            }
+                            catch (err) {
+                                this.logger.error(`Error in callback for ${pattern}`, err);
+                            }
+                        });
+                    }
+                }
+                catch (e) {
+                    this.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+            this.pmessageHandlerSet = true;
+        }
+        await this.eventClient.psubscribe(topic, (err) => {
+            if (err) {
+                this.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const callbacks = this.subscriptions.get(topic);
+        // Only unsubscribe from Redis if no more callbacks exist
+        if (callbacks && callbacks.size > 0) {
+            this.subscriptions.delete(topic);
+            await this.eventClient.punsubscribe(topic);
+        }
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        //NOTE: `storeClient.publish` is used,
+        //      because a Redis connection with subscriptions
+        //      may not publish (is read only).
+        this.logger.debug('ioredis-publish', { topic, message });
+        const status = await this.storeClient.publish(topic, JSON.stringify(message));
+        return status === 1;
+    }
+}
+exports.IORedisSubService = IORedisSubService;

package/build/services/sub/providers/redis/redis.d.ts

@@ -0,0 +1,18 @@
+import { KeyStoreParams, KeyType } from '../../../../modules/key';
+import { ILogger } from '../../../logger';
+import { SubService } from '../../index';
+import { RedisRedisClientType as ClientProvider, RedisRedisMultiType as TransactionProvider } from '../../../../types/redis';
+import { SubscriptionCallback } from '../../../../types/quorum';
+declare class RedisSubService extends SubService<ClientProvider> {
+    private subscriptions;
+    constructor(eventClient: ClientProvider, storeClient: ClientProvider);
+    init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
+    transact(): TransactionProvider;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    subscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    unsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+    psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    punsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+    publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;
+}
+export { RedisSubService };

package/build/services/sub/providers/redis/redis.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSubService = void 0;
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class RedisSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+        this.subscriptions = new Map();
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        const multi = this.eventClient.multi();
+        return multi;
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        if (this.eventClient) {
+            const topic = this.mintKey(keyType, { appId, engineId });
+            // Add callback to set (supports multiple subscribers per topic)
+            let callbacks = this.subscriptions.get(topic);
+            const isFirstSubscription = !callbacks;
+            if (!callbacks) {
+                callbacks = new Set();
+                this.subscriptions.set(topic, callbacks);
+            }
+            callbacks.add(callback);
+            this.logger.debug('redis-subscribe', {
+                topic,
+                isFirstSubscription,
+                totalCallbacks: callbacks.size,
+            });
+            // Only subscribe to Redis once per topic
+            if (isFirstSubscription) {
+                await this.eventClient.subscribe(topic, (message) => {
+                    try {
+                        const payload = JSON.parse(message);
+                        const cbs = this.subscriptions.get(topic);
+                        this.logger.debug('redis-message-received', {
+                            topic,
+                            callbackCount: cbs?.size || 0,
+                            payload,
+                        });
+                        if (cbs) {
+                            // Call all callbacks for this topic
+                            cbs.forEach(cb => {
+                                try {
+                                    cb(topic, payload);
+                                }
+                                catch (err) {
+                                    this.logger.error(`Error in callback for ${topic}`, err);
+                                }
+                            });
+                        }
+                    }
+                    catch (e) {
+                        this.logger.error(`Error parsing message: ${message}`, e);
+                    }
+                });
+            }
+        }
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const callbacks = this.subscriptions.get(topic);
+        this.logger.debug('redis-unsubscribe', {
+            topic,
+            hadCallbacks: !!callbacks,
+            callbackCount: callbacks?.size || 0,
+        });
+        // Only unsubscribe from Redis if no more callbacks exist
+        if (callbacks && callbacks.size > 0) {
+            this.subscriptions.delete(topic);
+            await this.eventClient.unsubscribe(topic);
+        }
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        if (this.eventClient) {
+            const topic = this.mintKey(keyType, { appId, engineId });
+            // Add callback to set (supports multiple subscribers per topic)
+            let callbacks = this.subscriptions.get(topic);
+            if (!callbacks) {
+                callbacks = new Set();
+                this.subscriptions.set(topic, callbacks);
+            }
+            callbacks.add(callback);
+            await this.eventClient.pSubscribe(topic, (message, channel) => {
+                try {
+                    const payload = JSON.parse(message);
+                    const cbs = this.subscriptions.get(topic);
+                    if (cbs) {
+                        // Call all callbacks for this topic
+                        cbs.forEach(cb => {
+                            try {
+                                cb(channel, payload);
+                            }
+                            catch (err) {
+                                this.logger.error(`Error in callback for ${topic}`, err);
+                            }
+                        });
+                    }
+                }
+                catch (e) {
+                    this.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+        }
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        const callbacks = this.subscriptions.get(topic);
+        // Only unsubscribe from Redis if no more callbacks exist
+        if (callbacks && callbacks.size > 0) {
+            this.subscriptions.delete(topic);
+            await this.eventClient.pUnsubscribe(topic);
+        }
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        //NOTE: `storeClient.publish` is used,
+        //      because a Redis connection with subscriptions
+        //      may not publish (is read only).
+        this.logger.debug('redis-publish', { topic, message });
+        const status = await this.storeClient.publish(topic, JSON.stringify(message));
+        return status > 0;
+    }
+}
+exports.RedisSubService = RedisSubService;

package/build/types/index.d.ts

@@ -17,6 +17,7 @@ export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCall
 export { PostgresClassType, PostgresClientOptions, PostgresClientType, PostgresConsumerGroup, PostgresPendingMessage, PostgresPoolClientType, PostgresQueryConfigType, PostgresQueryResultType, PostgresStreamMessage, PostgresStreamOptions, PostgresTransaction, } from './postgres';
 export { ActivateMessage, CronMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, RollCallMessage, RollCallOptions, SubscriptionCallback, SubscriptionOptions, SystemHealth, ThrottleMessage, ThrottleOptions, WorkMessage, } from './quorum';
 export { NatsAckPolicy, NatsAckPolicyExplicitType, NatsClassType, NatsClientType, NatsClientOptions, NatsConsumerConfigType, NatsJetStreamManager, NatsConnection, NatsJetStreamType, NatsConnectionOptions, NatsConsumerConfig, NatsConsumerInfo, NatsConsumerManager, NatsDeliveryInfo, NatsJetStreamOptions, NatsError, NatsErrorType, NatsJetStreamClient, NatsJsMsg, NatsMessageType, NatsMsgExpect, NatsPubAck, NatsPubAckType, NatsPublishOptions, NatsRetentionPolicy, NatsRetentionPolicyWorkqueueType, NatsSequenceInfo, NatsStorageMemoryType, NatsStorageType, NatsStreamConfig, NatsStreamInfo, NatsStreamManager, NatsStreamConfigType, NatsStreamInfoType, NatsStreamOptions, NatsStreamState, NatsTransaction, } from './nats';
+export { RedisClass, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, } from './redis';
 export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets, } from './serializer';
 export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment, } from './stats';
 export { ReclaimedMessageType, RouterConfig, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamMessage, StreamMessageMetadata, StreamProviderType, StreamRetryPolicy, StreamRole, StreamStats, StreamStatus, } from './stream';

package/build/types/index.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.isIORedisClient = exports.isRedisClient = exports.KeyType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var hotmesh_1 = require("./hotmesh");
 Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
+var redis_1 = require("./redis");
+Object.defineProperty(exports, "isRedisClient", { enumerable: true, get: function () { return redis_1.isRedisClient; } });
+Object.defineProperty(exports, "isIORedisClient", { enumerable: true, get: function () { return redis_1.isIORedisClient; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });

package/build/types/provider.d.ts

@@ -12,7 +12,7 @@ export interface ProviderClass {
 export interface ProviderOptions {
     [key: string]: any;
 }
-export type Providers = 'nats' | 'postgres';
+export type Providers = 'nats' | 'postgres' | 'redis' | 'ioredis';
 /**
  * A provider transaction is a set of operations that are executed
  * atomically by the provider. The transaction is created by calling

package/build/types/redis.d.ts

@@ -0,0 +1,258 @@
+/// <reference types="node" />
+import { ProviderClient, ProviderConfig, ProviderTransaction } from './provider';
+import { StringStringType } from './serializer';
+import { ReclaimedMessageType } from './stream';
+/**
+ * Redis types
+ */
+interface ConnectionOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+    socket?: any;
+    NPNProtocols?: string[] | Buffer[];
+    ALPNProtocols?: string[] | Buffer[];
+    servername?: string;
+    checkServerIdentity?: (servername: string, cert: Buffer) => Error | undefined;
+    session?: Buffer;
+    minDHSize?: number;
+    secureContext?: any;
+    secureProtocol?: string;
+    ciphers?: string;
+    honorCipherOrder?: boolean;
+    requestCert?: boolean;
+    rejectUnauthorized?: boolean;
+    maxVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+    minVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
+}
+interface RedisRedisClientOptions {
+    url?: string;
+    socket?: {
+        host?: string;
+        port?: number;
+        tls?: boolean;
+        servername?: string;
+    };
+    username?: string;
+    password?: string;
+    database?: number;
+    name?: string;
+    readonly?: boolean;
+    legacyMode?: boolean;
+    commandsQueueMaxLength?: number;
+    disableOfflineQueue?: boolean;
+    connectTimeout?: number;
+    autoResubscribe?: boolean;
+    autoResendUnfulfilledCommands?: boolean;
+    lazyConnect?: boolean;
+    tls?: boolean | ConnectionOptions;
+    enableReadyCheck?: boolean;
+    keepAlive?: number;
+    family?: 'IPv4' | 'IPv6';
+    keyPrefix?: string;
+    retry?: {
+        maxReconnectionAttempts?: number;
+        initialReconnectionDelay?: number;
+        reconnectionBackoffFactor?: number;
+        totalReconnectionTimeout?: number;
+        maxRetryCount?: number;
+    };
+    stringNumbers?: boolean;
+}
+interface RedisRedisMultiType extends ProviderTransaction {
+    sendCommand(command: string, ...args: string[]): Promise<any>;
+    exec: () => Promise<unknown[]>;
+    DEL(key: string): this;
+    EXISTS(key: string): this;
+    EXPIRE(key: string, seconds: number): this;
+    HDEL(key: string, fields: string[] | string): this;
+    HGET(key: string, itemId: string): this;
+    HGETALL(key: string): this;
+    HINCRBYFLOAT(key: string, itemId: string, value: number): this;
+    HMPUSH(key: string, values: Record<string, string>): this;
+    RPUSH(key: string, items: string[]): this;
+    HMGET(key: string, itemIds: string[]): this;
+    HSET(key: string, values: Record<string, string>): this;
+    LPUSH(key: string, items: string[]): this;
+    LRANGE(key: string, start: number, end: number): this;
+    RPUSH(key: string, items: string[]): this;
+    SET(key: string, value: string): this;
+    XADD(key: string, id: string, fields: any): this;
+    XACK(key: string, group: string, id: string): this;
+    XACK(key: string, group: string, ...ids: string[]): this;
+    XDEL(key: string, id: string): this;
+    XDEL(key: string, ...ids: string[]): this;
+    XCLAIM(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
+    XLEN(key: string): this;
+    XGROUP(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
+    XPENDING(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
+    ZADD(key: string, values: {
+        score: string;
+        value: string;
+    }, opts?: {
+        NX: boolean;
+    }): this;
+    ZRANGE_WITHSCORES(key: string, start: number, end: number): this;
+    ZRANK(key: string, member: string): this;
+    ZSCORE(key: string, value: string): this;
+}
+interface RedisRedisClientType extends ProviderClient {
+    multi(): Partial<RedisRedisMultiType>;
+    connect(): Promise<void>;
+    sendCommand(args: any[]): Promise<any>;
+    exec(): Promise<unknown[]>;
+    flushDb(): Promise<string>;
+    quit(): Promise<string>;
+    disconnect(): void;
+    duplicate(): RedisRedisClientType;
+    on(event: string, callback: (...args: any[]) => void): void;
+    publish(channel: string, message: string): Promise<number>;
+    pSubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
+    pUnsubscribe(pattern: string): Promise<void>;
+    subscribe(channel: string, callback: (channel: string, message: string) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    punsubscribe(channel: string): void;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<string>;
+    DEL(key: string): Promise<number>;
+    EXISTS(key: string): Promise<number>;
+    HDEL(key: string, fields: string[] | string): Promise<number>;
+    HGET(key: string, itemId: string): Promise<string | null>;
+    HGETALL(key: string): Promise<StringStringType>;
+    HINCRBYFLOAT(key: string, itemId: string, value: number): Promise<number>;
+    HMGET(key: string, itemIds: string[]): Promise<string[]>;
+    HSET(key: string, values: Record<string, string>): Promise<number>;
+    LPUSH(key: string, items: string[]): Promise<number>;
+    LRANGE(key: string, start: number, end: number): Promise<string[]>;
+    RPUSH(key: string, items: string[]): Promise<number>;
+    SET(key: string, value: string): Promise<string>;
+    XADD(key: string, id: string, fields: any): Promise<string>;
+    XACK(key: string, group: string, ...ids: string[]): Promise<number>;
+    XACK(key: string, group: string, id: string): Promise<number>;
+    XCLAIM(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    XDEL(key: string, id: string): Promise<number>;
+    XDEL(key: string, ...ids: string[]): Promise<number>;
+    xGroupDestroy(key: string, groupName: string): Promise<boolean>;
+    XINFO(command: 'GROUPS' | string, key: string): Promise<unknown>;
+    XINFO_GROUPS(key: string): Promise<unknown>;
+    XLEN(key: string): Promise<number>;
+    XPENDING(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
+    ZADD(key: string, values: {
+        score: string;
+        value: string;
+    }, opts?: {
+        NX: boolean;
+    }): Promise<number>;
+    ZRANGE_WITHSCORES(key: string, start: number, end: number): Promise<{
+        score: number;
+        value: string;
+    }>;
+    ZRANK(key: string, member: string): Promise<number>;
+    ZSCORE(key: string, value: string): Promise<number>;
+}
+interface RedisRedisClassType {
+    createClient(options: RedisRedisClientOptions): Partial<RedisRedisClientType>;
+}
+/**
+ * IORedis types
+ */
+interface IORedisClientOptions {
+    port?: number;
+    host?: string;
+    family?: 'IPv4' | 'IPv6';
+    path?: string;
+    keepAlive?: number;
+    noDelay?: boolean;
+    connectionName?: string;
+    db?: number;
+    password?: string;
+    username?: string;
+    sentinels?: Array<{
+        host: string;
+        port: number;
+    }>;
+    name?: string;
+    readOnly?: boolean;
+    keyPrefix?: string;
+    reconnectOnError?: (err: Error) => boolean;
+}
+interface IORedisClient extends ProviderClient {
+    multi(): IORedisMultiType;
+    exec(): Promise<unknown[]>;
+    sendCommand(args: any[]): Promise<any>;
+    call(command: string, ...args: any[]): Promise<any>;
+    quit(): Promise<string>;
+    flushdb(): Promise<string>;
+    publish(channel: string, message: string): Promise<number>;
+    psubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
+    punsubscribe(pattern: string): Promise<number>;
+    subscribe(channel: string, callback: (channel: string, message: string) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<number>;
+    punsubscribe(channel: string): Promise<number>;
+    xadd(key: string, id: string, fields: any, message?: string): Promise<string>;
+    xack(key: string, group: string, id: string): Promise<number>;
+    xack(key: string, group: string, ...ids: string[]): Promise<number>;
+    xdel(key: string, id: string): Promise<number>;
+    xdel(key: string, ...ids: string[]): Promise<number>;
+    xlen(key: string): Promise<number>;
+    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>;
+    xinfo(command: 'GROUPS' | string, key: string): Promise<unknown>;
+    xrange(key: string, start: string, end: string): Promise<string[][]>;
+    xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: string, blockTime: number, streamsOption: string, streamName: string, key: string): Promise<string[][]>;
+    del(key: string): Promise<number>;
+    exists(key: string): Promise<number>;
+    get(key: string): Promise<string | null>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    hget(key: string, itemId: string): Promise<string | null>;
+    hgetall(key: string): Promise<StringStringType>;
+    hincrbyfloat(key: string, itemId: string, value: number): Promise<number>;
+    hmget(key: string, itemIds: string[]): Promise<string[]>;
+    hset(key: string, values: Record<string, string>): Promise<number>;
+    lpush(key: string, ...args: string[]): Promise<number>;
+    lrange(key: string, start: number, end: number): Promise<string[]>;
+    on(event: string, callback: (...args: any[]) => void): void;
+    rpush(key: string, ...args: string[]): Promise<number>;
+    set(key: string, value: string): Promise<string>;
+    zadd(...args: Array<string | number>): Promise<number>;
+    zrange(key: string, start: number, end: number, withScores?: 'WITHSCORES'): Promise<string[]>;
+    zrank(key: string, member: string): Promise<number>;
+    zscore(key: string, value: string): Promise<number>;
+    xgroup(command: 'CREATE' | 'DESTROY' | string, key: string, groupName: string, id?: string, mkStream?: 'MKSTREAM'): Promise<string | number>;
+}
+type IORedisClassType = new (options: IORedisClientOptions, ...args: any[]) => IORedisClient;
+interface IORedisMultiType extends ProviderTransaction {
+    xadd(key: string, id: string, fields: any, message?: string): this;
+    xack(key: string, group: string, id: string): this;
+    xack(key: string, group: string, ...ids: string[]): this;
+    xdel(key: string, id: string): this;
+    xdel(key: string, ...ids: string[]): this;
+    xlen(key: string): this;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
+    del(key: string): this;
+    expire(key: string, seconds: number): this;
+    hdel(key: string, itemId: string): this;
+    hget(key: string, itemId: string): this;
+    hgetall(key: string): this;
+    hincrbyfloat(key: string, itemId: string, value: number): this;
+    hmget(key: string, itemIds: string[]): this;
+    hset(key: string, values: Record<string, string>): this;
+    lrange(key: string, start: number, end: number): this;
+    rpush(key: string, value: string): this;
+    zadd(...args: Array<string | number>): this;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
+    sendCommand(command: string[]): Promise<any>;
+    exec: () => Promise<unknown[]>;
+}
+type RedisClass = RedisRedisClassType | IORedisClassType;
+type RedisClient = RedisRedisClientType | IORedisClient;
+type RedisOptions = RedisRedisClientOptions | IORedisClientOptions;
+type RedisMulti = RedisRedisMultiType | IORedisMultiType;
+declare function isRedisClient(client: RedisClient): client is RedisRedisClientType;
+declare function isIORedisClient(client: RedisClient): client is IORedisClient;
+interface RedisConfig extends ProviderConfig {
+    class: Partial<RedisClass>;
+    options: Partial<RedisOptions>;
+}
+export { RedisClass, RedisConfig, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClient as IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, };

package/build/types/redis.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIORedisClient = exports.isRedisClient = void 0;
+function isRedisClient(client) {
+    return 'sendCommand' in client;
+}
+exports.isRedisClient = isRedisClient;
+function isIORedisClient(client) {
+    return 'pipeline' in client;
+}
+exports.isIORedisClient = isIORedisClient;

package/index.ts

@@ -16,13 +16,17 @@ import * as Enums from './modules/enums';
 import * as KeyStore from './modules/key';
 import { ConnectorService as Connector } from './services/connector/factory';
 import { PostgresConnection as ConnectorPostgres } from './services/connector/providers/postgres';
+import { RedisConnection as ConnectorIORedis } from './services/connector/providers/ioredis';
+import { RedisConnection as ConnectorRedis } from './services/connector/providers/redis';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 
 export {
   //Provider Connectors
   Connector, //factory
+  ConnectorIORedis,
   ConnectorNATS,
   ConnectorPostgres,
+  ConnectorRedis,
 
   //Top-level Modules
   HotMesh,