@hotmeshio/hotmesh 0.3.6 → 0.3.8

package/build/services/store/clients/redis.js

@@ -1,319 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisStoreService = void 0;
-const index_1 = require("../index");
-const enums_1 = require("../../../modules/enums");
-class RedisStoreService extends index_1.StoreService {
-    constructor(redisClient) {
-        super(redisClient);
-        this.commands = {
-            get: 'GET',
-            set: 'SET',
-            setnx: 'SETNX',
-            del: 'DEL',
-            expire: 'EXPIRE',
-            hscan: 'HSCAN',
-            hset: 'HSET',
-            hsetnx: 'HSETNX',
-            hincrby: 'HINCRBY',
-            hdel: 'HDEL',
-            hget: 'HGET',
-            hmget: 'HMGET',
-            hgetall: 'HGETALL',
-            hincrbyfloat: 'HINCRBYFLOAT',
-            zrange: 'ZRANGE',
-            zrangebyscore_withscores: 'ZRANGEBYSCORE_WITHSCORES',
-            zrangebyscore: 'ZRANGEBYSCORE',
-            zrem: 'ZREM',
-            zadd: 'ZADD',
-            lmove: 'LMOVE',
-            lrange: 'LRANGE',
-            llen: 'LLEN',
-            lpop: 'LPOP',
-            rename: 'RENAME',
-            rpush: 'RPUSH',
-            scan: 'SCAN',
-            xack: 'XACK',
-            xdel: 'XDEL',
-            xlen: 'XLEN',
-        };
-    }
-    getMulti() {
-        const my = this;
-        if (enums_1.HMSH_IS_CLUSTER) {
-            const commands = [];
-            const addCommand = (command, args) => {
-                commands.push({ command: command.toUpperCase(), args });
-                return multiInstance;
-            };
-            const multiInstance = {
-                sendCommand(command, ...args) {
-                    return my.redisClient.sendCommand([command, ...args]);
-                },
-                async exec() {
-                    if (commands.length === 0)
-                        return [];
-                    const sameKey = commands.every((cmd) => {
-                        return cmd.args[0] === commands[0].args[0];
-                    });
-                    if (sameKey) {
-                        const multi = my.redisClient.multi();
-                        commands.forEach((cmd) => {
-                            if (cmd.command === 'ZADD') {
-                                return multi.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
-                            }
-                            return multi[cmd.command](...cmd.args);
-                        });
-                        const results = await multi.exec();
-                        return results.map((item) => item);
-                    }
-                    else {
-                        return Promise.all(commands.map((cmd) => {
-                            if (cmd.command === 'ZADD') {
-                                return my.redisClient.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
-                            }
-                            return my.redisClient[cmd.command](...cmd.args);
-                        }));
-                    }
-                },
-                XADD(key, id, fields, message) {
-                    return addCommand('XADD', [key, id, fields, message]);
-                },
-                XACK(key, group, id) {
-                    return addCommand('XACK', [key, group, id]);
-                },
-                XDEL(key, id) {
-                    return addCommand('XDEL', [key, id]);
-                },
-                XLEN(key) {
-                    return addCommand('XLEN', [key]);
-                },
-                XCLAIM(key, group, consumer, minIdleTime, id, ...args) {
-                    return addCommand('XCLAIM', [
-                        key,
-                        group,
-                        consumer,
-                        minIdleTime,
-                        id,
-                        ...args,
-                    ]);
-                },
-                XPENDING(key, group, start, end, count, consumer) {
-                    return addCommand('XPENDING', [
-                        key,
-                        group,
-                        start,
-                        end,
-                        count,
-                        consumer,
-                    ]);
-                },
-                DEL: function (key) {
-                    return addCommand('DEL', [key]);
-                },
-                EXPIRE: function (key, seconds) {
-                    return addCommand('EXPIRE', [key, seconds]);
-                },
-                HDEL(key, itemId) {
-                    return addCommand('HDEL', [key, itemId]);
-                },
-                HGET(key, itemId) {
-                    return addCommand('HGET', [key, itemId]);
-                },
-                HGETALL(key) {
-                    return addCommand('HGETALL', [key]);
-                },
-                HINCRBYFLOAT(key, itemId, value) {
-                    return addCommand('HINCRBYFLOAT', [key, itemId, value]);
-                },
-                HMGET(key, itemIds) {
-                    return addCommand('HMGET', [key, itemIds]);
-                },
-                HSET(key, values) {
-                    return addCommand('HSET', [key, values]);
-                },
-                LRANGE(key, start, end) {
-                    return addCommand('LRANGE', [key, start, end]);
-                },
-                RPUSH(key, items) {
-                    return addCommand('RPUSH', [key, items]);
-                },
-                ZADD(key, args, opts) {
-                    return addCommand('ZADD', [key, args, opts]);
-                },
-                XGROUP(command, key, groupName, id, mkStream) {
-                    return addCommand('XGROUP', [command, key, groupName, id, mkStream]);
-                },
-                EXISTS: function (key) {
-                    throw new Error('Function not implemented.');
-                },
-                HMPUSH: function (key, values) {
-                    throw new Error('Function not implemented.');
-                },
-                LPUSH: function (key, items) {
-                    throw new Error('Function not implemented.');
-                },
-                SET: function (key, value) {
-                    throw new Error('Function not implemented.');
-                },
-                ZRANGE_WITHSCORES: function (key, start, end) {
-                    throw new Error('Function not implemented.');
-                },
-                ZRANK: function (key, member) {
-                    throw new Error('Function not implemented.');
-                },
-                ZSCORE: function (key, value) {
-                    throw new Error('Function not implemented.');
-                },
-            };
-            return multiInstance;
-        }
-        return this.redisClient.multi();
-    }
-    async exec(...args) {
-        return await this.redisClient.sendCommand(args);
-    }
-    async setnxex(key, value, expireSeconds) {
-        const status = await this.redisClient[this.commands.set](key, value, { NX: true, EX: expireSeconds });
-        return this.isSuccessful(status);
-    }
-    async publish(keyType, message, appId, engineId) {
-        const topic = this.mintKey(keyType, { appId, engineId });
-        const status = await this.redisClient.publish(topic, JSON.stringify(message));
-        return this.isSuccessful(status);
-    }
-    async zAdd(key, score, value, redisMulti) {
-        return await (redisMulti || this.redisClient)[this.commands.zadd](key, {
-            score: score,
-            value: value.toString(),
-        });
-    }
-    async zRangeByScoreWithScores(key, score, value) {
-        const result = await this.redisClient[this.commands.zrangebyscore_withscores](key, score, value);
-        if (result?.length > 0) {
-            return result[0];
-        }
-        return null;
-    }
-    async zRangeByScore(key, score, value) {
-        const result = await this.redisClient[this.commands.zrangebyscore](key, score, value);
-        if (result?.length > 0) {
-            return result[0];
-        }
-        return null;
-    }
-    async xgroup(command, key, groupName, id, mkStream) {
-        const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
-        try {
-            return ((await this.redisClient.sendCommand([
-                'XGROUP',
-                'CREATE',
-                key,
-                groupName,
-                id,
-                ...args,
-            ])) === 1);
-        }
-        catch (error) {
-            const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.debug(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { ...error });
-            throw error;
-        }
-    }
-    async xadd(key, id, ...args) {
-        let multi;
-        if (typeof args[args.length - 1] !== 'string') {
-            multi = args.pop();
-        }
-        try {
-            return await (multi || this.redisClient).XADD(key, id, {
-                [args[0]]: args[1],
-            });
-        }
-        catch (error) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xpending(key, group, start, end, count, consumer) {
-        try {
-            const args = [key, group];
-            if (start)
-                args.push(start);
-            if (end)
-                args.push(end);
-            if (count !== undefined)
-                args.push(count.toString());
-            if (consumer)
-                args.push(consumer);
-            return await this.redisClient.sendCommand(['XPENDING', ...args]);
-        }
-        catch (error) {
-            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
-        try {
-            return (await this.redisClient.sendCommand([
-                'XCLAIM',
-                key,
-                group,
-                consumer,
-                minIdleTime.toString(),
-                id,
-                ...args,
-            ]));
-        }
-        catch (error) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xack(key, group, id, multi) {
-        try {
-            if (multi) {
-                multi[this.commands.xack](key, group, id);
-                return multi;
-            }
-            else {
-                return await this.redisClient[this.commands.xack](key, group, id);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xdel(key, id, multi) {
-        try {
-            if (multi) {
-                multi[this.commands.xdel](key, id);
-                return multi;
-            }
-            else {
-                return await this.redisClient[this.commands.xdel](key, id);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xlen(key, multi) {
-        try {
-            if (multi) {
-                multi.XLEN(key);
-                return multi;
-            }
-            else {
-                return await this.redisClient.XLEN(key);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error getting stream depth: ${key}`, { ...error });
-            throw error;
-        }
-    }
-}
-exports.RedisStoreService = RedisStoreService;

package/build/services/stream/clients/ioredis.d.ts

@@ -1,24 +0,0 @@
-import { KeyStoreParams, KeyType } from '../../../modules/key';
-import { ILogger } from '../../logger';
-import { StreamService } from '../index';
-import { IORedisClientType as RedisClientType, IORedisMultiType as RedisMultiType } from '../../../types/redis';
-import { ReclaimedMessageType } from '../../../types/stream';
-declare class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType> {
-    redisClient: RedisClientType;
-    namespace: string;
-    logger: ILogger;
-    appId: string;
-    constructor(redisClient: RedisClientType);
-    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
-    getMulti(): RedisMultiType;
-    mintKey(type: KeyType, params: KeyStoreParams): string;
-    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>;
-    xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: 'BLOCK' | 'COUNT', blockTime: number | string, streamsOption: 'STREAMS', streamName: string, id: string): Promise<string[][][] | null | unknown[]>;
-    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>;
-    xlen(key: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
-}
-export { IORedisStreamService };

package/build/services/stream/clients/ioredis.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IORedisStreamService = void 0;
-const key_1 = require("../../../modules/key");
-const index_1 = require("../index");
-class IORedisStreamService extends index_1.StreamService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = key_1.HMNS, appId, logger) {
-        this.namespace = namespace;
-        this.logger = logger;
-        this.appId = appId;
-    }
-    getMulti() {
-        return this.redisClient.multi();
-    }
-    mintKey(type, params) {
-        if (!this.namespace)
-            throw new Error('namespace not set');
-        return key_1.KeyService.mintKey(this.namespace, type, params);
-    }
-    async xgroup(command, key, groupName, id, mkStream) {
-        if (mkStream === 'MKSTREAM') {
-            try {
-                return ((await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK');
-            }
-            catch (error) {
-                this.logger.debug('stream-mkstream-caught', { key, group: groupName });
-                throw error;
-            }
-        }
-        else {
-            try {
-                return ((await this.redisClient.xgroup(command, key, groupName, id)) === 'OK');
-            }
-            catch (error) {
-                this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
-                throw error;
-            }
-        }
-    }
-    async xadd(key, id, messageId, messageValue, multi) {
-        try {
-            return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
-        }
-        catch (error) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
-        try {
-            return await this.redisClient.xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id);
-        }
-        catch (error) {
-            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { ...error });
-            throw error;
-        }
-    }
-    async xpending(key, group, start, end, count, consumer) {
-        try {
-            const args = [key, group];
-            if (start)
-                args.push(start);
-            if (end)
-                args.push(end);
-            if (count !== undefined)
-                args.push(count.toString());
-            if (consumer)
-                args.push(consumer);
-            try {
-                return (await this.redisClient.call('XPENDING', ...args));
-            }
-            catch (error) {
-                this.logger.error('err, args', { ...error }, args);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, { ...error });
-            throw error;
-        }
-    }
-    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
-        try {
-            return (await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args));
-        }
-        catch (error) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xack(key, group, id, multi) {
-        try {
-            return await (multi || this.redisClient).xack(key, group, id);
-        }
-        catch (error) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xdel(key, id, multi) {
-        try {
-            return await (multi || this.redisClient).xdel(key, id);
-        }
-        catch (error) {
-            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xlen(key, multi) {
-        try {
-            return await (multi || this.redisClient).xlen(key);
-        }
-        catch (error) {
-            this.logger.error(`Error getting stream depth: ${key}`, { ...error });
-            throw error;
-        }
-    }
-}
-exports.IORedisStreamService = IORedisStreamService;

package/build/services/stream/clients/redis.d.ts

@@ -1,24 +0,0 @@
-import { KeyStoreParams, KeyType } from '../../../modules/key';
-import { ILogger } from '../../logger';
-import { StreamService } from '../index';
-import { RedisRedisClientType as RedisClientType, RedisRedisMultiType as RedisMultiType } from '../../../types/redis';
-import { ReclaimedMessageType } from '../../../types/stream';
-declare class RedisStreamService extends StreamService<RedisClientType, RedisMultiType> {
-    redisClient: RedisClientType;
-    namespace: string;
-    logger: ILogger;
-    appId: string;
-    constructor(redisClient: RedisClientType);
-    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
-    getMulti(): RedisMultiType;
-    mintKey(type: KeyType, params: KeyStoreParams): string;
-    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
-    xadd(key: string, id: string, ...args: any[]): Promise<string | RedisMultiType>;
-    xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: 'BLOCK' | 'COUNT', blockTime: number | string, streamsOption: 'STREAMS', streamName: string, id: string): Promise<string[][][] | null>;
-    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number]>;
-    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
-    xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
-    xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
-    xlen(key: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
-}
-export { RedisStreamService };

package/build/services/stream/clients/redis.js

@@ -1,161 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisStreamService = void 0;
-const key_1 = require("../../../modules/key");
-const index_1 = require("../index");
-class RedisStreamService extends index_1.StreamService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = key_1.HMNS, appId, logger) {
-        this.namespace = namespace;
-        this.logger = logger;
-        this.appId = appId;
-    }
-    getMulti() {
-        return this.redisClient.multi();
-    }
-    mintKey(type, params) {
-        if (!this.namespace)
-            throw new Error('namespace not set');
-        return key_1.KeyService.mintKey(this.namespace, type, params);
-    }
-    async xgroup(command, key, groupName, id, mkStream) {
-        const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
-        try {
-            return ((await this.redisClient.sendCommand([
-                'XGROUP',
-                'CREATE',
-                key,
-                groupName,
-                id,
-                ...args,
-            ])) === 1);
-        }
-        catch (error) {
-            const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.error(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { ...error });
-            throw error;
-        }
-    }
-    async xadd(key, id, ...args) {
-        let multi;
-        if (typeof args[args.length - 1] !== 'string') {
-            multi = args.pop();
-        }
-        try {
-            return await (multi || this.redisClient).XADD(key, id, {
-                [args[0]]: args[1],
-            });
-        }
-        catch (error) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
-        try {
-            return await this.redisClient.sendCommand([
-                'XREADGROUP',
-                command,
-                groupName,
-                consumerName,
-                blockOption,
-                blockTime.toString(),
-                streamsOption,
-                streamName,
-                id,
-            ]);
-        }
-        catch (error) {
-            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { ...error });
-            throw error;
-        }
-    }
-    async xpending(key, group, start, end, count, consumer) {
-        try {
-            const args = [key, group];
-            if (start)
-                args.push(start);
-            if (end)
-                args.push(end);
-            if (count !== undefined)
-                args.push(count.toString());
-            if (consumer)
-                args.push(consumer);
-            try {
-                return await this.redisClient.sendCommand(['XPENDING', ...args]);
-            }
-            catch (error) {
-                this.logger.error('error, args', { ...error }, args);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error retrieving pending messages for group: ${group} in key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
-        try {
-            return (await this.redisClient.sendCommand([
-                'XCLAIM',
-                key,
-                group,
-                consumer,
-                minIdleTime.toString(),
-                id,
-                ...args,
-            ]));
-        }
-        catch (error) {
-            this.logger.error(`Error claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xack(key, group, id, multi) {
-        try {
-            if (multi) {
-                multi.XACK(key, group, id);
-                return multi;
-            }
-            else {
-                return await this.redisClient.XACK(key, group, id);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error acknowledging messages in group: ${group} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xdel(key, id, multi) {
-        try {
-            if (multi) {
-                multi.XDEL(key, id);
-                return multi;
-            }
-            else {
-                return await this.redisClient.XDEL(key, id);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error deleting messages with ids: ${id} for key: ${key}`, { ...error });
-            throw error;
-        }
-    }
-    async xlen(key, multi) {
-        try {
-            if (multi) {
-                multi.XLEN(key);
-                return multi;
-            }
-            else {
-                return await this.redisClient.XLEN(key);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error getting stream depth: ${key}`, { ...error });
-            throw error;
-        }
-    }
-}
-exports.RedisStreamService = RedisStreamService;