@hotmeshio/hotmesh 0.3.32 → 0.4.1

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

@@ -1 +1,272 @@
-'use strict';function b(c,d){const e=a();return b=function(f,g){f=f-0x119;let h=e[f];return h;},b(c,d);}function a(){const L=['1233943yALXpK','createConsumerGroup','defineProperty','length','storeClient','Error\x20in\x20deleting\x20messages:\x20','xclaim','claimMessage','\x20for\x20key:\x20','publishMessages','get','Error\x20deleting\x20consumer\x20group\x20','4WfCEeb','Error\x20consuming\x20messages\x20from\x20','__esModule','../../../../modules/enums','consumeMessages','xadd','multi','XPENDING','xack','Error\x20deleting\x20stream\x20','namespace','198OEdhGL','GROUP','acknowledgeMessages','Error\x20in\x20claiming\x20message\x20with\x20id:\x20','transaction','exec','getStreamDepth','ackAndDelete','error','createStream','toString','getStreamDepths','forEach','../../index','field','xdel','appId','deleteConsumerGroup','getProviderSpecificFeatures','logger','xlen','keys','Error\x20in\x20retrieving\x20pending\x20messages\x20for\x20[stream\x20','../../../../modules/utils','xgroup','963473iyiBji','KeyService','has','deleteStream','5968670wYKMdb','30ChHSBD','ioredis-xadd-error\x20key:\x20','streamClient','HMSH_BLOCK_TIME_MS','init','344920XrBbfn','StreamService','map','Error\x20getting\x20depth\x20for\x20','CREATE','isArray','mintKey','call','4Pazkbp','Error\x20in\x20acknowledging\x20messages:\x20[','IORedisStreamService','push','stream','message','Error\x20creating\x20stream\x20','debug','1873941pfAyhZ','STREAMS','isStreamMessage','minIdleTime','getPendingMessages','trimStream','18767796niQEga','set','12045110ClijYr','consumerName','22MJQrwY','xreadgroup'];a=function(){return L;};return a();}const r=b;(function(c,d){const q=b,e=c();while(!![]){try{const f=parseInt(q(0x146))/0x1+parseInt(q(0x132))/0x2*(-parseInt(q(0x13a))/0x3)+parseInt(q(0x152))/0x4*(-parseInt(q(0x124))/0x5)+-parseInt(q(0x125))/0x6*(parseInt(q(0x120))/0x7)+parseInt(q(0x12a))/0x8*(parseInt(q(0x15d))/0x9)+-parseInt(q(0x142))/0xa+-parseInt(q(0x144))/0xb*(-parseInt(q(0x140))/0xc);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xedf71));Object[r(0x148)](exports,r(0x154),{'value':!0x0}),exports[r(0x134)]=void 0x0;const index_1=require(r(0x16a)),utils_1=require(r(0x11e)),key_1=require('../../../../modules/key'),enums_1=require(r(0x155));class IORedisStreamService extends index_1[r(0x12b)]{constructor(c,d,f={}){super(c,d,f);}async[r(0x129)](c,d,f){const s=r;this[s(0x15c)]=c,this['logger']=f,this[s(0x16d)]=d;}[r(0x130)](c,d){const t=r;if(!this[t(0x15c)])throw new Error('namespace\x20not\x20set');return key_1[t(0x121)][t(0x130)](this[t(0x15c)],c,{...d,'appId':this['appId']});}['transact'](){const u=r;return this[u(0x127)]['multi']();}async[r(0x166)](c){const v=r;try{const d=await this[v(0x127)][v(0x157)](c,'*',v(0x16b),'value');return await this[v(0x127)][v(0x16c)](c,d),!0x0;}catch(f){throw this[v(0x11a)][v(0x165)](v(0x138)+c,{'error':f}),f;}}async[r(0x123)](c){const w=r;try{return await this[w(0x127)]['del'](c)>0x0;}catch(d){throw this[w(0x11a)]['error'](w(0x15b)+c,{'error':d}),d;}}async[r(0x147)](c,d){const x=r;try{return'OK'===await this[x(0x14a)][x(0x11f)](x(0x12e),c,d,'$','MKSTREAM');}catch(f){throw this[x(0x11a)][x(0x139)]('stream-mkstream-caught',{'key':c,'group':d}),f;}}async[r(0x16e)](c,d){const y=r;try{return 0x1===await this[y(0x127)][y(0x11f)]('DESTROY',c,d);}catch(f){throw this[y(0x11a)][y(0x165)](y(0x151)+d+'\x20for\x20stream\x20'+c,{'error':f}),f;}}async[r(0x14f)](c,d,f){const z=r;try{const g=f?.[z(0x161)]||d[z(0x149)]>0x1&&this['storeClient'][z(0x158)]();let h;for(const i of d)h=await(g||this[z(0x14a)])[z(0x157)](c,'*',z(0x137),i);return g&&!f?.['transaction']?(await g[z(0x162)]())[z(0x12c)](j=>j[0x1]):[h];}catch(j){throw this['logger'][z(0x165)](z(0x126)+c,{'error':j}),j;}}async[r(0x156)](c,d,f,g){const A=r;try{const h=await this[A(0x127)][A(0x145)](A(0x15e),d,f,'BLOCK',g?.['blockTimeout']??enums_1[A(0x128)],A(0x13b),c,'>'),j=[];if(!(0x0,utils_1[A(0x13c)])(h))return[];{const [[,k]]=h;for(const [l,m]of k)j[A(0x135)]({'id':l,'data':(0x0,utils_1['parseStreamMessage'])(m[0x1])});}return j;}catch(n){throw this['logger'][A(0x165)](A(0x153)+c,{'error':n}),n;}}async[r(0x164)](c,d,f){const B=r,g=this[B(0x14a)]['multi']();return this['acknowledgeMessages'](c,d,f,{'multi':g}),this['deleteMessages'](c,d,f,{'multi':g}),await g[B(0x162)](),f[B(0x149)];}async[r(0x15f)](c,d,f,g){const C=r;try{return g?.['multi']?(g[C(0x158)][C(0x15a)](c,d,...f),g[C(0x158)]):await this['streamClient'][C(0x15a)](c,d,...f);}catch(h){throw this[C(0x11a)][C(0x165)](C(0x133)+f+']\x20in\x20group:\x20'+d+'\x20for\x20key:\x20'+c,{'error':h}),h;}}async['deleteMessages'](c,d,f,g){const D=r;try{return g?.[D(0x158)]?(g[D(0x158)][D(0x16c)](c,...f),g[D(0x158)]):await this[D(0x127)][D(0x16c)](c,...f);}catch(h){throw this[D(0x11a)][D(0x165)](D(0x14b)+f+'\x20for\x20key:\x20'+c,{'error':h}),h;}}async['getPendingMessages'](c,d,f,g){const E=r;try{const h=[c,d];h['push']('-'),h[E(0x135)]('+'),void 0x0!==f&&h['push'](f[E(0x167)]()),g&&h[E(0x135)](g);try{return await this[E(0x127)][E(0x131)](E(0x159),...h);}catch(i){this[E(0x11a)][E(0x165)]('err,\x20args',{'error':i},h);}}catch(j){throw this[E(0x11a)][E(0x165)](E(0x11d)+c+'],\x20[group\x20'+d+']',{'error':j}),j;}}async['retryMessages'](c,d,f){const F=r;let g=[];const h=await this[F(0x13e)](c,d,f?.['limit']);for(const j of h)if(Array[F(0x12f)](j)){const [k,,l,m]=j;if(l>f?.[F(0x13d)]){const p=await this['claimMessage'](c,d,f?.[F(0x143)],f?.[F(0x13d)],k);g=g['concat'](p);}}return g;}async[r(0x14d)](c,d,f,g,h,...j){const G=r;try{const k=await this[G(0x127)][G(0x14c)](c,d,f,g,h,...j);return{'id':k[0x0][0x0],'data':(0x0,utils_1['parseStreamMessage'])(k[0x0][0x1][0x1])};}catch(l){throw this[G(0x11a)]['error'](G(0x160)+h+'\x20in\x20group:\x20'+d+G(0x14e)+c,{'error':l}),l;}}async['getStreamStats'](c){const H=r;return{'messageCount':await this[H(0x163)](c)};}async['getStreamDepth'](c,d){const I=r;try{if(d?.['multi'])return d[I(0x158)][I(0x11b)](c),0x0;return await this['streamClient'][I(0x11b)](c);}catch(f){throw this[I(0x11a)][I(0x165)](I(0x12d)+c,{'error':f}),f;}}async[r(0x168)](c){const J=r,d=this['storeClient'][J(0x158)](),f=new Map();c[J(0x169)](h=>{const K=J;f[K(0x122)](h[K(0x136)])||(f[K(0x141)](h['stream'],-0x1),this['getStreamDepth'](h[K(0x136)],{'multi':d}));});const g=await d[J(0x162)]();return Array['from'](f[J(0x11c)]())['forEach']((h,i)=>{f['set'](h,g[i][0x1]);}),c[J(0x12c)](h=>({'stream':h[J(0x136)],'depth':f[J(0x150)](h[J(0x136)])||0x0}));}async[r(0x13f)](c,d){return 0x0;}[r(0x119)](){return{'supportsBatching':!0x0,'supportsDeadLetterQueue':!0x1,'supportsOrdering':!0x0,'supportsTrimming':!0x0,'supportsRetry':!0x0,'maxMessageSize':0x20000000,'maxBatchSize':0x3e8};}}exports[r(0x134)]=IORedisStreamService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisStreamService = void 0;
+const index_1 = require("../../index");
+const utils_1 = require("../../../../modules/utils");
+const key_1 = require("../../../../modules/key");
+const enums_1 = require("../../../../modules/enums");
+class IORedisStreamService extends index_1.StreamService {
+    constructor(streamClient, storeClient, config = {}) {
+        super(streamClient, storeClient, config);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    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 this.streamClient.multi();
+    }
+    // Core streaming operations
+    async createStream(streamName) {
+        try {
+            // streams are created when you add messages.
+            // To create an empty stream, we can add and delete a dummy message.
+            const dummyId = await this.streamClient.xadd(streamName, '*', 'field', 'value');
+            await this.streamClient.xdel(streamName, dummyId);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error creating stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async deleteStream(streamName) {
+        try {
+            const result = await this.streamClient.del(streamName);
+            return result > 0;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    // Consumer group operations
+    async createConsumerGroup(key, groupName) {
+        try {
+            return ((await this.storeClient.xgroup('CREATE', key, groupName, '$', 'MKSTREAM')) === 'OK');
+        }
+        catch (err) {
+            this.logger.debug('stream-mkstream-caught', { key, group: groupName });
+            throw err;
+        }
+    }
+    async deleteConsumerGroup(streamName, groupName) {
+        try {
+            const result = await this.streamClient.xgroup('DESTROY', streamName, groupName);
+            return result === 1;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting consumer group ${groupName} for stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    // Message operations
+    async publishMessages(streamName, messages, options) {
+        try {
+            const multi = options?.transaction ||
+                (messages.length > 1 && this.storeClient.multi());
+            let response;
+            for (const message of messages) {
+                response = await (multi || this.storeClient).xadd(streamName, '*', 'message', message);
+            }
+            if (multi && !options?.transaction) {
+                //only exec if we created the multi;
+                //otherwise caller is responsible
+                return (await multi.exec()).map((result) => result[1]);
+            }
+            else {
+                return [response];
+            }
+        }
+        catch (error) {
+            this.logger.error(`ioredis-xadd-error key: ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async consumeMessages(streamName, groupName, consumerName, options) {
+        try {
+            const result = await this.streamClient.xreadgroup('GROUP', groupName, consumerName, 'BLOCK', options?.blockTimeout ?? enums_1.HMSH_BLOCK_TIME_MS, 'STREAMS', streamName, '>');
+            const response = [];
+            if ((0, utils_1.isStreamMessage)(result)) {
+                const [[, messages]] = result;
+                for (const [id, message] of messages) {
+                    response.push({
+                        id,
+                        data: (0, utils_1.parseStreamMessage)(message[1]),
+                    });
+                }
+            }
+            else {
+                return [];
+            }
+            return response;
+        }
+        catch (error) {
+            this.logger.error(`Error consuming messages from ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async ackAndDelete(stream, group, ids) {
+        const multi = this.storeClient.multi();
+        this.acknowledgeMessages(stream, group, ids, { multi });
+        this.deleteMessages(stream, group, ids, { multi });
+        await multi.exec();
+        return ids.length;
+    }
+    async acknowledgeMessages(stream, group, ids, options) {
+        try {
+            if (options?.multi) {
+                options.multi.xack(stream, group, ...ids);
+                return options.multi;
+            }
+            else {
+                return await this.streamClient.xack(stream, group, ...ids);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages: [${ids}] in group: ${group} for key: ${stream}`, { error });
+            throw error;
+        }
+    }
+    async deleteMessages(stream, group, ids, options) {
+        try {
+            if (options?.multi) {
+                options.multi.xdel(stream, ...ids);
+                return options.multi;
+            }
+            else {
+                return await this.streamClient.xdel(stream, ...ids);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in deleting messages: ${ids} for key: ${stream}`, { error });
+            throw error;
+        }
+    }
+    async getPendingMessages(stream, group, count, consumer) {
+        const start = '-';
+        const end = '+';
+        try {
+            const args = [stream, 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.streamClient.call('XPENDING', ...args));
+            }
+            catch (error) {
+                this.logger.error('err, args', { error }, args);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${stream}], [group ${group}]`, { error });
+            throw error;
+        }
+    }
+    // Retry Method
+    async retryMessages(streamName, groupName, options) {
+        let pendingMessages = [];
+        const pendingMessagesInfo = await this.getPendingMessages(streamName, groupName, options?.limit); //[[ '1688768134881-0', 'testConsumer1', 1017, 1 ]]
+        for (const pendingMessageInfo of pendingMessagesInfo) {
+            if (Array.isArray(pendingMessageInfo)) {
+                const [id, , elapsedTimeMs, deliveryCount] = pendingMessageInfo;
+                if (elapsedTimeMs > options?.minIdleTime) {
+                    const reclaimedMessage = await this.claimMessage(streamName, groupName, options?.consumerName, options?.minIdleTime, id);
+                    pendingMessages = pendingMessages.concat(reclaimedMessage);
+                }
+            }
+        }
+        return pendingMessages;
+    }
+    async claimMessage(streamName, groupName, consumerName, minIdleTime, messageId, ...args) {
+        try {
+            const message = (await this.streamClient.xclaim(streamName, groupName, consumerName, minIdleTime, messageId, ...args));
+            return {
+                id: message[0][0],
+                data: (0, utils_1.parseStreamMessage)(message[0][1][1]),
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${messageId} in group: ${groupName} for key: ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async getStreamStats(streamName) {
+        return {
+            messageCount: await this.getStreamDepth(streamName),
+        };
+    }
+    async getStreamDepth(streamName, options) {
+        try {
+            if (options?.multi) {
+                options.multi.xlen(streamName);
+                return 0;
+            }
+            const length = await this.streamClient.xlen(streamName);
+            return length;
+        }
+        catch (error) {
+            this.logger.error(`Error getting depth for ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async getStreamDepths(streamNames) {
+        const multi = this.storeClient.multi();
+        const uniqueStreams = new Map(); // to store unique streams
+        // Add unique streams to the multi command
+        streamNames.forEach((profile) => {
+            if (!uniqueStreams.has(profile.stream)) {
+                uniqueStreams.set(profile.stream, -1); // initialize depth to -1 as a placeholder
+                this.getStreamDepth(profile.stream, { multi });
+            }
+        });
+        // Execute all commands
+        const streamDepthResults = (await multi.exec());
+        // Update the uniqueStreams map with the actual depths from multi.exec() results
+        Array.from(uniqueStreams.keys()).forEach((stream, idx) => {
+            uniqueStreams.set(stream, streamDepthResults[idx][1]);
+        });
+        // Map back to the original `streamNames` array with correct depths
+        const updatedNames = streamNames.map((profile) => {
+            return {
+                stream: profile.stream,
+                depth: uniqueStreams.get(profile.stream) || 0,
+            };
+        });
+        return updatedNames;
+    }
+    async trimStream(streamName, options) {
+        //no-op for now
+        return 0;
+    }
+    // Provider-specific helpers
+    getProviderSpecificFeatures() {
+        return {
+            supportsBatching: true,
+            supportsDeadLetterQueue: false,
+            supportsOrdering: true,
+            supportsTrimming: true,
+            supportsRetry: true,
+            supportsNotifications: false,
+            maxMessageSize: 512 * 1024 * 1024,
+            maxBatchSize: 1000,
+        };
+    }
+}
+exports.IORedisStreamService = IORedisStreamService;

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

@@ -53,6 +53,7 @@ declare class RedisStreamService extends StreamService<RedisRedisClientType, Red
         supportsOrdering: boolean;
         supportsTrimming: boolean;
         supportsRetry: boolean;
+        supportsNotifications: boolean;
         maxMessageSize: number;
         maxBatchSize: number;
     };

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

@@ -1 +1,305 @@
-'use strict';const r=b;(function(c,d){const q=b,e=c();while(!![]){try{const f=-parseInt(q(0x1c3))/0x1+parseInt(q(0x1c6))/0x2+parseInt(q(0x1d6))/0x3+-parseInt(q(0x1f2))/0x4*(parseInt(q(0x212))/0x5)+-parseInt(q(0x1c1))/0x6+parseInt(q(0x1cf))/0x7*(parseInt(q(0x20f))/0x8)+parseInt(q(0x203))/0x9;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x45858));function b(c,d){const e=a();return b=function(f,g){f=f-0x1bf;let h=e[f];return h;},b(c,d);}Object[r(0x205)](exports,'__esModule',{'value':!0x0}),exports[r(0x1ed)]=void 0x0;const index_1=require(r(0x1da)),utils_1=require(r(0x1fd)),key_1=require(r(0x1f0)),enums_1=require(r(0x1d7));class RedisStreamService extends index_1['StreamService']{constructor(c,d,f={}){super(c,d,f);}async['init'](c,d,f){const s=r;this[s(0x1e8)]=c,this[s(0x1f8)]=f,this['appId']=d;}[r(0x1c4)](c,d){const t=r;if(!this[t(0x1e8)])throw new Error(t(0x1ee));return key_1[t(0x1fa)]['mintKey'](this[t(0x1e8)],c,{...d,'appId':this[t(0x1c9)]});}[r(0x201)](){const u=r;return this[u(0x1f3)][u(0x1c5)]();}async[r(0x1c2)](c){const v=r;try{const d=await this[v(0x1f3)][v(0x1cd)](c,'*',{'field':'value'});return await this[v(0x1f3)][v(0x1db)](c,d),!0x0;}catch(f){throw this[v(0x1f8)]['error'](v(0x1cc)+c,{'error':f}),f;}}async[r(0x211)](c){const w=r;try{return await this['streamClient']['DEL'](c)>0x0;}catch(d){throw this[w(0x1f8)][w(0x1d3)](w(0x1d8)+c,{'error':d}),d;}}async[r(0x20e)](c,d){const x=r;try{return'OK'===await this[x(0x208)][x(0x1df)](['XGROUP',x(0x1eb),c,d,'$',x(0x1f6)]);}catch(f){const g=x(0x1ef);throw this[x(0x1f8)][x(0x1d4)](x(0x1dc)+g+x(0x1e9)+c+x(0x1e0)+d,{'error':f}),f;}}async['deleteConsumerGroup'](c,d){const y=r;try{return await this['streamClient']['xGroupDestroy'](c,d);}catch(f){throw this[y(0x1f8)][y(0x1d3)](y(0x1e1)+d+y(0x1fb)+c,{'error':f}),f;}}async[r(0x1d2)](c,d,f){const z=r;try{const g=f?.['transaction']||d[z(0x1e2)]>0x1&&this[z(0x208)][z(0x1c5)]();let h;for(const i of d)h=await(g||this[z(0x208)])[z(0x1cd)](c,'*',{'message':i});return g&&!f?.[z(0x20a)]?(await g['exec']())[z(0x1e5)](j=>j[0x1]):[h];}catch(j){throw this[z(0x1f8)][z(0x1d3)](z(0x1f7)+c,{'error':j}),j;}}async[r(0x1d1)](c,d,f,g){const A=r;try{const h=await this[A(0x1f3)][A(0x1df)]([A(0x1ea),'GROUP',d,f,A(0x1c0),g?.[A(0x1d9)]?.[A(0x20d)]()??enums_1['HMSH_BLOCK_TIME_MS'][A(0x20d)](),A(0x1d0),c,'>']),j=[];if(!(0x0,utils_1['isStreamMessage'])(h))return[];{const [[,k]]=h;for(const [l,m]of k)j['push']({'id':l,'data':(0x0,utils_1[A(0x1ec)])(m[0x1])});}return j;}catch(n){throw this[A(0x1f8)][A(0x1d3)](A(0x210)+c,{'error':n}),n;}}async[r(0x1f5)](c,d,f){const B=r,g=this['storeClient']['multi']();return await this['acknowledgeMessages'](c,d,f,{'multi':g}),await this[B(0x20b)](c,d,f,{'multi':g}),await g[B(0x1dd)](),f[B(0x1e2)];}async[r(0x1e4)](c,d,f,g){const C=r;try{return g?.['multi']?(g[C(0x1c5)][C(0x1de)](c,d,f),g[C(0x1c5)]):await this[C(0x1f3)][C(0x1de)](c,d,...f);}catch(h){throw this[C(0x1f8)][C(0x1d3)]('Error\x20in\x20acknowledging\x20messages\x20in\x20group:\x20'+d+'\x20for\x20key:\x20'+c,{'error':h}),h;}}async[r(0x20b)](c,d,f,g){const D=r;try{return g?.[D(0x1c5)]?(g[D(0x1c5)]['xDel'](c,f),g[D(0x1c5)]):await this['streamClient'][D(0x1db)](c,...f);}catch(h){throw this[D(0x1f8)][D(0x1d3)]('Error\x20in\x20deleting\x20messages\x20with\x20ids:\x20'+f['join'](',')+'\x20for\x20key:\x20'+c,{'error':h}),h;}}async[r(0x209)](c,d,f,g){const E=r;try{const h='-',j='+',k=[c,d];h&&k['push'](h),j&&k[E(0x1fe)](j),void 0x0!==f&&k[E(0x1fe)](f[E(0x20d)]()),g&&k[E(0x1fe)](g);try{return await this['streamClient'][E(0x1df)]([E(0x1e7),...k]);}catch(l){this['logger'][E(0x1d3)](E(0x1fc),{'error':l},k);}}catch(m){throw this[E(0x1f8)][E(0x1d3)](E(0x202)+d+'\x20in\x20key:\x20'+c,{'error':m}),m;}}async['retryMessages'](c,d,f){const F=r;let g=[];const h=await this[F(0x209)](c,d,f?.[F(0x200)]);for(const j of h)if(Array[F(0x1cb)](j)){const [k,,l,m]=j;if(l>f?.[F(0x1ff)]){const p=await this[F(0x1f9)](c,d,f?.['consumerName'],f?.[F(0x1ff)],k);g=g[F(0x213)](p);}}return g;}async['claimMessage'](c,d,f,g,h,...j){const G=r;try{const k=await this[G(0x1f3)][G(0x1df)]([G(0x204),c,d,f,g[G(0x20d)](),h,...j]);return{'id':k[0x0][0x0],'data':(0x0,utils_1[G(0x1ec)])(k[0x0][0x1][0x1])};}catch(l){throw this[G(0x1f8)][G(0x1d3)](G(0x1ce)+h+'\x20in\x20group:\x20'+d+G(0x1e9)+c,{'error':l}),l;}}async[r(0x1f4)](c){const H=r;return{'messageCount':await this[H(0x1bf)](c)};}async[r(0x1bf)](c,d){const I=r;try{if(d?.['multi'])return d[I(0x1c5)]['XLEN'](c),0x0;return await this[I(0x1f3)][I(0x1e6)](c);}catch(f){throw this[I(0x1f8)][I(0x1d3)](I(0x1d5)+c,{'error':f}),f;}}async[r(0x1c8)](c){const J=r,d=this['storeClient'][J(0x1c5)](),f=new Map();c[J(0x206)](h=>{const K=J;f[K(0x1e3)](h['stream'])||(f[K(0x1c7)](h[K(0x1ca)],-0x1),this[K(0x1bf)](h[K(0x1ca)],{'multi':d}));});const g=await d[J(0x1dd)]();return Array['from'](f[J(0x1f1)]())[J(0x206)]((h,i)=>{f['set'](h,g[i]);}),c[J(0x1e5)](h=>({'stream':h[J(0x1ca)],'depth':f['get'](h[J(0x1ca)])||0x0}));}async[r(0x20c)](c,d){return 0x0;}[r(0x207)](){return{'supportsBatching':!0x0,'supportsDeadLetterQueue':!0x1,'supportsOrdering':!0x0,'supportsTrimming':!0x0,'supportsRetry':!0x0,'maxMessageSize':0x20000000,'maxBatchSize':0x3e8};}}exports[r(0x1ed)]=RedisStreamService;function a(){const L=['Error\x20creating\x20stream\x20','XADD','Error\x20in\x20claiming\x20message\x20with\x20id:\x20','3767267bTlnBu','STREAMS','consumeMessages','publishMessages','error','debug','Error\x20getting\x20depth\x20for\x20','737049acOUxf','../../../../modules/enums','Error\x20deleting\x20stream\x20','blockTimeout','../../index','XDEL','x-group-error\x20','exec','XACK','sendCommand','\x20and\x20group:\x20','Error\x20deleting\x20consumer\x20group\x20','length','has','acknowledgeMessages','map','XLEN','XPENDING','namespace','\x20for\x20key:\x20','XREADGROUP','CREATE','parseStreamMessage','RedisStreamService','namespace\x20not\x20set','with\x20MKSTREAM','../../../../modules/key','keys','1972FzpBfP','streamClient','getStreamStats','ackAndDelete','MKSTREAM','ioredis-xadd-error\x20key:\x20','logger','claimMessage','KeyService','\x20for\x20stream\x20','error,\x20args','../../../../modules/utils','push','minIdleTime','limit','transact','Error\x20retrieving\x20pending\x20messages\x20for\x20group:\x20','3489453ObZLCa','XCLAIM','defineProperty','forEach','getProviderSpecificFeatures','storeClient','getPendingMessages','transaction','deleteMessages','trimStream','toString','createConsumerGroup','8LNpTeX','Error\x20consuming\x20messages\x20from\x20','deleteStream','3695JuFkLn','concat','getStreamDepth','BLOCK','2414340YMDndn','createStream','200178fiJhHD','mintKey','multi','160148YMmTCf','set','getStreamDepths','appId','stream','isArray'];a=function(){return L;};return a();}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamService = void 0;
+const index_1 = require("../../index");
+const utils_1 = require("../../../../modules/utils");
+const key_1 = require("../../../../modules/key");
+const enums_1 = require("../../../../modules/enums");
+class RedisStreamService extends index_1.StreamService {
+    constructor(streamClient, storeClient, config = {}) {
+        super(streamClient, storeClient, config);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    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 this.streamClient.multi();
+    }
+    // Core streaming operations
+    async createStream(streamName) {
+        try {
+            // streams are created when you add messages.
+            // To create an empty stream, we can add and delete a dummy message.
+            const dummyId = await this.streamClient.XADD(streamName, '*', {
+                field: 'value',
+            });
+            await this.streamClient.XDEL(streamName, dummyId);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Error creating stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async deleteStream(streamName) {
+        try {
+            const result = await this.streamClient.DEL(streamName);
+            return result > 0;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    // Consumer group operations
+    async createConsumerGroup(streamName, groupName) {
+        try {
+            const result = (await this.storeClient.sendCommand([
+                'XGROUP',
+                'CREATE',
+                streamName,
+                groupName,
+                '$',
+                'MKSTREAM',
+            ]));
+            return result === 'OK';
+        }
+        catch (error) {
+            const streamType = 'with MKSTREAM';
+            this.logger.debug(`x-group-error ${streamType} for key: ${streamName} and group: ${groupName}`, { error });
+            throw error;
+        }
+    }
+    async deleteConsumerGroup(streamName, groupName) {
+        try {
+            const result = await this.streamClient.xGroupDestroy(streamName, groupName);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting consumer group ${groupName} for stream ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async publishMessages(streamName, messages, options) {
+        try {
+            const multi = options?.transaction ||
+                (messages.length > 1 && this.storeClient.multi());
+            let response;
+            for (const message of messages) {
+                response = await (multi || this.storeClient).XADD(streamName, '*', {
+                    message: message,
+                });
+            }
+            if (multi && !options?.transaction) {
+                //only exec if we created the multi;
+                //otherwise caller is responsible
+                return (await multi.exec()).map((result) => result[1]);
+            }
+            else {
+                return [response];
+            }
+        }
+        catch (error) {
+            this.logger.error(`ioredis-xadd-error key: ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async consumeMessages(streamName, groupName, consumerName, options) {
+        const command = 'GROUP';
+        const blockOption = 'BLOCK';
+        const streamsOption = 'STREAMS';
+        const id = '>';
+        try {
+            const result = await this.streamClient.sendCommand([
+                'XREADGROUP',
+                command,
+                groupName,
+                consumerName,
+                blockOption,
+                options?.blockTimeout?.toString() ?? enums_1.HMSH_BLOCK_TIME_MS.toString(),
+                streamsOption,
+                streamName,
+                id,
+            ]);
+            const response = [];
+            if ((0, utils_1.isStreamMessage)(result)) {
+                const [[, messages]] = result;
+                for (const [id, message] of messages) {
+                    response.push({
+                        id,
+                        data: (0, utils_1.parseStreamMessage)(message[1]),
+                    });
+                }
+            }
+            else {
+                return [];
+            }
+            return response;
+        }
+        catch (error) {
+            this.logger.error(`Error consuming messages from ${streamName}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async ackAndDelete(stream, group, ids) {
+        const multi = this.storeClient.multi();
+        await this.acknowledgeMessages(stream, group, ids, { multi });
+        await this.deleteMessages(stream, group, ids, { multi });
+        await multi.exec();
+        return ids.length;
+    }
+    async acknowledgeMessages(stream, group, ids, options) {
+        try {
+            if (options?.multi) {
+                options.multi.XACK(stream, group, ids);
+                return options.multi;
+            }
+            else {
+                return await this.streamClient.XACK(stream, group, ...ids);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${stream}`, { error });
+            throw error;
+        }
+    }
+    async deleteMessages(stream, group, ids, options) {
+        try {
+            if (options?.multi) {
+                options.multi.xDel(stream, ids);
+                return options.multi;
+            }
+            else {
+                return await this.streamClient.XDEL(stream, ...ids);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Error in deleting messages with ids: ${ids.join(',')} for key: ${stream}`, { error });
+            throw error;
+        }
+    }
+    async getPendingMessages(stream, group, count, consumer) {
+        try {
+            const start = '-';
+            const end = '+';
+            const args = [stream, 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.streamClient.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: ${stream}`, { error });
+            throw error;
+        }
+    }
+    // Retry Method
+    async retryMessages(streamName, groupName, options) {
+        let pendingMessages = [];
+        const pendingMessagesInfo = await this.getPendingMessages(streamName, groupName, options?.limit); //[[ '1688768134881-0', 'testConsumer1', 1017, 1 ]]
+        for (const pendingMessageInfo of pendingMessagesInfo) {
+            if (Array.isArray(pendingMessageInfo)) {
+                const [id, , elapsedTimeMs, deliveryCount] = pendingMessageInfo;
+                if (elapsedTimeMs > options?.minIdleTime) {
+                    const reclaimedMessage = await this.claimMessage(streamName, groupName, options?.consumerName, options?.minIdleTime, id);
+                    pendingMessages = pendingMessages.concat(reclaimedMessage);
+                }
+            }
+        }
+        return pendingMessages;
+    }
+    async claimMessage(stream, group, consumer, minIdleTime, id, ...args) {
+        try {
+            const message = (await this.streamClient.sendCommand([
+                'XCLAIM',
+                stream,
+                group,
+                consumer,
+                minIdleTime.toString(),
+                id,
+                ...args,
+            ]));
+            return {
+                id: message[0][0],
+                data: (0, utils_1.parseStreamMessage)(message[0][1][1]),
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${stream}`, { error });
+            throw error;
+        }
+    }
+    async getStreamStats(streamName) {
+        return {
+            messageCount: await this.getStreamDepth(streamName),
+        };
+    }
+    async getStreamDepth(streamName, options) {
+        try {
+            if (options?.multi) {
+                options.multi.XLEN(streamName);
+                return 0;
+            }
+            const length = await this.streamClient.XLEN(streamName);
+            return length;
+        }
+        catch (error) {
+            this.logger.error(`Error getting depth for ${streamName}`, { error });
+            throw error;
+        }
+    }
+    async getStreamDepths(streamNames) {
+        const multi = this.storeClient.multi();
+        const uniqueStreams = new Map(); // Use a Map to track unique streams
+        // Add unique streams to the multi command
+        streamNames.forEach((profile) => {
+            if (!uniqueStreams.has(profile.stream)) {
+                uniqueStreams.set(profile.stream, -1); // Initialize depth to -1 as a placeholder
+                this.getStreamDepth(profile.stream, { multi: multi });
+            }
+        });
+        // Execute all commands in multi (ioredis strips null fields)
+        const streamDepthResults = (await multi.exec());
+        // Update the uniqueStreams map with actual depths from multi.exec() results
+        Array.from(uniqueStreams.keys()).forEach((stream, idx) => {
+            uniqueStreams.set(stream, streamDepthResults[idx]);
+        });
+        // Map back to the original `streamNames` array with correct depths
+        return streamNames.map((profile) => {
+            return {
+                stream: profile.stream,
+                depth: uniqueStreams.get(profile.stream) || 0,
+            };
+        });
+    }
+    async trimStream(streamName, options) {
+        //no-op for now
+        return 0;
+    }
+    // Provider-specific helpers
+    getProviderSpecificFeatures() {
+        return {
+            supportsBatching: true,
+            supportsDeadLetterQueue: false,
+            supportsOrdering: true,
+            supportsTrimming: true,
+            supportsRetry: true,
+            supportsNotifications: false,
+            maxMessageSize: 512 * 1024 * 1024,
+            maxBatchSize: 1000,
+        };
+    }
+}
+exports.RedisStreamService = RedisStreamService;

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

@@ -1 +1,2 @@
-'use strict';var i=b;function a(){var j=['10VsgUWx','1dcwDeL','30AmNJEy','1874758WCkLGs','2011540jVKPpC','2393811bPEUJv','6845289pcjoyX','5141969WizEjS','1056126rHxjHZ','defineProperty','12798864CUnNPC','6ixQSFp','__esModule'];a=function(){return j;};return a();}(function(c,d){var h=b,e=c();while(!![]){try{var f=-parseInt(h(0x16b))/0x1*(-parseInt(h(0x16d))/0x2)+parseInt(h(0x172))/0x3+-parseInt(h(0x16e))/0x4*(parseInt(h(0x16a))/0x5)+-parseInt(h(0x168))/0x6*(-parseInt(h(0x171))/0x7)+-parseInt(h(0x167))/0x8+-parseInt(h(0x16f))/0x9*(-parseInt(h(0x16c))/0xa)+parseInt(h(0x170))/0xb;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xccbc4));function b(c,d){var e=a();return b=function(f,g){f=f-0x167;var h=e[f];return h;},b(c,d);}Object[i(0x173)](exports,i(0x169),{'value':!0x0});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });