@hotmeshio/hotmesh 0.3.32 → 0.4.1

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

@@ -1 +1,105 @@
-'use strict';function a(){const A=['logger','init','punsubscribe','nats-psubscribe\x20','794hoHVYe','namespace\x20not\x20set','parse','nats-punsubscribe\x20','../../index','__esModule','371106rJUDOV','1109409xdEbYG','catch','245KPsYxo','nats-publish-error\x20','KeyService','nats-unsubscribe-error\x20','63708FPhytW','nats-publish\x20','replace','subscribe','30mIbOVM','error','psubscribe','publish','mintKey','1019684FGDQPo','nats-subscribe-error\x20','warn','nats-subscribe\x20','subject','toString','NatsSubService','unsubscribe','namespace','1957043HODryi','debug','transact','data','2223WgeMPX','nats-unsubscribe\x20','nats-parse-psubscription-message-error\x20','80akbmWx','nats-pattern-psubscription-error\x20','set','SubService','subscriptions','109368hGpSAi','delete','appId','nats-punsubscribe-error\x20'];a=function(){return A;};return a();}const o=b;(function(c,d){const n=b,e=c();while(!![]){try{const f=parseInt(n(0x1f2))/0x1+-parseInt(n(0x1fa))/0x2*(-parseInt(n(0x1ea))/0x3)+-parseInt(n(0x210))/0x4+parseInt(n(0x203))/0x5*(parseInt(n(0x207))/0x6)+-parseInt(n(0x201))/0x7+parseInt(n(0x1ed))/0x8*(parseInt(n(0x200))/0x9)+-parseInt(n(0x20b))/0xa*(parseInt(n(0x1e6))/0xb);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x5ef9c));function b(c,d){const e=a();return b=function(f,g){f=f-0x1e4;let h=e[f];return h;},b(c,d);}Object['defineProperty'](exports,o(0x1ff),{'value':!0x0}),exports['NatsSubService']=void 0x0;const key_1=require('../../../../modules/key'),index_1=require(o(0x1fe));class NatsSubService extends index_1[o(0x1f0)]{constructor(c,d){super(c,d),this['subscriptions']=new Map();}async[o(0x1f7)](c=key_1['HMNS'],d,f,g){const p=o;this['namespace']=c,this[p(0x1f6)]=g,this[p(0x1f4)]=d,this['engineId']=f;}[o(0x1e8)](){return{};}[o(0x20f)](c,d){const q=o;if(!this[q(0x1e5)])throw new Error(q(0x1fb));return key_1[q(0x205)][q(0x20f)](this[q(0x1e5)],c,d)['replace'](/:/g,'.')[q(0x209)](/\.$/g,'.X');}async['subscribe'](c,d,f,g){const r=o,h=this[r(0x20f)](c,{'appId':f,'engineId':g}),j=this['eventClient'][r(0x20a)](h);this[r(0x1f1)][r(0x1ef)](h,j),this[r(0x1f6)]['debug'](r(0x213)+h),(async()=>{const s=r;for await(const k of j)try{const l=JSON[s(0x1fc)](k['data'][s(0x215)]());d(h,l);}catch(m){this[s(0x1f6)][s(0x20c)]('nats-subscribe-message-parse-error:\x20'+k['data'][s(0x215)](),m);}})()[r(0x202)](k=>{const t=r;this[t(0x1f6)][t(0x20c)](t(0x211)+h,k);});}async[o(0x1e4)](c,d,f){const u=o,g=this[u(0x20f)](c,{'appId':d,'engineId':f}),h=this['subscriptions']['get'](g);h?(h[u(0x1e4)](),this[u(0x1f1)][u(0x1f3)](g),this['logger'][u(0x1e7)](u(0x1eb)+g)):this[u(0x1f6)][u(0x212)](u(0x206)+g);}async[o(0x20d)](c,d,f,g){const v=o,h=this[v(0x20f)](c,{'appId':f,'engineId':g}),j=this['eventClient'][v(0x20a)](h);this[v(0x1f1)]['set'](h,j),this[v(0x1f6)][v(0x1e7)](v(0x1f9)+h),(async()=>{const w=v;for await(const k of j)try{const l=JSON[w(0x1fc)](k[w(0x1e9)][w(0x215)]());d(k[w(0x214)],l);}catch(m){this[w(0x1f6)][w(0x20c)](w(0x1ec)+k[w(0x1e9)][w(0x215)](),m);}})()[v(0x202)](k=>{const x=v;this[x(0x1f6)][x(0x20c)](x(0x1ee)+h,k);});}async[o(0x1f8)](c,d,f){const y=o,g=this[y(0x20f)](c,{'appId':d,'engineId':f}),h=this[y(0x1f1)]['get'](g);h?(h[y(0x1e4)](),this[y(0x1f1)]['delete'](g),this[y(0x1f6)]['debug'](y(0x1fd)+g)):this[y(0x1f6)][y(0x212)](y(0x1f5)+g);}async[o(0x20e)](c,d,f,g){const z=o,h=this[z(0x20f)](c,{'appId':f,'engineId':g});try{return this['storeClient']['publish'](h,JSON['stringify'](d)),this[z(0x1f6)][z(0x1e7)](z(0x208)+h),!0x0;}catch(j){return this['logger'][z(0x20c)](z(0x204)+h,j),!0x1;}}}exports[o(0x216)]=NatsSubService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsSubService = void 0;
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class NatsSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+        this.subscriptions = new Map();
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        // NATS does not support transactions like Redis.
+        // Return an empty object or throw an error if not supported.
+        return {};
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params)
+            .replace(/:/g, '.')
+            .replace(/\.$/g, '.X');
+    }
+    async subscribe(keyType, callback, appId, topic) {
+        const subject = this.mintKey(keyType, { appId, engineId: topic });
+        const subscription = this.eventClient.subscribe(subject);
+        this.subscriptions.set(subject, subscription);
+        this.logger.debug(`nats-subscribe ${subject}`);
+        (async () => {
+            for await (const msg of subscription) {
+                try {
+                    const payload = JSON.parse(msg.data.toString());
+                    callback(subject, payload);
+                }
+                catch (e) {
+                    this.logger.error(`nats-subscribe-message-parse-error: ${msg.data.toString()}`, e);
+                }
+            }
+        })().catch((err) => {
+            this.logger.error(`nats-subscribe-error ${subject}`, err);
+        });
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const subject = this.mintKey(keyType, { appId, engineId });
+        const subscription = this.subscriptions.get(subject);
+        if (subscription) {
+            subscription.unsubscribe();
+            this.subscriptions.delete(subject);
+            this.logger.debug(`nats-unsubscribe ${subject}`);
+        }
+        else {
+            this.logger.warn(`nats-unsubscribe-error ${subject}`);
+        }
+    }
+    async psubscribe(keyType, callback, appId, topic) {
+        const subject = this.mintKey(keyType, { appId, engineId: topic });
+        const subscription = this.eventClient.subscribe(subject);
+        this.subscriptions.set(subject, subscription);
+        this.logger.debug(`nats-psubscribe ${subject}`);
+        (async () => {
+            for await (const msg of subscription) {
+                try {
+                    const payload = JSON.parse(msg.data.toString());
+                    callback(msg.subject, payload);
+                }
+                catch (e) {
+                    this.logger.error(`nats-parse-psubscription-message-error ${msg.data.toString()}`, e);
+                }
+            }
+        })().catch((err) => {
+            this.logger.error(`nats-pattern-psubscription-error ${subject}`, err);
+        });
+    }
+    async punsubscribe(keyType, appId, topic) {
+        const subject = this.mintKey(keyType, { appId, engineId: topic });
+        const subscription = this.subscriptions.get(subject);
+        if (subscription) {
+            subscription.unsubscribe();
+            this.subscriptions.delete(subject);
+            this.logger.debug(`nats-punsubscribe ${subject}`);
+        }
+        else {
+            this.logger.warn(`nats-punsubscribe-error ${subject}`);
+        }
+    }
+    async publish(keyType, message, appId, topic) {
+        const subject = this.mintKey(keyType, { appId, engineId: topic });
+        try {
+            // Use the storeClient for publishing if necessary
+            this.storeClient.publish(subject, JSON.stringify(message));
+            this.logger.debug(`nats-publish ${subject}`);
+            return true;
+        }
+        catch (err) {
+            this.logger.error(`nats-publish-error ${subject}`, err);
+            return false;
+        }
+    }
+}
+exports.NatsSubService = NatsSubService;

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

