@hotmeshio/hotmesh 0.3.32 → 0.4.1

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

@@ -1 +1,180 @@
-'use strict';function b(c,d){const e=a();return b=function(f,g){f=f-0x1d0;let h=e[f];return h;},b(c,d);}const q=b;function a(){const y=['length','all','xadd','expire','hincrbyfloat','hsetnx','16qedZar','2965752PpZTmY','lrange','defineProperty','27nSssLe','1026BlQRvm','__esModule','xlen','lpop','sendCommand','4527465FOBpKS','./_base','RedisStoreBase','storeClient','2837070YThMDS','setnxex','WORK_ITEMS','hmget','62300KrhMyH','xack','forEach','exec','hGetAllResult','1572633DEZNmC','hget','map','hincrby','command','scan','set','args','zadd','xdel','zrange','hdel','xgroup','hgetall','string','1957490YAHgmi','addTaskQueues','1571540CApFVX','commands','hscan','IORedisStoreService','zrangebyscore','del','setnx','hset','xpending','isArray','multi'];a=function(){return y;};return a();}(function(c,d){const p=b,e=c();while(!![]){try{const f=parseInt(p(0x1f7))/0x1+parseInt(p(0x1ee))/0x2+-parseInt(p(0x1ea))/0x3+parseInt(p(0x1e0))/0x4*(-parseInt(p(0x208))/0x5)+-parseInt(p(0x1e5))/0x6*(-parseInt(p(0x1f2))/0x7)+-parseInt(p(0x1e1))/0x8+-parseInt(p(0x1e4))/0x9*(parseInt(p(0x206))/0xa);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xc08eb));Object[q(0x1e3)](exports,q(0x1e6),{'value':!0x0}),exports['IORedisStoreService']=void 0x0;const key_1=require('../../../../modules/key'),enums_1=require('../../../../modules/enums'),_base_1=require(q(0x1eb));class IORedisStoreService extends _base_1[q(0x1ec)]{constructor(c){const r=q;super(c),this[r(0x1d0)]={'get':'get','set':r(0x1fd),'setnx':r(0x1d5),'del':r(0x1d4),'expire':r(0x1dd),'hset':r(0x1d6),'hscan':r(0x1d1),'hsetnx':r(0x1df),'hincrby':r(0x1fa),'hdel':r(0x202),'hget':'hget','hmget':r(0x1f1),'hgetall':r(0x204),'hincrbyfloat':r(0x1de),'zrank':'zrank','zrange':r(0x201),'zrangebyscore_withscores':r(0x1d3),'zrangebyscore':'zrangebyscore','zrem':'zrem','zadd':r(0x1ff),'lmove':'lmove','lpop':r(0x1e8),'lrange':r(0x1e2),'rename':'rename','rpush':'rpush','scan':r(0x1fc),'xack':r(0x1f3),'xdel':r(0x200)};}['transact'](){const s=q,c=this;if(enums_1['HMSH_IS_CLUSTER']){const d=[],f=(h,i)=>(d['push']({'command':h,'args':i}),g),g={'sendCommand':h=>c[s(0x1ed)][s(0x1e9)](h),async 'exec'(){const t=s;if(0x0===d[t(0x1da)])return[];if(d['every'](h=>h[t(0x1fe)][0x0]===d[0x0][t(0x1fe)][0x0])){const h=c[t(0x1ed)][t(0x1d9)]();return d[t(0x1f4)](i=>h[i[t(0x1fb)]](...i[t(0x1fe)])),(await h[t(0x1f5)]())[t(0x1f9)](i=>i);}return Promise[t(0x1db)](d[t(0x1f9)](i=>c[t(0x1ed)][i[t(0x1fb)]](...i['args'])));},'xadd':(h,i,j,k)=>f(s(0x1dc),[h,i,j,k]),'xack':(h,i,j)=>f(s(0x1f3),[h,i,j]),'xdel':(h,i)=>f(s(0x200),[h,i]),'xlen':h=>f(s(0x1e7),[h]),'xpending':(h,j,k,l,m,o)=>f(s(0x1d7),[h,j,k,l,m,o]),'xclaim':(h,j,k,l,m,...o)=>f('xclaim',[h,j,k,l,m,...o]),'del':h=>f(s(0x1d4),[h]),'expire':function(h,i){const u=s;return f(u(0x1dd),[h,i]);},'hdel':(h,i)=>f(s(0x202),[h,i]),'hget':(h,i)=>f(s(0x1f8),[h,i]),'hgetall':h=>f(s(0x204),[h]),'hincrbyfloat':(h,i,j)=>f('hincrbyfloat',[h,i,j]),'hmget':(h,i)=>f(s(0x1f1),[h,i]),'hset':(h,i)=>f(s(0x1d6),[h,i]),'lrange':(h,i,j)=>f(s(0x1e2),[h,i,j]),'rpush':(h,i)=>f('rpush',[h,i]),'zadd':(...h)=>f(s(0x1ff),h),'xgroup':(h,i,j,k,l)=>f(s(0x203),[h,i,j,k,l])};return g;}return this[s(0x1ed)][s(0x1d9)]();}async['exec'](...c){const v=q,d=await this[v(0x1ed)]['call']['apply'](this[v(0x1ed)],c);return v(0x205)==typeof d?d:Array[v(0x1d8)](d)?(Array[v(0x1d8)](d[0x0]),d):d;}async[q(0x1ef)](c,d,f){const w=q,g=await this[w(0x1ed)][this[w(0x1d0)]['set']](c,d,'NX','EX',f['toString']());return this['isSuccessful'](g);}[q(0x1f6)](c){return c[0x1];}async[q(0x207)](c){const x=q,d=this['storeClient'][x(0x1d9)](),f=this['mintKey'](key_1['KeyType'][x(0x1f0)],{'appId':this['appId']});for(const g of c)d[x(0x1ff)](f,'NX',Date['now'](),g);await d[x(0x1f5)]();}}exports[q(0x1d2)]=IORedisStoreService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisStoreService = void 0;
+const key_1 = require("../../../../modules/key");
+const enums_1 = require("../../../../modules/enums");
+const _base_1 = require("./_base");
+class IORedisStoreService extends _base_1.RedisStoreBase {
+    constructor(storeClient) {
+        super(storeClient);
+        this.commands = {
+            get: 'get',
+            set: 'set',
+            setnx: 'setnx',
+            del: 'del',
+            expire: 'expire',
+            hset: 'hset',
+            hscan: 'hscan',
+            hsetnx: 'hsetnx',
+            hincrby: 'hincrby',
+            hdel: 'hdel',
+            hget: 'hget',
+            hmget: 'hmget',
+            hgetall: 'hgetall',
+            hincrbyfloat: 'hincrbyfloat',
+            zrank: 'zrank',
+            zrange: 'zrange',
+            zrangebyscore_withscores: 'zrangebyscore',
+            zrangebyscore: 'zrangebyscore',
+            zrem: 'zrem',
+            zadd: 'zadd',
+            lmove: 'lmove',
+            lpop: 'lpop',
+            lrange: 'lrange',
+            rename: 'rename',
+            rpush: 'rpush',
+            scan: 'scan',
+            xack: 'xack',
+            xdel: 'xdel',
+        };
+    }
+    /**
+     * When in cluster mode, the transact wrapper only
+     * sends commands to the same node/shard if they share a key.
+     * All other commands are sent simultaneouslyusing Promise.all
+     * and are then collated. this is effectiely a wrapper for
+     * `multi` but is closer to `pipeline` in terms of usage when
+     * promises are used.
+     */
+    transact() {
+        const my = this;
+        if (enums_1.HMSH_IS_CLUSTER) {
+            const commands = [];
+            const addCommand = (command, args) => {
+                commands.push({ command, args });
+                return multiInstance;
+            };
+            const multiInstance = {
+                sendCommand(command) {
+                    return my.storeClient.sendCommand(command);
+                },
+                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.storeClient.multi();
+                        commands.forEach((cmd) => multi[cmd.command](...cmd.args));
+                        const results = await multi.exec();
+                        return results.map((item) => item);
+                    }
+                    else {
+                        return Promise.all(commands.map((cmd) => my.storeClient[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]);
+                },
+                xpending(key, group, start, end, count, consumer) {
+                    return addCommand('xpending', [
+                        key,
+                        group,
+                        start,
+                        end,
+                        count,
+                        consumer,
+                    ]);
+                },
+                xclaim(key, group, consumer, minIdleTime, id, ...args) {
+                    return addCommand('xclaim', [
+                        key,
+                        group,
+                        consumer,
+                        minIdleTime,
+                        id,
+                        ...args,
+                    ]);
+                },
+                del(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, value) {
+                    return addCommand('rpush', [key, value]);
+                },
+                zadd(...args) {
+                    return addCommand('zadd', args);
+                },
+                xgroup(command, key, groupName, id, mkStream) {
+                    return addCommand('xgroup', [command, key, groupName, id, mkStream]);
+                },
+            };
+            return multiInstance;
+        }
+        return this.storeClient.multi();
+    }
+    async exec(...args) {
+        const response = await this.storeClient.call.apply(this.storeClient, args);
+        if (typeof response === 'string') {
+            return response;
+        }
+        else if (Array.isArray(response)) {
+            if (Array.isArray(response[0])) {
+                return response;
+            }
+            return response;
+        }
+        return response;
+    }
+    async setnxex(key, value, expireSeconds) {
+        const status = await this.storeClient[this.commands.set](key, value, 'NX', 'EX', expireSeconds.toString());
+        return this.isSuccessful(status);
+    }
+    hGetAllResult(result) {
+        //ioredis response signature is [null, {}] or [null, null]
+        return result[1];
+    }
+    async addTaskQueues(keys) {
+        const multi = this.storeClient.multi();
+        const zsetKey = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId });
+        for (const key of keys) {
+            multi.zadd(zsetKey, 'NX', Date.now(), key);
+        }
+        await multi.exec();
+    }
+}
+exports.IORedisStoreService = IORedisStoreService;

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

