@hotmeshio/hotmesh 0.5.5 → 0.5.7

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

@@ -1,81 +0,0 @@
-"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);
-    }
-    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 self = this;
-        const topic = this.mintKey(keyType, { appId, engineId });
-        await this.eventClient.subscribe(topic, (err) => {
-            if (err) {
-                self.logger.error(`Error subscribing to: ${topic}`, err);
-            }
-        });
-        this.eventClient.on('message', (channel, message) => {
-            if (channel === topic) {
-                try {
-                    const payload = JSON.parse(message);
-                    callback(topic, payload);
-                }
-                catch (e) {
-                    self.logger.error(`Error parsing message: ${message}`, e);
-                }
-            }
-        });
-    }
-    async unsubscribe(keyType, appId, engineId) {
-        const topic = this.mintKey(keyType, { appId, engineId });
-        await this.eventClient.unsubscribe(topic);
-    }
-    async psubscribe(keyType, callback, appId, engineId) {
-        const self = this;
-        const topic = this.mintKey(keyType, { appId, engineId });
-        await this.eventClient.psubscribe(topic, (err) => {
-            if (err) {
-                self.logger.error(`Error subscribing to: ${topic}`, err);
-            }
-        });
-        this.eventClient.on('pmessage', (pattern, channel, message) => {
-            if (pattern === topic) {
-                try {
-                    const payload = JSON.parse(message);
-                    callback(channel, payload);
-                }
-                catch (e) {
-                    self.logger.error(`Error parsing message: ${message}`, e);
-                }
-            }
-        });
-    }
-    async punsubscribe(keyType, appId, engineId) {
-        const topic = this.mintKey(keyType, { appId, engineId });
-        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).
-        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

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

@@ -1,72 +0,0 @@
-"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);
-    }
-    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 self = this;
-            const topic = this.mintKey(keyType, { appId, engineId });
-            await this.eventClient.subscribe(topic, (message) => {
-                try {
-                    const payload = JSON.parse(message);
-                    callback(topic, payload);
-                }
-                catch (e) {
-                    self.logger.error(`Error parsing message: ${message}`, e);
-                }
-            });
-        }
-    }
-    async unsubscribe(keyType, appId, engineId) {
-        const topic = this.mintKey(keyType, { appId, engineId });
-        await this.eventClient.unsubscribe(topic);
-    }
-    async psubscribe(keyType, callback, appId, engineId) {
-        if (this.eventClient) {
-            const self = this;
-            const topic = this.mintKey(keyType, { appId, engineId });
-            await this.eventClient.pSubscribe(topic, (message, channel) => {
-                try {
-                    const payload = JSON.parse(message);
-                    callback(channel, payload);
-                }
-                catch (e) {
-                    self.logger.error(`Error parsing message: ${message}`, e);
-                }
-            });
-        }
-    }
-    async punsubscribe(keyType, appId, engineId) {
-        const topic = this.mintKey(keyType, { appId, engineId });
-        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).
-        const status = await this.storeClient.publish(topic, JSON.stringify(message));
-        return status > 0;
-    }
-}
-exports.RedisSubService = RedisSubService;

package/build/types/redis.d.ts

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

@@ -1,11 +0,0 @@
-"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;