@@ -1 +1,92 @@
-'use strict';const o=b;(function(c,d){const n=b,e=c();while(!![]){try{const f=parseInt(n(0xca))/0x1*(-parseInt(n(0xcb))/0x2)+-parseInt(n(0xd2))/0x3*(parseInt(n(0xc3))/0x4)+-parseInt(n(0xee))/0x5*(-parseInt(n(0xc9))/0x6)+parseInt(n(0xea))/0x7+parseInt(n(0xd3))/0x8*(parseInt(n(0xbe))/0x9)+-parseInt(n(0xe7))/0xa+-parseInt(n(0xdf))/0xb;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x9a395));var __importDefault=this&&this[o(0xd0)]||function(c){return c&&c['__esModule']?c:{'default':c};};function b(c,d){const e=a();return b=function(f,g){f=f-0xbb;let h=e[f];return h;},b(c,d);}Object[o(0xcd)](exports,o(0xbd),{'value':!0x0}),exports[o(0xeb)]=void 0x0;const crypto_1=__importDefault(require(o(0xe9))),key_1=require(o(0xdb)),index_1=require('../../index');class PostgresSubService extends index_1['SubService']{constructor(c,d){super(c,d);}async[o(0xd1)](c=key_1[o(0xc8)],d,f,g){const p=o;this['namespace']=c,this[p(0xbc)]=g,this[p(0xbf)]=d,this['engineId']=f;}['transact'](){const q=o;throw new Error(q(0xcc));}[o(0xc0)](c,d){const r=o;if(!this[r(0xde)])throw new Error(r(0xc4));return key_1[r(0xe8)][r(0xc0)](this['namespace'],c,d);}['mintSafeKey'](c,d){const s=o,f=this['mintKey'](c,d);if(f[s(0xd8)]<=0x3f)return[f,f];const {appId:g='',engineId:h=''}=d,j=this[s(0xde)]+':'+g+':'+c,k=0x3f-j[s(0xd8)]-0x1;return[f,j+':'+crypto_1['default'][s(0xdc)](s(0xd4))['update'](h)[s(0xcf)]('hex')[s(0xe1)](0x0,k)];}async[o(0xc1)](c,d,f,g){const t=o,[h,j]=this['mintSafeKey'](c,{'appId':f,'engineId':g});await this[t(0xdd)][t(0xd9)](t(0xe0)+j+'\x22'),this[t(0xbc)][t(0xe5)](t(0xce),{'originalKey':h,'safeKey':j}),this['eventClient']['on'](t(0xec),k=>{const u=t;if(k['channel']===j)try{const l=JSON[u(0xd5)](k[u(0xd7)]||'{}');d(j,l);}catch(m){this[u(0xbc)][u(0xda)]('Error\x20parsing\x20message\x20for\x20topic\x20'+j+':',m);}});}async[o(0xe4)](c,d,f){const v=o,[g,h]=this[v(0xe3)](c,{'appId':d,'engineId':f});await this['eventClient'][v(0xd9)]('UNLISTEN\x20\x22'+h+'\x22'),this[v(0xbc)][v(0xe5)](v(0xce),{'originalKey':g,'safeKey':h});}async[o(0xc2)](c,d,f,g){const w=o,[h,j]=this['mintSafeKey'](c,{'appId':f,'engineId':g}),k=JSON[w(0xed)](d)[w(0xc5)](/'/g,'\x27\x27');return await this[w(0xe2)][w(0xd9)](w(0xc6)+j+'\x22,\x20\x27'+k+'\x27'),this['logger']['debug'](w(0xe6),{'originalKey':h,'safeKey':j}),!0x0;}async[o(0xd6)](){const x=o;throw new Error(x(0xc7));}async[o(0xbb)](){const y=o;throw new Error(y(0xc7));}}function a(){const z=['KeyService','crypto','8510922iAMlOn','PostgresSubService','notification','stringify','335JlFYbh','punsubscribe','logger','__esModule','193149XLHCOY','appId','mintKey','subscribe','publish','44ANZnJM','Namespace\x20not\x20set','replace','NOTIFY\x20\x22','Pattern\x20subscriptions\x20are\x20not\x20supported\x20in\x20PostgreSQL','HMNS','101982ZXmyzZ','27407YTogfw','58AjsjZf','Transactions\x20are\x20not\x20supported\x20in\x20lightweight\x20pub/sub','defineProperty','postgres-subscribe','digest','__importDefault','init','145833yZJtzH','344HXSSIh','sha256','parse','psubscribe','payload','length','query','error','../../../../modules/key','createHash','eventClient','namespace','4946128AhHzIe','LISTEN\x20\x22','substring','storeClient','mintSafeKey','unsubscribe','debug','postgres-publish','8665950QqXKKD'];a=function(){return z;};return a();}exports['PostgresSubService']=PostgresSubService;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresSubService = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class PostgresSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        throw new Error('Transactions are not supported in lightweight pub/sub');
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('Namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    mintSafeKey(type, params) {
+        const originalKey = this.mintKey(type, params);
+        if (originalKey.length <= 63) {
+            return [originalKey, originalKey];
+        }
+        const { appId = '', engineId = '' } = params;
+        const baseKey = `${this.namespace}:${appId}:${type}`;
+        const maxHashLength = 63 - baseKey.length - 1; // Reserve space for `:` delimiter
+        const engineIdHash = crypto_1.default
+            .createHash('sha256')
+            .update(engineId)
+            .digest('hex')
+            .substring(0, maxHashLength);
+        const safeKey = `${baseKey}:${engineIdHash}`;
+        return [originalKey, safeKey];
+    }
+    async subscribe(keyType, callback, appId, topic) {
+        const [originalKey, safeKey] = this.mintSafeKey(keyType, {
+            appId,
+            engineId: topic,
+        });
+        // Start listening to the safe topic
+        await this.eventClient.query(`LISTEN "${safeKey}"`);
+        this.logger.debug(`postgres-subscribe`, { originalKey, safeKey });
+        // Set up the notification handler
+        this.eventClient.on('notification', (msg) => {
+            if (msg.channel === safeKey) {
+                try {
+                    const payload = JSON.parse(msg.payload || '{}');
+                    callback(safeKey, payload);
+                }
+                catch (err) {
+                    this.logger.error(`Error parsing message for topic ${safeKey}:`, err);
+                }
+            }
+        });
+    }
+    async unsubscribe(keyType, appId, topic) {
+        const [originalKey, safeKey] = this.mintSafeKey(keyType, {
+            appId,
+            engineId: topic,
+        });
+        // Stop listening to the safe topic
+        await this.eventClient.query(`UNLISTEN "${safeKey}"`);
+        this.logger.debug(`postgres-subscribe`, { originalKey, safeKey });
+    }
+    async publish(keyType, message, appId, topic) {
+        const [originalKey, safeKey] = this.mintSafeKey(keyType, {
+            appId,
+            engineId: topic,
+        });
+        // Publish the message using the safe topic
+        const payload = JSON.stringify(message).replace(/'/g, "''");
+        await this.storeClient.query(`NOTIFY "${safeKey}", '${payload}'`);
+        this.logger.debug(`postgres-publish`, { originalKey, safeKey });
+        return true;
+    }
+    async psubscribe() {
+        throw new Error('Pattern subscriptions are not supported in PostgreSQL');
+    }
+    async punsubscribe() {
+        throw new Error('Pattern subscriptions are not supported in PostgreSQL');
+    }
+}
+exports.PostgresSubService = PostgresSubService;

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

@@ -1 +1,81 @@
-'use strict';const r=b;(function(c,d){const q=b,e=c();while(!![]){try{const f=-parseInt(q(0x19a))/0x1+parseInt(q(0x182))/0x2+parseInt(q(0x18b))/0x3*(-parseInt(q(0x17c))/0x4)+parseInt(q(0x19b))/0x5+-parseInt(q(0x192))/0x6+parseInt(q(0x181))/0x7+-parseInt(q(0x188))/0x8;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x81f61));Object[r(0x19c)](exports,'__esModule',{'value':!0x0}),exports['IORedisSubService']=void 0x0;function b(c,d){const e=a();return b=function(f,g){f=f-0x17c;let h=e[f];return h;},b(c,d);}const key_1=require('../../../../modules/key'),index_1=require(r(0x196));function a(){const E=['publish','appId','894732VlLoPI','transact','parse','Error\x20subscribing\x20to:\x20','psubscribe','3664598TfCKAJ','1648488DuFKhs','subscribe','init','Error\x20parsing\x20message:\x20','SubService','namespace','3685248KdwMHI','punsubscribe','storeClient','3uqzljA','KeyService','eventClient','namespace\x20not\x20set','error','pmessage','unsubscribe','1899498hrzhIt','mintKey','message','multi','../../index','logger','IORedisSubService','stringify','20918LRjGfl','1032015PvbqVh','defineProperty'];a=function(){return E;};return a();}class IORedisSubService extends index_1[r(0x186)]{constructor(c,d){super(c,d);}async[r(0x184)](c=key_1['HMNS'],d,f,g){const s=r;this['namespace']=c,this[s(0x197)]=g,this[s(0x19e)]=d,this['engineId']=f;}[r(0x17d)](){const t=r;return this['eventClient'][t(0x195)]();}[r(0x193)](c,d){const u=r;if(!this['namespace'])throw new Error(u(0x18e));return key_1[u(0x18c)][u(0x193)](this[u(0x187)],c,d);}async[r(0x183)](c,d,f,g){const v=r,h=this,j=this[v(0x193)](c,{'appId':f,'engineId':g});await this[v(0x18d)][v(0x183)](j,k=>{const w=v;k&&h[w(0x197)][w(0x18f)](w(0x17f)+j,k);}),this[v(0x18d)]['on'](v(0x194),(k,l)=>{const x=v;if(k===j)try{const m=JSON[x(0x17e)](l);d(j,m);}catch(o){h[x(0x197)][x(0x18f)](x(0x185)+l,o);}});}async[r(0x191)](c,d,f){const y=r,g=this[y(0x193)](c,{'appId':d,'engineId':f});await this['eventClient'][y(0x191)](g);}async[r(0x180)](c,d,f,g){const z=r,h=this,j=this[z(0x193)](c,{'appId':f,'engineId':g});await this['eventClient'][z(0x180)](j,k=>{const A=z;k&&h[A(0x197)][A(0x18f)](A(0x17f)+j,k);}),this[z(0x18d)]['on'](z(0x190),(k,l,m)=>{const B=z;if(k===j)try{const o=JSON['parse'](m);d(l,o);}catch(p){h[B(0x197)][B(0x18f)]('Error\x20parsing\x20message:\x20'+m,p);}});}async[r(0x189)](c,d,f){const C=r,g=this[C(0x193)](c,{'appId':d,'engineId':f});await this[C(0x18d)]['punsubscribe'](g);}async[r(0x19d)](c,d,f,g){const D=r,h=this['mintKey'](c,{'appId':f,'engineId':g});return 0x1===await this[D(0x18a)]['publish'](h,JSON[D(0x199)](d));}}exports[r(0x198)]=IORedisSubService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSubService = void 0;
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class IORedisSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        return this.eventClient.multi();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        const self = this;
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.subscribe(topic, (err) => {
+            if (err) {
+                self.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+        this.eventClient.on('message', (channel, message) => {
+            if (channel === topic) {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(topic, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            }
+        });
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.unsubscribe(topic);
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        const self = this;
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.psubscribe(topic, (err) => {
+            if (err) {
+                self.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+        this.eventClient.on('pmessage', (pattern, channel, message) => {
+            if (pattern === topic) {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(channel, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            }
+        });
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.punsubscribe(topic);
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        //NOTE: `storeClient.publish` is used,
+        //      because a Redis connection with subscriptions
+        //      may not publish (is read only).
+        const status = await this.storeClient.publish(topic, JSON.stringify(message));
+        return status === 1;
+    }
+}
+exports.IORedisSubService = IORedisSubService;

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

@@ -1 +1,72 @@
-'use strict';const q=b;(function(c,d){const p=b,e=c();while(!![]){try{const f=parseInt(p(0x139))/0x1+-parseInt(p(0x149))/0x2*(parseInt(p(0x147))/0x3)+-parseInt(p(0x13b))/0x4*(-parseInt(p(0x148))/0x5)+-parseInt(p(0x12f))/0x6*(-parseInt(p(0x13c))/0x7)+parseInt(p(0x140))/0x8*(parseInt(p(0x143))/0x9)+parseInt(p(0x135))/0xa*(parseInt(p(0x13f))/0xb)+parseInt(p(0x131))/0xc*(-parseInt(p(0x141))/0xd);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xc0ea9));function a(){const B=['__esModule','pSubscribe','276947YrXzpE','24zZlHth','44291VMnCYT','HMNS','4148163JQnYrw','storeClient','KeyService','transact','129iUVrNB','5QgApFS','60062qsLKSO','engineId','../../../../modules/key','unsubscribe','multi','stringify','mintKey','publish','../../index','pUnsubscribe','init','5034360EkmvLd','RedisSubService','6276Aqeoyn','subscribe','eventClient','parse','20EUgSjj','error','namespace','logger','474607hBiMmF','punsubscribe','4466548UoAWnL','7EBJKzj'];a=function(){return B;};return a();}Object['defineProperty'](exports,q(0x13d),{'value':!0x0}),exports[q(0x130)]=void 0x0;const key_1=require(q(0x14b)),index_1=require(q(0x151));function b(c,d){const e=a();return b=function(f,g){f=f-0x12e;let h=e[f];return h;},b(c,d);}class RedisSubService extends index_1['SubService']{constructor(c,d){super(c,d);}async[q(0x12e)](c=key_1[q(0x142)],d,f,g){const r=q;this[r(0x137)]=c,this['logger']=g,this['appId']=d,this[r(0x14a)]=f;}[q(0x146)](){const s=q;return this['eventClient'][s(0x14d)]();}[q(0x14f)](c,d){const t=q;if(!this[t(0x137)])throw new Error('namespace\x20not\x20set');return key_1[t(0x145)][t(0x14f)](this[t(0x137)],c,d);}async['subscribe'](c,d,f,g){const u=q;if(this[u(0x133)]){const h=this,j=this[u(0x14f)](c,{'appId':f,'engineId':g});await this[u(0x133)][u(0x132)](j,k=>{const v=u;try{const l=JSON[v(0x134)](k);d(j,l);}catch(m){h[v(0x138)][v(0x136)]('Error\x20parsing\x20message:\x20'+k,m);}});}}async['unsubscribe'](c,d,f){const w=q,g=this['mintKey'](c,{'appId':d,'engineId':f});await this[w(0x133)][w(0x14c)](g);}async['psubscribe'](c,d,f,g){const x=q;if(this[x(0x133)]){const h=this,j=this[x(0x14f)](c,{'appId':f,'engineId':g});await this[x(0x133)][x(0x13e)](j,(k,l)=>{const y=x;try{const m=JSON['parse'](k);d(l,m);}catch(o){h['logger'][y(0x136)]('Error\x20parsing\x20message:\x20'+k,o);}});}}async[q(0x13a)](c,d,f){const z=q,g=this[z(0x14f)](c,{'appId':d,'engineId':f});await this[z(0x133)][z(0x152)](g);}async[q(0x150)](c,d,f,g){const A=q,h=this[A(0x14f)](c,{'appId':f,'engineId':g});return await this[A(0x144)][A(0x150)](h,JSON[A(0x14e)](d))>0x0;}}exports[q(0x130)]=RedisSubService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSubService = void 0;
+const key_1 = require("../../../../modules/key");
+const index_1 = require("../../index");
+class RedisSubService extends index_1.SubService {
+    constructor(eventClient, storeClient) {
+        super(eventClient, storeClient);
+    }
+    async init(namespace = key_1.HMNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+        this.engineId = engineId;
+    }
+    transact() {
+        const multi = this.eventClient.multi();
+        return multi;
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        if (this.eventClient) {
+            const self = this;
+            const topic = this.mintKey(keyType, { appId, engineId });
+            await this.eventClient.subscribe(topic, (message) => {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(topic, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+        }
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.unsubscribe(topic);
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        if (this.eventClient) {
+            const self = this;
+            const topic = this.mintKey(keyType, { appId, engineId });
+            await this.eventClient.pSubscribe(topic, (message, channel) => {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(channel, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+        }
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.eventClient.pUnsubscribe(topic);
+    }
+    async publish(keyType, message, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        //NOTE: `storeClient.publish` is used,
+        //      because a Redis connection with subscriptions
+        //      may not publish (is read only).
+        const status = await this.storeClient.publish(topic, JSON.stringify(message));
+        return status > 0;
+    }
+}
+exports.RedisSubService = RedisSubService;

package/build/services/task/index.js

@@ -1 +1,206 @@
-'use strict';const y=b;function a(){const M=[':processed','true','processTimeHooks','errorCount','284610zbHTiG','2eCyUsF','expireJob','split','registerWebHook','99928WalkYj','shouldScout','match','getHookSignal','now','appId','HMSH_FIDELITY_SECONDS','task-process-timehooks-error','../../modules/utils','store','KeyType','jid','reserveScoutRole','SIGNALS','deleteWebHookSignal','timerId','sleepFor','actual','HMSH_SCOUT_INTERVAL_SECONDS','promise','resolve','defineProperty','1795365TnLrPf','addTaskQueues','parse','4900CmjCXF','28kwqjEm','WEBSEP','signal-not-found','registerTimeHook','935832vQylHY','3NCjfbR','processWebHooks','TaskService','getNextTask','join','conditions','HMSH_EXPIRE_DURATION','deleteHookSignal','random','1733814wYpYPi','../../modules/key','getHookRules','../pipe','signaler.registerWebHook:error:\x20hook\x20rule\x20not\x20found','getActiveTaskQueue','child','XSleepFor','floor','metadata','getHookRule','isScout','25762iudotE','cleanupTimeout','mintKey','../../modules/enums','logger','delist','266263MFNkUX','cancelCleanup'];a=function(){return M;};return a();}(function(c,d){const x=b,e=c();while(!![]){try{const f=parseInt(x(0x11c))/0x1*(-parseInt(x(0xde))/0x2)+-parseInt(x(0x101))/0x3*(parseInt(x(0x100))/0x4)+-parseInt(x(0xdd))/0x5+-parseInt(x(0x10a))/0x6+parseInt(x(0xfc))/0x7*(parseInt(x(0xe2))/0x8)+-parseInt(x(0xf8))/0x9+-parseInt(x(0xfb))/0xa*(-parseInt(x(0x116))/0xb);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x2518b));Object[y(0xf7)](exports,'__esModule',{'value':!0x0}),exports[y(0x103)]=void 0x0;function b(c,d){const e=a();return b=function(f,g){f=f-0xdb;let h=e[f];return h;},b(c,d);}const enums_1=require(y(0x119)),utils_1=require(y(0xea)),pipe_1=require(y(0x10d)),hotmesh_1=require('../../types/hotmesh'),key_1=require(y(0x10b));class TaskService{constructor(c,d){const z=y;this['cleanupTimeout']=null,this[z(0x115)]=!0x1,this[z(0xdc)]=0x0,this['logger']=d,this[z(0xeb)]=c;}async[y(0x102)](c){const A=y,d=await this[A(0xeb)][A(0x10f)]();if(d){const [f,g,h,...j]=d[A(0xe0)](key_1['WEBSEP']),k=JSON[A(0xfa)](j[A(0x105)](key_1['WEBSEP'])),l=g+A(0x11e),m=await this['store']['processTaskQueue'](g,l);m?await c(f,{...k,'id':m}):await this[A(0xeb)]['deleteProcessedTaskQueue'](d,g,l,A(0x11f)===h),setImmediate(()=>this['processWebHooks'](c));}}async['enqueueWorkItems'](c){const B=y;await this['store'][B(0xf9)](c);}async['registerJobForCleanup'](c,d=enums_1[y(0x107)],f){const C=y;d>0x0&&await this[C(0xeb)][C(0xdf)](c,d);}async[y(0xff)](d,f,g,h,j=enums_1[y(0xe8)],k,l){const D=y,m=Date[D(0xe6)]()+0x3e8*j,p=0x3e8*enums_1[D(0xe8)],q=Math[D(0x112)](m/p)*p;await this['store']['registerTimeHook'](d,f,g,h,q,k,l);}async[y(0xe3)](){const E=y,c=this[E(0x115)];return!(!c&&!(this[E(0x115)]=await this[E(0xeb)][E(0xee)]('time')))&&(c||setTimeout(()=>{const F=E;this[F(0x115)]=!0x1;},0x3e8*enums_1[E(0xf4)]),!0x0);}async[y(0xdb)](c,d){const G=y;if(await this[G(0xe3)]())try{const f=await this[G(0xeb)][G(0x104)](d);if(Array['isArray'](f)){const [g,h,j,k,l]=f;if(G(0x110)===l);else{if(G(0x11b)===l){const m=this[G(0xeb)][G(0x118)](hotmesh_1[G(0xec)][G(0xef)],{'appId':this[G(0xeb)][G(0xe7)]});await this[G(0xeb)]['delistSignalKey'](m,h);}else await c(h,j,k,l);}await(0x0,utils_1[G(0xf2)])(0x0),this[G(0xdc)]=0x0,this['processTimeHooks'](c,g);}else{if(f)await(0x0,utils_1[G(0xf2)])(0x0),this['errorCount']=0x0,this[G(0xdb)](c);else{const n=(0x0,utils_1[G(0x111)])(0x3e8*enums_1[G(0xe8)]);this[G(0x117)]=n[G(0xf1)],await n['promise'],this[G(0xdc)]=0x0,this[G(0xdb)](c);}}}catch(p){this[G(0x11a)]['warn'](G(0xe9),p),await(0x0,utils_1[G(0xf2)])(0x3e8*this[G(0xdc)]++),this[G(0xdc)]<0x5&&this[G(0xdb)](c);}else{const q=(0x0,utils_1[G(0x111)])(0x3e8*enums_1[G(0xf4)]*0x2*Math[G(0x109)]());this[G(0x117)]=q['timerId'],await q[G(0xf5)],this[G(0xdb)](c);}}[y(0x11d)](){const H=y;void 0x0!==this[H(0x117)]&&(clearTimeout(this[H(0x117)]),this['cleanupTimeout']=void 0x0);}async[y(0x114)](c){const I=y,d=await this['store'][I(0x10c)]();return d?.[c]?.[0x0];}async[y(0xe1)](d,f,g,h,j){const J=y,k=await this[J(0x114)](d);if(k){const m=k[J(0x106)][J(0xe4)][0x0]['expected'],p=pipe_1['Pipe']['resolve'](m,f),q=f[J(0x113)][J(0xed)],v=f[J(0x113)]['gid'],w={'topic':d,'resolved':p,'jobId':[k['to'],g,v,q][J(0x105)](key_1['WEBSEP']),'expire':h};return await this['store']['setHookSignal'](w,j),q;}throw new Error(J(0x10e));}async['processWebHookSignal'](d,f){const K=y,g=await this['getHookRule'](d);if(g){const h={'$self':{'hook':{'data':f}},'$hook':{'data':f}},j=g['conditions'][K(0xe4)][0x0]['actual'],k=pipe_1['Pipe'][K(0xf6)](j,h),m=await this[K(0xeb)][K(0xe5)](d,k);if(!m)return;const [p,q,v,...w]=m[K(0xe0)](key_1[K(0xfd)]);return[w[K(0x105)](key_1[K(0xfd)]),g['to'],q,v];}throw new Error(K(0xfe));}async[y(0xf0)](c,d){const L=y,f=await this[L(0x114)](c);if(f){const g={'$self':{'hook':{'data':d}},'$hook':{'data':d}},h=f['conditions'][L(0xe4)][0x0][L(0xf3)],j=pipe_1['Pipe'][L(0xf6)](h,g);return await this[L(0xeb)][L(0x108)](c,j);}throw new Error('signaler.process:error:\x20hook\x20rule\x20not\x20found');}}exports['TaskService']=TaskService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
+const pipe_1 = require("../pipe");
+const hotmesh_1 = require("../../types/hotmesh");
+const key_1 = require("../../modules/key");
+class TaskService {
+    constructor(store, logger) {
+        this.cleanupTimeout = null;
+        this.isScout = false;
+        this.errorCount = 0;
+        this.logger = logger;
+        this.store = store;
+    }
+    async processWebHooks(hookEventCallback) {
+        const workItemKey = await this.store.getActiveTaskQueue();
+        if (workItemKey) {
+            const [topic, sourceKey, scrub, ...sdata] = workItemKey.split(key_1.WEBSEP);
+            const data = JSON.parse(sdata.join(key_1.WEBSEP));
+            const destinationKey = `${sourceKey}:processed`;
+            const jobId = await this.store.processTaskQueue(sourceKey, destinationKey);
+            if (jobId) {
+                //todo: don't use 'id', make configurable using hook rule
+                await hookEventCallback(topic, { ...data, id: jobId });
+            }
+            else {
+                await this.store.deleteProcessedTaskQueue(workItemKey, sourceKey, destinationKey, scrub === 'true');
+            }
+            setImmediate(() => this.processWebHooks(hookEventCallback));
+        }
+    }
+    async enqueueWorkItems(keys) {
+        await this.store.addTaskQueues(keys);
+    }
+    async registerJobForCleanup(jobId, inSeconds = enums_1.HMSH_EXPIRE_DURATION, options) {
+        if (inSeconds > 0) {
+            await this.store.expireJob(jobId, inSeconds);
+            // const fromNow = Date.now() + inSeconds * 1000;
+            // const fidelityMS = HMSH_FIDELITY_SECONDS * 1000;
+            // const timeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+            // await this.store.registerDependenciesForCleanup(jobId, timeSlot, options);
+        }
+    }
+    async registerTimeHook(jobId, gId, activityId, type, inSeconds = enums_1.HMSH_FIDELITY_SECONDS, dad, transaction) {
+        const fromNow = Date.now() + inSeconds * 1000;
+        const fidelityMS = enums_1.HMSH_FIDELITY_SECONDS * 1000;
+        const awakenTimeSlot = Math.floor(fromNow / fidelityMS) * fidelityMS;
+        await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, dad, transaction);
+    }
+    /**
+     * Should this engine instance play the role of 'scout' on behalf
+     * of the entire quorum? The scout role is responsible for processing
+     * task lists on behalf of the collective.
+     */
+    async shouldScout() {
+        const wasScout = this.isScout;
+        const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
+        if (isScout) {
+            if (!wasScout) {
+                setTimeout(() => {
+                    this.isScout = false;
+                }, enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Callback handler that takes an item from a work list and
+     * processes according to its type
+     */
+    async processTimeHooks(timeEventCallback, listKey) {
+        if (await this.shouldScout()) {
+            try {
+                const workListTask = await this.store.getNextTask(listKey);
+                if (Array.isArray(workListTask)) {
+                    const [listKey, target, gId, activityId, type] = workListTask;
+                    if (type === 'child') {
+                        //continue; this child is listed here for convenience, but
+                        //  will be expired by an origin ancestor and is listed there
+                    }
+                    else if (type === 'delist') {
+                        //delist the signalKey (target)
+                        const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, {
+                            appId: this.store.appId,
+                        });
+                        await this.store.delistSignalKey(key, target);
+                    }
+                    else {
+                        //awaken/expire/interrupt
+                        await timeEventCallback(target, gId, activityId, type);
+                    }
+                    await (0, utils_1.sleepFor)(0);
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback, listKey);
+                }
+                else if (workListTask) {
+                    //a worklist was just emptied; try again immediately
+                    await (0, utils_1.sleepFor)(0);
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback);
+                }
+                else {
+                    //no worklists exist; sleep before checking
+                    const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_FIDELITY_SECONDS * 1000);
+                    this.cleanupTimeout = sleep.timerId;
+                    await sleep.promise;
+                    this.errorCount = 0;
+                    this.processTimeHooks(timeEventCallback);
+                }
+            }
+            catch (err) {
+                //most common reasons: deleted job not found; container stopping; test stopping
+                //less common: redis/cluster down; retry with fallback (5s max main reassignment)
+                this.logger.warn('task-process-timehooks-error', err);
+                await (0, utils_1.sleepFor)(1000 * this.errorCount++);
+                if (this.errorCount < 5) {
+                    this.processTimeHooks(timeEventCallback);
+                }
+            }
+        }
+        else {
+            //didn't get the scout role; try again in 'one-ish' minutes
+            const sleep = (0, utils_1.XSleepFor)(enums_1.HMSH_SCOUT_INTERVAL_SECONDS * 1000 * 2 * Math.random());
+            this.cleanupTimeout = sleep.timerId;
+            await sleep.promise;
+            this.processTimeHooks(timeEventCallback);
+        }
+    }
+    cancelCleanup() {
+        if (this.cleanupTimeout !== undefined) {
+            clearTimeout(this.cleanupTimeout);
+            this.cleanupTimeout = undefined;
+        }
+    }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerWebHook(topic, context, dad, expire, transaction) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            const mapExpression = hookRule.conditions.match[0].expected;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const jobId = context.metadata.jid;
+            const gId = context.metadata.gid;
+            const activityId = hookRule.to;
+            //composite keys are used to fully describe the task target
+            const compositeJobKey = [activityId, dad, gId, jobId].join(key_1.WEBSEP);
+            const hook = {
+                topic,
+                resolved,
+                jobId: compositeJobKey,
+                expire,
+            };
+            await this.store.setHookSignal(hook, transaction);
+            return jobId;
+        }
+        else {
+            throw new Error('signaler.registerWebHook:error: hook rule not found');
+        }
+    }
+    async processWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            const hookSignalId = await this.store.getHookSignal(topic, resolved);
+            if (!hookSignalId) {
+                //messages can be double-processed; not an issue; return `undefined`
+                //users can also provide a bogus topic; not an issue; return `undefined`
+                return undefined;
+            }
+            //`aid` is part of composite key, but the hook `topic` is its public interface;
+            // this means that a new version of the graph can be deployed and the
+            // topic can be re-mapped to a different activity id. Outside callers
+            // can adhere to the unchanged contract (calling the same topic),
+            // while the internal system can be updated in real-time as necessary.
+            const [_aid, dad, gid, ...jid] = hookSignalId.split(key_1.WEBSEP);
+            return [jid.join(key_1.WEBSEP), hookRule.to, dad, gid];
+        }
+        else {
+            throw new Error('signal-not-found');
+        }
+    }
+    async deleteWebHookSignal(topic, data) {
+        const hookRule = await this.getHookRule(topic);
+        if (hookRule) {
+            //NOTE: both formats are supported by the mapping engine:
+            //      `$self.hook.data` OR `$hook.data`
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
+            return await this.store.deleteHookSignal(topic, resolved);
+        }
+        else {
+            throw new Error('signaler.process:error: hook rule not found');
+        }
+    }
+}
+exports.TaskService = TaskService;