@@ -1 +1,199 @@
-'use strict';const r=b;(function(c,d){const q=b,e=c();while(!![]){try{const f=-parseInt(q(0x1ed))/0x1+-parseInt(q(0x1d6))/0x2*(parseInt(q(0x201))/0x3)+parseInt(q(0x1f0))/0x4*(parseInt(q(0x1ef))/0x5)+-parseInt(q(0x1fd))/0x6*(-parseInt(q(0x1f8))/0x7)+parseInt(q(0x1ee))/0x8+parseInt(q(0x1d1))/0x9+-parseInt(q(0x1eb))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xac267));function b(c,d){const e=a();return b=function(f,g){f=f-0x1c7;let h=e[f];return h;},b(c,d);}Object[r(0x1d7)](exports,r(0x1d9),{'value':!0x0}),exports['RedisStoreService']=void 0x0;const enums_1=require(r(0x1d2)),_base_1=require(r(0x1cb));function a(){const E=['args','setnxex','SET','1024760YBLnGQ','LMOVE','946727OIprQe','132960gkLVAS','2530sVTNLA','7412kQODgO','zadd','HINCRBY','RENAME','zRangeByScore','XGROUP','HMSH_IS_CLUSTER','HDEL','92477FlmMAu','XDEL','commands','multi','XPENDING','186AxWqDp','RedisStoreService','storeClient','GET','3spWNeH','push','zrangebyscore','all','ZRANGE','EXPIRE','XLEN','map','ZADD','SCAN','./_base','LRANGE','toString','SETNX','HMGET','HINCRBYFLOAT','10996839RvYRBQ','../../../../modules/enums','sendCommand','HSCAN','XCLAIM','1662640HZyqVu','defineProperty','ZRANGEBYSCORE','__esModule','exec','HGETALL','HGET','XACK','DEL','transact','RPUSH','Function\x20not\x20implemented.','length','toUpperCase','command','HSET','XADD','ZRANGEBYSCORE_WITHSCORES'];a=function(){return E;};return a();}class RedisStoreService extends _base_1['RedisStoreBase']{constructor(c){const s=r;super(c),this[s(0x1fa)]={'get':s(0x200),'set':s(0x1ea),'setnx':s(0x1ce),'del':s(0x1de),'expire':s(0x206),'hscan':s(0x1d4),'hset':s(0x1e5),'hsetnx':'HSETNX','hincrby':s(0x1f2),'hdel':'HDEL','hget':s(0x1dc),'hmget':s(0x1cf),'hgetall':s(0x1db),'hincrbyfloat':s(0x1d0),'zrange':s(0x205),'zrangebyscore_withscores':s(0x1e7),'zrangebyscore':s(0x1d8),'zrem':'ZREM','zadd':'ZADD','lmove':s(0x1ec),'lrange':'LRANGE','lpop':'LPOP','rename':s(0x1f3),'rpush':s(0x1e0),'scan':s(0x1ca),'xack':s(0x1dd),'xdel':s(0x1f9),'xlen':'XLEN'};}[r(0x1df)](){const t=r,c=this;if(enums_1[t(0x1f6)]){const d=[],f=(h,i)=>(d[t(0x202)]({'command':h[t(0x1e3)](),'args':i}),g),g={'sendCommand':(h,...i)=>c[t(0x1ff)][t(0x1d3)]([h,...i]),async 'exec'(){const u=t;if(0x0===d[u(0x1e2)])return[];if(d['every'](h=>h['args'][0x0]===d[0x0][u(0x1e8)][0x0])){const h=c[u(0x1ff)][u(0x1fb)]();return d['forEach'](i=>u(0x1c9)===i[u(0x1e4)]?h[u(0x1c9)](i[u(0x1e8)][0x0],i[u(0x1e8)][0x1],i[u(0x1e8)][0x2]):h[i['command']](...i[u(0x1e8)])),(await h[u(0x1da)]())[u(0x1c8)](i=>i);}return Promise[u(0x204)](d[u(0x1c8)](i=>u(0x1c9)===i[u(0x1e4)]?c[u(0x1ff)][u(0x1c9)](i[u(0x1e8)][0x0],i[u(0x1e8)][0x1],i['args'][0x2]):c[u(0x1ff)][i[u(0x1e4)]](...i[u(0x1e8)])));},'XADD':(h,i,j,k)=>f(t(0x1e6),[h,i,j,k]),'XACK':(h,i,j)=>f(t(0x1dd),[h,i,j]),'XDEL':(h,i)=>f(t(0x1f9),[h,i]),'XLEN':h=>f(t(0x1c7),[h]),'XCLAIM':(h,j,k,l,m,...p)=>f(t(0x1d5),[h,j,k,l,m,...p]),'XPENDING':(h,j,k,l,m,p)=>f(t(0x1fc),[h,j,k,l,m,p]),'DEL':function(h){return f('DEL',[h]);},'EXPIRE':function(h,i){const v=t;return f(v(0x206),[h,i]);},'HDEL':(h,i)=>f(t(0x1f7),[h,i]),'HGET':(h,i)=>f('HGET',[h,i]),'HGETALL':h=>f(t(0x1db),[h]),'HINCRBYFLOAT':(h,i,j)=>f('HINCRBYFLOAT',[h,i,j]),'HMGET':(h,i)=>f(t(0x1cf),[h,i]),'HSET':(h,i)=>f(t(0x1e5),[h,i]),'LRANGE':(h,i,j)=>f(t(0x1cc),[h,i,j]),'RPUSH':(h,i)=>f('RPUSH',[h,i]),'ZADD':(h,i,j)=>f(t(0x1c9),[h,i,j]),'XGROUP':(h,i,j,k,l)=>f(t(0x1f5),[h,i,j,k,l]),'EXISTS':function(h){const w=t;throw new Error(w(0x1e1));},'HMPUSH':function(h,i){const x=t;throw new Error(x(0x1e1));},'LPUSH':function(h,i){throw new Error('Function\x20not\x20implemented.');},'SET':function(h,i){const y=t;throw new Error(y(0x1e1));},'ZRANGE_WITHSCORES':function(h,i,j){throw new Error('Function\x20not\x20implemented.');},'ZRANK':function(h,i){throw new Error('Function\x20not\x20implemented.');},'ZSCORE':function(h,i){const z=t;throw new Error(z(0x1e1));}};return g;}return this[t(0x1ff)][t(0x1fb)]();}async[r(0x1da)](...c){const A=r;return await this[A(0x1ff)]['sendCommand'](c);}async[r(0x1e9)](c,d,f){const B=r,g=await this[B(0x1ff)][this[B(0x1fa)]['set']](c,d,{'NX':!0x0,'EX':f});return this['isSuccessful'](g);}async['zAdd'](c,d,f,g){const C=r;return await(g||this[C(0x1ff)])[this[C(0x1fa)][C(0x1f1)]](c,{'score':d,'value':f[C(0x1cd)]()});}async[r(0x1f4)](c,d,f){const D=r,g=await this['storeClient'][this[D(0x1fa)][D(0x203)]](c,d,f);return g?.[D(0x1e2)]>0x0?g[0x0]:null;}}exports[r(0x1fe)]=RedisStoreService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStoreService = void 0;
+const enums_1 = require("../../../../modules/enums");
+const _base_1 = require("./_base");
+class RedisStoreService extends _base_1.RedisStoreBase {
+    constructor(storeClient) {
+        super(storeClient);
+        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',
+            lpop: 'LPOP',
+            rename: 'RENAME',
+            rpush: 'RPUSH',
+            scan: 'SCAN',
+            xack: 'XACK',
+            xdel: 'XDEL',
+            xlen: 'XLEN',
+        };
+    }
+    /**
+     * When in cluster mode, the transact wrapper only
+     * sends commands to the same node/shard if they share a key.
+     * All other commands are sent simultaneouslyusing Promise.all
+     * and are then collated
+     */
+    transact() {
+        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.storeClient.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.storeClient.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.storeClient.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
+                            }
+                            return my.storeClient[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.storeClient.multi();
+    }
+    async exec(...args) {
+        return await this.storeClient.sendCommand(args);
+    }
+    async setnxex(key, value, expireSeconds) {
+        const status = await this.storeClient[this.commands.set](key, value, { NX: true, EX: expireSeconds });
+        return this.isSuccessful(status);
+    }
+    async zAdd(key, score, value, redisMulti) {
+        return await (redisMulti || this.storeClient)[this.commands.zadd](key, {
+            score: score,
+            value: value.toString(),
+        });
+    }
+    async zRangeByScore(key, score, value) {
+        const result = await this.storeClient[this.commands.zrangebyscore](key, score, value);
+        if (result?.length > 0) {
+            return result[0];
+        }
+        return null;
+    }
+}
+exports.RedisStoreService = RedisStoreService;

package/build/services/store/providers/store-initializable.js

@@ -1 +1,2 @@
-'use strict';function a(){var j=['defineProperty','1191752MjdDyi','1194160QaIpYr','317610eopEAA','852628eyWdST','584235yNrdsV','14myhRas','316154KGQqcM','121053dOUyUg'];a=function(){return j;};return a();}var i=b;function b(c,d){var e=a();return b=function(f,g){f=f-0x16d;var h=e[f];return h;},b(c,d);}(function(c,d){var h=b,e=c();while(!![]){try{var f=-parseInt(h(0x172))/0x1+parseInt(h(0x171))/0x2+parseInt(h(0x16f))/0x3+-parseInt(h(0x16e))/0x4+-parseInt(h(0x175))/0x5+parseInt(h(0x16d))/0x6+parseInt(h(0x170))/0x7*(parseInt(h(0x174))/0x8);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x1fe5d));Object[i(0x173)](exports,'__esModule',{'value':!0x0});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/services/stream/index.d.ts

@@ -26,6 +26,8 @@ export declare abstract class StreamService<ClientProvider extends ProviderClien
         initialBackoff?: number;
         maxBackoff?: number;
         maxRetries?: number;
+        enableNotifications?: boolean;
+        notificationCallback?: (messages: StreamMessage[]) => void;
     }): Promise<StreamMessage[]>;
     abstract transact(): ProviderTransaction;
     abstract ackAndDelete(streamName: string, groupName: string, messageIds: string[], options?: StringAnyType): Promise<number>;
@@ -58,7 +60,10 @@ export declare abstract class StreamService<ClientProvider extends ProviderClien
         supportsOrdering: boolean;
         supportsTrimming: boolean;
         supportsRetry: boolean;
+        supportsNotifications?: boolean;
         maxMessageSize: number;
         maxBatchSize: number;
     };
+    stopNotificationConsumer?(streamName: string, groupName: string): Promise<void>;
+    cleanup?(): Promise<void>;
 }

package/build/services/stream/providers/nats/nats.d.ts

@@ -52,6 +52,7 @@ declare class NatsStreamService extends StreamService<NatsClientType, NatsPubAck
         supportsOrdering: boolean;
         supportsTrimming: boolean;
         supportsRetry: boolean;
+        supportsNotifications: boolean;
         maxMessageSize: number;
         maxBatchSize: number;
     };

package/build/services/stream/providers/nats/nats.js

@@ -1 +1,225 @@
-'use strict';const p=b;(function(c,d){const o=b,e=c();while(!![]){try{const f=-parseInt(o(0x10c))/0x1*(-parseInt(o(0x117))/0x2)+parseInt(o(0x11c))/0x3+parseInt(o(0x137))/0x4+-parseInt(o(0x110))/0x5*(parseInt(o(0x122))/0x6)+parseInt(o(0x136))/0x7*(parseInt(o(0x10e))/0x8)+-parseInt(o(0x118))/0x9+-parseInt(o(0x100))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xc5cc0));function b(c,d){const e=a();return b=function(f,g){f=f-0xef;let h=e[f];return h;},b(c,d);}Object[p(0x10a)](exports,p(0xf7),{'value':!0x0}),exports[p(0xf1)]=void 0x0;function a(){const H=['.message','getStreamStats','defineProperty','jsm','182786OwlwaU','batchSize','155864IoZrHr','../../../../modules/enums','340865TGSmJa','acknowledgeMessages','blockTimeout','init','Error\x20creating\x20consumer\x20group\x20','Error\x20trimming\x20stream\x20','Error\x20publishing\x20messages\x20to\x20','10Mzihxd','7400439kptAEb','../../../../modules/key','Error\x20getting\x20multiple\x20stream\x20depths','consumeMessages','4050537aKQVMz','Error\x20deleting\x20consumer\x20group\x20','from','jetstream','seq','appId','24YgAIPD','../../index','createConsumerGroup','jetstreamManager','ackAndDelete','explicit','maxAge','length','getStreamDepth','info','Error\x20deleting\x20stream\x20','publishMessages','StreamService','memory','publish','Error\x20creating\x20stream\x20','namespace\x20not\x20set','toString','update','Error\x20deleting\x20messages\x20from\x20','399kbTnuC','6130732LHtyap','deleteMessage','mintKey','KeyService','HMSH_BLOCK_TIME_MS','string','delete','map','consumers','createStream','parseStreamMessage','logger','NatsStreamService','\x20for\x20stream\x20','maxLen','getProviderSpecificFeatures','get','Error\x20getting\x20stats\x20for\x20','__esModule','deleteMessages','namespace','state','config','deleteConsumerGroup','transact','all','add','30021840kkozpg','push','streams','fetch','messages','error','Error\x20consuming\x20messages\x20from\x20','Error\x20getting\x20depth\x20for\x20'];a=function(){return H;};return a();}const index_1=require(p(0x123)),key_1=require(p(0x119)),enums_1=require(p(0x10f)),utils_1=require('../../../../modules/utils');class NatsStreamService extends index_1[p(0x12e)]{constructor(c,d,f={}){const q=p;super(c,d,f),this[q(0x11f)]=c[q(0x11f)]();}async[p(0x113)](c,d,f){const r=p;this['namespace']=c,this[r(0xf0)]=f,this[r(0x121)]=d,this[r(0x10b)]=await this[r(0x11f)][r(0x125)]();}[p(0x139)](c,d){const s=p;if(!this[s(0xf9)])throw new Error(s(0x132));return key_1[s(0x13a)][s(0x139)](this[s(0xf9)],c,{...d,'appId':this[s(0x121)]});}[p(0xfd)](){return{};}async[p(0x140)](c){const t=p;try{const d={'name':c,'subjects':[c+'.*'],'retention':'workqueue','storage':t(0x12f),'num_replicas':0x1};return await this['jsm'][t(0x102)][t(0xff)](d),!0x0;}catch(f){throw this[t(0xf0)][t(0x105)](t(0x131)+c,{'error':f}),f;}}async['deleteStream'](c){const u=p;try{return await this[u(0x10b)][u(0x102)][u(0x13d)](c),!0x0;}catch(d){throw this[u(0xf0)][u(0x105)](u(0x12c)+c,{'error':d}),d;}}async[p(0x124)](c,d){const v=p;try{const f={'durable_name':d,'deliver_group':d,'ack_policy':v(0x127),'ack_wait':0x7530,'max_deliver':0xa};return await this[v(0x10b)][v(0x13f)][v(0xff)](c,f),!0x0;}catch(g){throw this['logger'][v(0x105)](v(0x114)+d+v(0xf2)+c,{'error':g}),g;}}async[p(0xfc)](c,d){const w=p;try{return await this['jsm'][w(0x13f)][w(0x13d)](c,d),!0x0;}catch(f){throw this[w(0xf0)]['error'](w(0x11d)+d+w(0xf2)+c,{'error':f}),f;}}async[p(0x12d)](c,d,f){const x=p;try{const g=d[x(0x13e)](async h=>{const y=x,i=c+y(0x108);return await this[y(0x11f)][y(0x130)](i,Buffer[y(0x11e)](h));});return(await Promise[x(0xfe)](g))[x(0x13e)](h=>h[x(0x120)]['toString']());}catch(h){throw this[x(0xf0)][x(0x105)](x(0x116)+c,{'error':h}),h;}}async[p(0x11b)](c,d,f,g){const z=p;try{const h=await this['jetstream'][z(0x13f)][z(0xf5)](c,d),j=[],k={'max_messages':g?.[z(0x10d)]||0x1,'expires':g?.[z(0x112)]||enums_1[z(0x13b)]},l=await h[z(0x103)](k);for await(const m of l)j[z(0x101)]({'id':m[z(0x120)][z(0x133)](),'data':(0x0,utils_1[z(0xef)])(m[z(0x13c)]())});return j;}catch(n){throw this[z(0xf0)]['error'](z(0x106)+c,{'error':n}),n;}}async[p(0x126)](c,d,f){const A=p;try{return await this[A(0x111)](c,d,f),f[A(0x129)];}catch(g){throw this['logger']['error']('Error\x20in\x20ack\x20and\x20delete\x20for\x20stream\x20'+c,{'error':g}),g;}}async[p(0x111)](c,d,f,g){const B=p;return f[B(0x129)];}async[p(0xf8)](c,d,f,g){const C=p;try{return await Promise[C(0xfe)](f[C(0x13e)](h=>this[C(0x10b)][C(0x102)][C(0x138)](c,parseInt(h)))),f[C(0x129)];}catch(h){throw this['logger']['error'](C(0x135)+c,{'error':h}),h;}}async['retryMessages'](c,d,f){return[];}async[p(0x109)](c){const D=p;try{return{'messageCount':(await this[D(0x10b)][D(0x102)]['info'](c))[D(0xfa)][D(0x104)]};}catch(d){throw this[D(0xf0)]['error'](D(0xf6)+c,{'error':d}),d;}}async['getStreamDepth'](c){const E=p;try{return(await this[E(0x10b)][E(0x102)][E(0x12b)](c))[E(0xfa)][E(0x104)];}catch(d){throw this['logger']['error'](E(0x107)+c,{'error':d}),d;}}async['getStreamDepths'](c){const F=p;try{return await Promise[F(0xfe)](c[F(0x13e)](async({stream:d})=>({'stream':d,'depth':await this[F(0x12a)](d)})));}catch(d){throw this[F(0xf0)][F(0x105)](F(0x11a),{'error':d}),d;}}async['trimStream'](c,d){const G=p;try{const f={...(await this['jsm'][G(0x102)][G(0x12b)](c))[G(0xfb)]};return void 0x0!==d[G(0xf3)]&&(f['max_msgs']=d[G(0xf3)]),void 0x0!==d[G(0x128)]&&(f['max_age']=0x3b9aca00*d['maxAge']),await this[G(0x10b)][G(0x102)][G(0x134)](c,f),0x0;}catch(g){throw this[G(0xf0)][G(0x105)](G(0x115)+c,{'error':g}),g;}}[p(0xf4)](){return{'supportsBatching':!0x0,'supportsDeadLetterQueue':!0x0,'supportsOrdering':!0x0,'supportsTrimming':!0x0,'supportsRetry':!0x1,'maxMessageSize':0x100000,'maxBatchSize':0x100};}}exports[p(0xf1)]=NatsStreamService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsStreamService = void 0;
+const index_1 = require("../../index");
+const key_1 = require("../../../../modules/key");
+const enums_1 = require("../../../../modules/enums");
+const utils_1 = require("../../../../modules/utils");
+class NatsStreamService extends index_1.StreamService {
+    constructor(streamClient, storeClient, config = {}) {
+        super(streamClient, storeClient, config);
+        this.jetstream = streamClient.jetstream();
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.jsm = await this.jetstream.jetstreamManager();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, {
+            ...params,
+            appId: this.appId,
+        });
+    }
+    transact() {
+        return {};
+    }
+    async createStream(streamName) {
+        try {
+            const config = {
+                name: streamName,
+                subjects: [`${streamName}.*`],
+                retention: 'workqueue',
+                storage: 'memory',
+                num_replicas: 1,
+            };
+            await this.jsm.streams.add(config);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error creating stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async deleteStream(streamName) {
+        try {
+            await this.jsm.streams.delete(streamName);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async createConsumerGroup(streamName, groupName) {
+        try {
+            const consumerConfig = {
+                durable_name: groupName,
+                deliver_group: groupName,
+                ack_policy: 'explicit',
+                ack_wait: 30 * 1000,
+                max_deliver: 10,
+            };
+            await this.jsm.consumers.add(streamName, consumerConfig);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error creating consumer group ${groupName} for stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async deleteConsumerGroup(streamName, groupName) {
+        try {
+            await this.jsm.consumers.delete(streamName, groupName);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting consumer group ${groupName} for stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async publishMessages(streamName, messages, options) {
+        try {
+            const publishPromises = messages.map(async (message) => {
+                const subject = `${streamName}.message`;
+                const ack = await this.jetstream.publish(subject, Buffer.from(message));
+                return ack;
+            });
+            const acks = await Promise.all(publishPromises);
+            return acks.map((ack) => ack.seq.toString());
+        }
+        catch (error) {
+            this.logger.error(`Error publishing messages to ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async consumeMessages(streamName, groupName, consumerName, options) {
+        try {
+            const consumer = await this.jetstream.consumers.get(streamName, groupName);
+            const messages = [];
+            const fetchOptions = {
+                max_messages: options?.batchSize || 1,
+                expires: options?.blockTimeout || enums_1.HMSH_BLOCK_TIME_MS,
+            };
+            const fetchedMessages = await consumer.fetch(fetchOptions);
+            for await (const msg of fetchedMessages) {
+                messages.push({
+                    id: msg.seq.toString(),
+                    data: (0, utils_1.parseStreamMessage)(msg.string()),
+                });
+            }
+            return messages;
+        }
+        catch (error) {
+            this.logger.error(`Error consuming messages from ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async ackAndDelete(streamName, groupName, messageIds) {
+        try {
+            await this.acknowledgeMessages(streamName, groupName, messageIds);
+            return messageIds.length;
+        }
+        catch (error) {
+            this.logger.error(`Error in ack and delete for stream ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async acknowledgeMessages(streamName, groupName, messageIds, options) {
+        //no-op
+        return messageIds.length;
+    }
+    async deleteMessages(streamName, groupName, messageIds, options) {
+        try {
+            await Promise.all(messageIds.map((id) => this.jsm.streams.deleteMessage(streamName, parseInt(id))));
+            return messageIds.length;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting messages from ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async retryMessages(streamName, groupName, options) {
+        return [];
+    }
+    async getStreamStats(streamName) {
+        try {
+            const info = await this.jsm.streams.info(streamName);
+            return {
+                messageCount: info.state.messages,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error getting stats for ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async getStreamDepth(streamName) {
+        try {
+            const info = await this.jsm.streams.info(streamName);
+            return info.state.messages;
+        }
+        catch (error) {
+            this.logger.error(`Error getting depth for ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async getStreamDepths(streamNames) {
+        try {
+            const results = await Promise.all(streamNames.map(async ({ stream }) => ({
+                stream,
+                depth: await this.getStreamDepth(stream),
+            })));
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Error getting multiple stream depths', { error });
+            throw error;
+        }
+    }
+    async trimStream(streamName, options) {
+        try {
+            // Retrieve the current stream info
+            const streamInfo = await this.jsm.streams.info(streamName);
+            const config = { ...streamInfo.config }; // Clone to avoid direct mutation
+            // Apply new limits based on options
+            if (options.maxLen !== undefined) {
+                config.max_msgs = options.maxLen;
+            }
+            if (options.maxAge !== undefined) {
+                config.max_age = options.maxAge * 1e9; // Convert maxAge to nanoseconds
+            }
+            // Update the stream with the modified config
+            await this.jsm.streams.update(streamName, config);
+            return 0; // Trimming is applied automatically based on updated config
+        }
+        catch (error) {
+            this.logger.error(`Error trimming stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    getProviderSpecificFeatures() {
+        return {
+            supportsBatching: true,
+            supportsDeadLetterQueue: true,
+            supportsOrdering: true,
+            supportsTrimming: true,
+            supportsRetry: false,
+            supportsNotifications: false,
+            maxMessageSize: 1024 * 1024,
+            maxBatchSize: 256,
+        };
+    }
+}
+exports.NatsStreamService = NatsStreamService;