@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/pipe/functions/symbol.js

@@ -1 +1,33 @@
-'use strict';var i=b;(function(c,d){var h=b,e=c();while(!![]){try{var f=parseInt(h(0x1b6))/0x1+parseInt(h(0x1b9))/0x2*(parseInt(h(0x1b2))/0x3)+-parseInt(h(0x1b7))/0x4*(parseInt(h(0x1b1))/0x5)+-parseInt(h(0x1bd))/0x6+-parseInt(h(0x1ba))/0x7*(parseInt(h(0x1b4))/0x8)+-parseInt(h(0x1c3))/0x9+parseInt(h(0x1b8))/0xa*(parseInt(h(0x1bc))/0xb);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x75483));function b(c,d){var e=a();return b=function(f,g){f=f-0x1b1;var h=e[f];return h;},b(c,d);}function a(){var j=['NaN','5202009VmXNbg','20QcMBkm','29598eLhRvF','date','40RIbQVR','object','714997kgauZy','505860hSHNaZ','9510eyQVEM','140kmZTdb','398839QtuERN','whitespace','15708QLeBva','5487072ZyWWUb','posInfinity','negInfinity','null','SymbolHandler'];a=function(){return j;};return a();}Object['defineProperty'](exports,'__esModule',{'value':!0x0}),exports[i(0x1c1)]=void 0x0;class SymbolHandler{[i(0x1c0)](){return null;}['undefined'](){}[i(0x1bb)](){return'\x20';}[i(0x1b5)](){return{};}['array'](){return[];}[i(0x1be)](){return 0x1/0x0;}[i(0x1bf)](){return-0x1/0x0;}[i(0x1c2)](){return NaN;}[i(0x1b3)](){return new Date();}}exports['SymbolHandler']=SymbolHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolHandler = void 0;
+class SymbolHandler {
+    null() {
+        return null;
+    }
+    undefined() {
+        return undefined;
+    }
+    whitespace() {
+        return ' ';
+    }
+    object() {
+        return {};
+    }
+    array() {
+        return [];
+    }
+    posInfinity() {
+        return Infinity;
+    }
+    negInfinity() {
+        return -Infinity;
+    }
+    NaN() {
+        return NaN;
+    }
+    date() {
+        return new Date();
+    }
+}
+exports.SymbolHandler = SymbolHandler;

package/build/services/pipe/functions/unary.js

@@ -1 +1,18 @@
-'use strict';var i=b;function a(){var j=['235720iULPzn','271yETzOB','51ZxcAMy','UnaryHandler','1309266iLtgiA','10598610hUECdg','negative','4870imJOBO','5017465EjIjsd','bitwise_not','7rmDUjR','2857194bIyoDj','4616096MuhOjW'];a=function(){return j;};return a();}(function(c,d){var h=b,e=c();while(!![]){try{var f=parseInt(h(0x15e))/0x1*(parseInt(h(0x164))/0x2)+-parseInt(h(0x15f))/0x3*(parseInt(h(0x16a))/0x4)+parseInt(h(0x165))/0x5+-parseInt(h(0x168))/0x6+-parseInt(h(0x167))/0x7*(parseInt(h(0x169))/0x8)+-parseInt(h(0x161))/0x9+parseInt(h(0x162))/0xa;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x7f9f8));Object['defineProperty'](exports,'__esModule',{'value':!0x0}),exports[i(0x160)]=void 0x0;function b(c,d){var e=a();return b=function(f,g){f=f-0x15e;var h=e[f];return h;},b(c,d);}class UnaryHandler{['not'](c){return!c;}['positive'](c){return+c;}[i(0x163)](c){return-c;}[i(0x166)](c){return~c;}}exports[i(0x160)]=UnaryHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnaryHandler = void 0;
+class UnaryHandler {
+    not(value) {
+        return !value;
+    }
+    positive(value) {
+        return +value;
+    }
+    negative(value) {
+        return -value;
+    }
+    bitwise_not(value) {
+        return ~value;
+    }
+}
+exports.UnaryHandler = UnaryHandler;

package/build/services/pipe/index.js

@@ -1 +1,242 @@
-'use strict';const m=b;function a(){const J=['object','defineProperty','__esModule','328088ifKdbt','endsWith','call','context','jobData','isreduceType','Unknown\x20domain\x20name\x20[','{$index','hasOwnProperty','concat','rules','resolveContextTerm','prototype','reduce','Unknown\x20domain\x20function\x20[','getNestedProperty','{$input','processRow',']:\x20','1255566Kgwxfc','resolveContextValue','split','push','7335005qInDwf','isPipeType','308FpIXQY','resolveFunction','Pipe','4642276DkHTqy','resolve','isContextVariable','processCells','isPipeObject','length','process','resolveCellValue','resolveMapTerm','@pipe','resolveMappableValue','cloneUnknown','{$item','isArray','569826nQwYiH','startsWith','default','2611026mvvlaH','isFunction','__importDefault','956350GMjACG','string','isMappable','substring','map'];a=function(){return J;};return a();}(function(c,d){const l=b,e=c();while(!![]){try{const f=parseInt(l(0x6e))/0x1+-parseInt(l(0x89))/0x2+-parseInt(l(0x6b))/0x3+parseInt(l(0x92))/0x4+-parseInt(l(0x8d))/0x5+-parseInt(l(0xa0))/0x6+-parseInt(l(0x8f))/0x7*(-parseInt(l(0x76))/0x8);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xd247a));function b(c,d){const e=a();return b=function(f,g){f=f-0x6b;let h=e[f];return h;},b(c,d);}var __importDefault=this&&this[m(0x6d)]||function(c){const n=m;return c&&c[n(0x75)]?c:{'default':c};};Object[m(0x74)](exports,m(0x75),{'value':!0x0}),exports[m(0x91)]=void 0x0;const functions_1=__importDefault(require('./functions'));class Pipe{constructor(c,d,f){const o=m;this['rules']=c,this[o(0x7a)]=d,this[o(0x79)]=f;}[m(0x8e)](c){const p=m;return!Array[p(0x9f)](c)&&'@pipe'in c;}['isreduceType'](c){const q=m;return!Array[q(0x9f)](c)&&'@reduce'in c;}static['isPipeObject'](c){const r=m;return r(0x73)==typeof c&&null!==c&&!Array[r(0x9f)](c)&&r(0x9b)in c;}static[m(0x93)](c,d){const s=m;let f;return f=Pipe[s(0x96)](c)?new Pipe(c[s(0x9b)],d):new Pipe([[c]],d),f[s(0x98)]();}[m(0x98)](c=null){const t=m;let d=0x0;c||this[t(0x8e)](this['rules'][0x0])||this[t(0x7b)](this[t(0x80)][0x0])||(c=this[t(0x95)](this['rules'][0x0]),d=0x1);const f=this[t(0x80)][t(0x97)],g=[];for(let h=d;h<f;h++)c=this[t(0x87)](this[t(0x80)][h],c,g);return c[0x0];}['cloneUnknown'](c){const u=m;if(null===c||u(0x73)!=typeof c)return c;if(c instanceof Date)return new Date(c['getTime']());if(c instanceof RegExp)return new RegExp(c);if(Array[u(0x9f)](c))return c[u(0x72)](f=>this[u(0x9d)](f));const d={};for(const f in c)Object[u(0x82)]['hasOwnProperty'][u(0x78)](c,f)&&(d[f]=this[u(0x9d)](c[f]));return d;}['reduce'](c){const v=m;let d=this[v(0x9d)](c[0x1]??null);if(Array[v(0x9f)](c[0x0])){for(let f=0x0;f<c[0x0]['length'];f++)this[v(0x79)]={'$input':c[0x0],'$output':d,'$item':c[0x0][f],'$key':f['toString'](),'$index':f},d=this[v(0x98)]([d]);}else{let g=-0x1;for(const h in c[0x0])g++,this[v(0x79)]={'$input':c[0x0],'$output':d,'$item':c[0x0][h],'$key':h,'$index':g},d=this[v(0x98)]([d]);}return[d];}[m(0x87)](c,d,f){const w=m;if(d&&this['isreduceType'](c))return new Pipe(c['@reduce'],this['jobData'])[w(0x83)](d);if(this[w(0x8e)](c)){const g=new Pipe(c[w(0x9b)],this['jobData'],this['context']);return f[w(0x8c)](g[w(0x98)]()),d;}if(f[w(0x97)]>0x0&&(d=[...f],f[w(0x97)]=0x0),d){const [h,...j]=c;let k;return k=this[w(0x94)](h)?this['resolveContextValue'](h):Pipe[w(0x90)](h)(...d),[k][w(0x7f)](this[w(0x95)]([...j]));}return[][w(0x7f)](this[w(0x95)](Array[w(0x9f)](c)?[...c]:[]));}static['resolveFunction'](c){const x=m;let [d,f]=c[x(0x8b)]('.');d=d[x(0x71)](0x2),f=f[x(0x71)](0x0,f[x(0x97)]-0x1);const g=functions_1[x(0xa2)][d];if(!g)throw new Error(x(0x7c)+c+x(0x88)+d);if(!g[f])throw new Error(x(0x84)+c+x(0x88)+d+'.'+f);return g[f];}[m(0x95)](c){const y=m,d=[];if(Array[y(0x9f)](c)){for(const f of c)d[y(0x8c)](this[y(0x99)](f));}return d;}['isFunction'](c){const z=m;return z(0x6f)==typeof c&&c[z(0xa1)]('{@')&&c[z(0x77)]('}');}[m(0x94)](c){const A=m;if(A(0x6f)==typeof c&&c[A(0x77)]('}'))return c[A(0xa1)](A(0x9e))||c[A(0xa1)]('{$key')||c['startsWith'](A(0x7d))||c['startsWith'](A(0x86))||c['startsWith']('{$output');}['isMappable'](c){const B=m;return B(0x6f)==typeof c&&c[B(0xa1)]('{')&&c[B(0x77)]('}');}[m(0x99)](c){const C=m;if(this[C(0x6c)](c))return Pipe[C(0x90)](c)['call']();return this[C(0x94)](c)?this[C(0x8a)](c):this[C(0x70)](c)?this[C(0x9c)](c):c;}[m(0x85)](c,d){const D=m,f=d[D(0x8b)]('.');let g=c;for(const h of f){if(null===g||D(0x73)!=typeof g||!g[D(0x7e)](h))return;g=g[h];}return g;}['resolveMappableValue'](c){const E=m,d=this[E(0x9a)](c);return this[E(0x85)](this[E(0x7a)],d);}[m(0x8a)](c){const F=m,d=this['resolveContextTerm'](c);return this[F(0x85)](this[F(0x79)],d);}[m(0x81)](c){const G=m;return c[G(0x71)](0x1,c[G(0x97)]-0x1);}['resolveFunctionTerm'](c){const H=m;return c['substring'](0x2,c[H(0x97)]-0x1);}[m(0x9a)](c){const I=m;return c['substring'](0x1,c[I(0x97)]-0x1);}}exports[m(0x91)]=Pipe;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipe = void 0;
+const functions_1 = __importDefault(require("./functions"));
+class Pipe {
+    constructor(rules, jobData, context) {
+        this.rules = rules;
+        this.jobData = jobData;
+        this.context = context;
+    }
+    isPipeType(currentRow) {
+        return !Array.isArray(currentRow) && '@pipe' in currentRow;
+    }
+    isreduceType(currentRow) {
+        return !Array.isArray(currentRow) && '@reduce' in currentRow;
+    }
+    static isPipeObject(obj) {
+        return (typeof obj === 'object' &&
+            obj !== null &&
+            !Array.isArray(obj) &&
+            '@pipe' in obj);
+    }
+    static resolve(unresolved, context) {
+        let pipe;
+        if (Pipe.isPipeObject(unresolved)) {
+            pipe = new Pipe(unresolved['@pipe'], context);
+        }
+        else {
+            pipe = new Pipe([[unresolved]], context);
+        }
+        return pipe.process();
+    }
+    /**
+     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
+     * @returns {any} the result of the pipe
+     */
+    process(resolved = null) {
+        let index = 0;
+        if (!(resolved ||
+            this.isPipeType(this.rules[0]) ||
+            this.isreduceType(this.rules[0]))) {
+            resolved = this.processCells(this.rules[0]); // Add type assertion
+            index = 1;
+        }
+        const len = this.rules.length;
+        const subPipeQueue = [];
+        for (let i = index; i < len; i++) {
+            resolved = this.processRow(this.rules[i], resolved, subPipeQueue);
+        }
+        return resolved[0];
+    }
+    cloneUnknown(value) {
+        if (value === null || typeof value !== 'object') {
+            return value;
+        }
+        if (value instanceof Date) {
+            return new Date(value.getTime());
+        }
+        if (value instanceof RegExp) {
+            return new RegExp(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.cloneUnknown(item));
+        }
+        const clonedObj = {};
+        for (const key in value) {
+            if (Object.prototype.hasOwnProperty.call(value, key)) {
+                clonedObj[key] = this.cloneUnknown(value[key]);
+            }
+        }
+        return clonedObj;
+    }
+    /**
+     * Transforms iterable `input` into a single value. Vars $output, $item, $key
+     * and $input are available. The final statement in the iterator (the reduction)
+     * is assumed to be the return value. A default $output object may be provided
+     * to the iterator by placing the the second cell of the preceding row. Otherwise,
+     * construct the object during first run and ensure it is the first cell of the
+     * last row of the iterator, so it is returned as the $output for the next cycle
+     * @param {unknown[]} input
+     * @returns {unknown}
+     * @private
+     */
+    reduce(input) {
+        let resolved = this.cloneUnknown(input[1] ?? null);
+        if (Array.isArray(input[0])) {
+            for (let index = 0; index < input[0].length; index++) {
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][index],
+                    $key: index.toString(),
+                    $index: index,
+                };
+                resolved = this.process([resolved]);
+            }
+        }
+        else {
+            let index = -1;
+            for (const $key in input[0]) {
+                index++;
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][$key],
+                    $key,
+                    $index: index,
+                };
+                resolved = this.process([resolved]);
+            }
+        }
+        return [resolved];
+    }
+    processRow(currentRow, resolvedPriorRow, subPipeQueue) {
+        if (resolvedPriorRow && this.isreduceType(currentRow)) {
+            //reduce the resolvedPriorRow and return the output from the reducer
+            const subPipe = new Pipe(currentRow['@reduce'], this.jobData);
+            const reduced = subPipe.reduce(resolvedPriorRow);
+            return reduced;
+        }
+        else if (this.isPipeType(currentRow)) {
+            //process subPipe and push to subPipeQueue; echo resolvedPriorRow
+            const subPipe = new Pipe(currentRow['@pipe'], this.jobData, this.context);
+            subPipeQueue.push(subPipe.process());
+            return resolvedPriorRow;
+        }
+        else {
+            //pivot the subPipeQueue into the arguments array (resolvedPriorRow)
+            if (subPipeQueue.length > 0) {
+                resolvedPriorRow = [...subPipeQueue];
+                subPipeQueue.length = 0;
+            }
+            if (!resolvedPriorRow) {
+                //if no prior row, use current row as prior row
+                return [].concat(this.processCells(Array.isArray(currentRow) ? [...currentRow] : []));
+            }
+            else {
+                const [functionName, ...params] = currentRow; // Add type assertion
+                //use resolved values from prior row (n - 1) as input params to cell 1 function
+                let resolvedValue;
+                if (this.isContextVariable(functionName)) {
+                    resolvedValue = this.resolveContextValue(functionName);
+                }
+                else {
+                    resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
+                }
+                //resolve remaining cells in row and return concatenated with resolvedValue
+                return [resolvedValue].concat(this.processCells([...params]));
+            }
+        }
+    }
+    static resolveFunction(functionName) {
+        let [prefix, suffix] = functionName.split('.');
+        prefix = prefix.substring(2);
+        suffix = suffix.substring(0, suffix.length - 1);
+        const domain = functions_1.default[prefix];
+        if (!domain) {
+            throw new Error(`Unknown domain name [${functionName}]: ${prefix}`);
+        }
+        if (!domain[suffix]) {
+            throw new Error(`Unknown domain function [${functionName}]: ${prefix}.${suffix}`);
+        }
+        return domain[suffix];
+    }
+    processCells(cells) {
+        const resolved = [];
+        if (Array.isArray(cells)) {
+            for (const currentCell of cells) {
+                resolved.push(this.resolveCellValue(currentCell));
+            }
+        }
+        return resolved;
+    }
+    isFunction(currentCell) {
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{@') &&
+            currentCell.endsWith('}'));
+    }
+    isContextVariable(currentCell) {
+        if (typeof currentCell === 'string' && currentCell.endsWith('}')) {
+            return (currentCell.startsWith('{$item') ||
+                currentCell.startsWith('{$key') ||
+                currentCell.startsWith('{$index') ||
+                currentCell.startsWith('{$input') ||
+                currentCell.startsWith('{$output'));
+        }
+    }
+    isMappable(currentCell) {
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{') &&
+            currentCell.endsWith('}'));
+    }
+    resolveCellValue(currentCell) {
+        if (this.isFunction(currentCell)) {
+            const fn = Pipe.resolveFunction(currentCell);
+            return fn.call();
+        }
+        else if (this.isContextVariable(currentCell)) {
+            return this.resolveContextValue(currentCell);
+        }
+        else if (this.isMappable(currentCell)) {
+            return this.resolveMappableValue(currentCell);
+        }
+        else {
+            return currentCell;
+        }
+    }
+    getNestedProperty(obj, path) {
+        const pathParts = path.split('.');
+        let current = obj;
+        for (const part of pathParts) {
+            if (current === null ||
+                typeof current !== 'object' ||
+                !current.hasOwnProperty(part)) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    resolveMappableValue(currentCell) {
+        const term = this.resolveMapTerm(currentCell);
+        return this.getNestedProperty(this.jobData, term);
+    }
+    resolveContextValue(currentCell) {
+        const term = this.resolveContextTerm(currentCell);
+        return this.getNestedProperty(this.context, term);
+    }
+    resolveContextTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
+    resolveFunctionTerm(currentCell) {
+        return currentCell.substring(2, currentCell.length - 1);
+    }
+    resolveMapTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
+}
+exports.Pipe = Pipe;

package/build/services/quorum/index.js

@@ -1 +1,263 @@
-'use strict';const p=b;(function(c,d){const o=b,e=c();while(!![]){try{const f=parseInt(o(0x137))/0x1*(-parseInt(o(0x145))/0x2)+parseInt(o(0x13c))/0x3*(-parseInt(o(0x136))/0x4)+parseInt(o(0x130))/0x5*(-parseInt(o(0xeb))/0x6)+parseInt(o(0xff))/0x7*(-parseInt(o(0xe6))/0x8)+-parseInt(o(0x128))/0x9*(-parseInt(o(0x11c))/0xa)+-parseInt(o(0x13f))/0xb*(parseInt(o(0x147))/0xc)+parseInt(o(0x146))/0xd*(parseInt(o(0x14b))/0xe);if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0xdd897));function a(){const G=['XSleepFor','depth','4RMsomM','241nNGLId','../../types/hotmesh','reclaimDelay','HMSH_QUORUM_DELAY_MS','active','2818371sFsztv','initSubChannel','defineProperty','247731QoONZU','verifyQuorumFields','rollCall','quorum\x20config\x20must\x20include\x20`store`\x20and\x20`sub`\x20fields.','store','max','5638gBmhOx','13bAgcbN','588IREVFF','getVID','HMSH_QUORUM_ROLLCALL_CYCLES','engine','60383834isrelD','type','until_version','job','push','HMSH_ACTIVATION_MAX_RETRY','info','sayPong','identifyProvider','filter','rollCallInterval','../store/factory','mintKey','random','7657016AkIamL','requestQuorum','setCacheMode','version','STREAMS','7614mGyhSg','length','quorum-activation-succeeded','../../modules/enums','quorum-rollcall-succeeded','throttle','forEach','callbacks','__esModule','stream','details','unsub','router','quorum-activation-awaiting','namespace','counts','warn','activate','quorum-activation-error','untilVersion','7mHyPTD','originator','inited','reserveScoutRole','releaseScoutRole','QuorumService','initStoreChannel','nocache','pub','QUORUM','../sub/factory','routeToSubscribers','getStreamDepths','processWebHooks','rollcall','cache_mode','logger','stream_depth','guid','formatISODate','profiles','\x20not\x20activated.','publish','pong','quorum','debug','processTimeHooks','reclaimCount','StoreServiceFactory','10Iaanil','subscribe','subscriptionHandler','sleepFor','ping','doRollCall','../../modules/utils','cancelRollCall','quorum-event-received','sub','appId','toString','11714994vcBZDG','CompilerService','SubServiceFactory','KeyType','work','interval','cache','profile','4050huTbIP','init','cacheMode','getApp'];a=function(){return G;};return a();}Object[p(0x13e)](exports,p(0xf3),{'value':!0x0}),exports['QuorumService']=void 0x0;const enums_1=require(p(0xee)),utils_1=require(p(0x122)),compiler_1=require('../compiler'),hotmesh_1=require(p(0x138)),factory_1=require(p(0x109)),factory_2=require(p(0xe3));class QuorumService{constructor(){const q=p;this['profiles']=[],this[q(0x132)]=q(0x12e),this['untilVersion']=null,this[q(0x117)]=null,this['callbacks']=[];}static async[p(0x131)](c,d,f,g,h,j){const r=p;if(g['engine']){const k=new QuorumService();return k[r(0x140)](g),k[r(0xf9)]=c,k[r(0x126)]=d,k[r(0x111)]=f,k[r(0x10f)]=j,k['engine']=h,await k[r(0x105)](g[r(0x14a)][r(0x143)]),await k[r(0x13d)](g[r(0x14a)][r(0x125)],g['engine'][r(0x107)]??g[r(0x14a)][r(0x143)]),await k['subscribe']['subscribe'](hotmesh_1[r(0x12b)][r(0x108)],k[r(0x11e)](),d),await k[r(0x11d)][r(0x11d)](hotmesh_1['KeyType'][r(0x108)],k[r(0x11e)](),d,k[r(0x111)]),k['engine'][r(0x10c)](),k['engine'][r(0x119)](),k;}}[p(0x140)](c){const s=p;if(!(0x0,utils_1[s(0xe0)])(c['engine']['store'])||!(0x0,utils_1[s(0xe0)])(c[s(0x14a)][s(0x125)]))throw new Error(s(0x142));}async['initStoreChannel'](c){const t=p;this[t(0x143)]=await factory_2[t(0x11b)][t(0x131)](c,this[t(0xf9)],this[t(0x126)],this[t(0x10f)]);}async[p(0x13d)](c,d){const u=p;this['subscribe']=await factory_1[u(0x12a)][u(0x131)](c,d,this[u(0xf9)],this['appId'],this[u(0x111)],this[u(0x10f)]);}[p(0x11e)](){const c=this;return async(d,f)=>{const v=b;c[v(0x10f)]['debug'](v(0x124),{'topic':d,'type':f['type']}),v(0xfc)===f['type']?c['engine'][v(0xe8)](f[v(0x10e)],f[v(0xda)]):v(0x120)===f['type']?c[v(0xdf)](c[v(0x126)],c['guid'],f[v(0x100)],f[v(0xf5)]):v(0x116)===f['type']&&c[v(0x111)]===f[v(0x100)]?(c[v(0x117)]=c[v(0x117)]+0x1,f[v(0x12f)]&&c['profiles'][v(0xdc)](f[v(0x12f)])):v(0xf0)===f['type']?c[v(0x14a)][v(0xf0)](f[v(0xf0)]):v(0x12c)===f[v(0xd9)]?c[v(0x14a)][v(0x10c)]():'job'===f['type']?c[v(0x14a)][v(0x10a)](f['topic'],f[v(0xdb)]):'cron'===f['type']?c[v(0x14a)][v(0x119)]():v(0x10d)===f['type']&&c[v(0x121)](f),c[v(0xf2)][v(0xec)]>0x0&&c[v(0xf2)][v(0xf1)](g=>g(d,f));};}async[p(0xdf)](c,d,f,g=!0x1){const w=p;let h;if(g){const j=this[w(0x14a)][w(0x143)][w(0xe4)](hotmesh_1[w(0x12b)][w(0xea)],{'appId':this[w(0x126)]});h={'engine_id':this[w(0x111)],'namespace':this[w(0xf9)],'app_id':this[w(0x126)],'stream':j,'counts':this[w(0x14a)][w(0xf7)][w(0xfa)],'timestamp':(0x0,utils_1[w(0x112)])(new Date()),'inited':this['engine'][w(0x101)],'throttle':this[w(0x14a)][w(0xf7)][w(0xf0)],'reclaimDelay':this[w(0x14a)][w(0xf7)][w(0x139)],'reclaimCount':this['engine'][w(0xf7)][w(0x11a)],'system':await(0x0,utils_1['getSystemHealth'])()};}this[w(0x11d)]['publish'](hotmesh_1[w(0x12b)][w(0x108)],{'type':w(0x116),'guid':d,'originator':f,'profile':h},c);}async[p(0xe7)](c=enums_1[p(0x13a)],d=!0x1){const x=p,f=this[x(0x117)];return this[x(0x117)]=0x0,this[x(0x113)][x(0xec)]=0x0,await this[x(0x11d)][x(0x115)](hotmesh_1['KeyType'][x(0x108)],{'type':x(0x120),'originator':this[x(0x111)],'details':d},this[x(0x126)]),await(0x0,utils_1[x(0x11f)])(c),f;}async[p(0x121)](c){const y=p;let d=0x0;const f=isNaN(c['max'])?enums_1[y(0x149)]:c[y(0x144)];this['rollCallInterval']&&clearTimeout(this['rollCallInterval']);const g=c[y(0x12d)]/0x2,h=g+Math['ceil'](Math[y(0xe5)]()*g);do{if(await(0x0,utils_1[y(0x11f)])(Math['ceil'](0x3e8*Math[y(0xe5)]())),await this[y(0xdf)](this[y(0x126)],this[y(0x111)],null,!0x0),!c['interval'])return;const {promise:j,timerId:k}=(0x0,utils_1[y(0x134)])(0x3e8*h);this[y(0xe2)]=k,await j;}while(this['rollCallInterval']&&d++<f-0x1);}[p(0x123)](){const z=p;this['rollCallInterval']&&(clearTimeout(this[z(0xe2)]),delete this['rollCallInterval']);}['stop'](){this['cancelRollCall']();}async['pub'](c){const A=p;return await this[A(0x11d)][A(0x115)](hotmesh_1['KeyType'][A(0x108)],c,this[A(0x126)],c['topic']||c[A(0x111)]);}async[p(0x125)](c){const B=p;this[B(0xf2)][B(0xdc)](c);}async[p(0xf6)](c){const C=p;this['callbacks']=this[C(0xf2)][C(0xe1)](d=>d!==c);}async[p(0x141)](c=enums_1[p(0x13a)]){const D=p;await this[D(0xe7)](c,!0x0);const d=await this[D(0x14a)][D(0xf4)][D(0x10b)](this[D(0x113)]);return this[D(0x113)]['forEach'](async(f,g)=>{const E=D;f[E(0x110)]=d?.[g]?.[E(0x135)]??0x0;}),this[D(0x113)];}async[p(0xfc)](c,d=enums_1['HMSH_QUORUM_DELAY_MS'],f=0x0){const F=p;c=c[F(0x127)]();if(!await this[F(0x143)][F(0x102)]('activate',Math['ceil'](0x6*d/0x3e8)+0x1)){this[F(0x10f)][F(0x118)](F(0xf8),{'version':c}),await(0x0,utils_1['sleepFor'])(0x6*d);const l=await this[F(0x143)][F(0x133)](this[F(0x126)],!0x0);return 0x1==l?.[F(0x13b)]&&l?.[F(0xe9)]===c;}const g=await this[F(0x14a)][F(0x148)]();await this[F(0xe7)](d);const h=await this[F(0xe7)](d),j=await this[F(0xe7)](d),k=await this[F(0xe7)](d);if(h&&h===j&&j===k){if(this[F(0x10f)][F(0xde)](F(0xef),{'q1':h,'q2':j,'q3':k}),this[F(0x11d)][F(0x115)](hotmesh_1['KeyType']['QUORUM'],{'type':F(0xfc),'cache_mode':F(0x106),'until_version':c},this[F(0x126)]),await new Promise(m=>setTimeout(m,d)),await this[F(0x143)][F(0x103)]('activate'),this[F(0x14a)][F(0xfe)]===c){this[F(0x10f)][F(0xde)](F(0xed),{'version':c});const {id:m}=g,n=new compiler_1[(F(0x129))](this[F(0x143)],this[F(0x14a)][F(0xf4)],this['logger']);return await n[F(0xfc)](m,c);}throw this['logger']['error'](F(0xfd),{'version':c}),new Error('UntilVersion\x20Not\x20Received.\x20Version\x20'+c+'\x20not\x20activated');}if(this[F(0x10f)][F(0xfb)]('quorum-rollcall-error',{'q1':h,'q2':j,'q3':k,'count':f}),this[F(0x143)][F(0x103)](F(0xfc)),f<enums_1[F(0xdd)])return await this[F(0xfc)](c,0x2*d,f+0x1);throw new Error('Quorum\x20not\x20reached.\x20Version\x20'+c+F(0x114));}}function b(c,d){const e=a();return b=function(f,g){f=f-0xd9;let h=e[f];return h;},b(c,d);}exports[p(0x104)]=QuorumService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuorumService = void 0;
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
+const compiler_1 = require("../compiler");
+const hotmesh_1 = require("../../types/hotmesh");
+const factory_1 = require("../sub/factory");
+const factory_2 = require("../store/factory");
+class QuorumService {
+    /**
+     * @private
+     */
+    constructor() {
+        this.profiles = [];
+        this.cacheMode = 'cache';
+        this.untilVersion = null;
+        this.quorum = null;
+        this.callbacks = [];
+    }
+    /**
+     * @private
+     */
+    static async init(namespace, appId, guid, config, engine, logger) {
+        if (config.engine) {
+            const instance = new QuorumService();
+            instance.verifyQuorumFields(config);
+            instance.namespace = namespace;
+            instance.appId = appId;
+            instance.guid = guid;
+            instance.logger = logger;
+            instance.engine = engine;
+            await instance.initStoreChannel(config.engine.store);
+            await instance.initSubChannel(config.engine.sub, config.engine.pub ?? config.engine.store);
+            //general quorum subscription
+            await instance.subscribe.subscribe(hotmesh_1.KeyType.QUORUM, instance.subscriptionHandler(), appId);
+            //app-specific quorum subscription (used for pubsub one-time request/response)
+            await instance.subscribe.subscribe(hotmesh_1.KeyType.QUORUM, instance.subscriptionHandler(), appId, instance.guid);
+            instance.engine.processWebHooks();
+            instance.engine.processTimeHooks();
+            return instance;
+        }
+    }
+    /**
+     * @private
+     */
+    verifyQuorumFields(config) {
+        if (!(0, utils_1.identifyProvider)(config.engine.store) ||
+            !(0, utils_1.identifyProvider)(config.engine.sub)) {
+            throw new Error('quorum config must include `store` and `sub` fields.');
+        }
+    }
+    /**
+     * @private
+     */
+    async initStoreChannel(store) {
+        this.store = await factory_2.StoreServiceFactory.init(store, this.namespace, this.appId, this.logger);
+    }
+    /**
+     * @private
+     */
+    async initSubChannel(sub, store) {
+        this.subscribe = await factory_1.SubServiceFactory.init(sub, store, this.namespace, this.appId, this.guid, this.logger);
+    }
+    /**
+     * @private
+     */
+    subscriptionHandler() {
+        const self = this;
+        return async (topic, message) => {
+            self.logger.debug('quorum-event-received', { topic, type: message.type });
+            if (message.type === 'activate') {
+                self.engine.setCacheMode(message.cache_mode, message.until_version);
+            }
+            else if (message.type === 'ping') {
+                self.sayPong(self.appId, self.guid, message.originator, message.details);
+            }
+            else if (message.type === 'pong' && self.guid === message.originator) {
+                self.quorum = self.quorum + 1;
+                if (message.profile) {
+                    self.profiles.push(message.profile);
+                }
+            }
+            else if (message.type === 'throttle') {
+                self.engine.throttle(message.throttle);
+            }
+            else if (message.type === 'work') {
+                self.engine.processWebHooks();
+            }
+            else if (message.type === 'job') {
+                self.engine.routeToSubscribers(message.topic, message.job);
+            }
+            else if (message.type === 'cron') {
+                self.engine.processTimeHooks();
+            }
+            else if (message.type === 'rollcall') {
+                self.doRollCall(message);
+            }
+            //if there are any callbacks, call them
+            if (self.callbacks.length > 0) {
+                self.callbacks.forEach((cb) => cb(topic, message));
+            }
+        };
+    }
+    /**
+     * @private
+     */
+    async sayPong(appId, guid, originator, details = false) {
+        let profile;
+        if (details) {
+            const stream = this.engine.store.mintKey(hotmesh_1.KeyType.STREAMS, {
+                appId: this.appId,
+            });
+            profile = {
+                engine_id: this.guid,
+                namespace: this.namespace,
+                app_id: this.appId,
+                stream,
+                counts: this.engine.router.counts,
+                timestamp: (0, utils_1.formatISODate)(new Date()),
+                inited: this.engine.inited,
+                throttle: this.engine.router.throttle,
+                reclaimDelay: this.engine.router.reclaimDelay,
+                reclaimCount: this.engine.router.reclaimCount,
+                system: await (0, utils_1.getSystemHealth)(),
+            };
+        }
+        this.subscribe.publish(hotmesh_1.KeyType.QUORUM, {
+            type: 'pong',
+            guid,
+            originator,
+            profile,
+        }, appId);
+    }
+    /**
+     * A quorum-wide command to request a quorum count.
+     * @private
+     */
+    async requestQuorum(delay = enums_1.HMSH_QUORUM_DELAY_MS, details = false) {
+        const quorum = this.quorum;
+        this.quorum = 0;
+        this.profiles.length = 0;
+        await this.subscribe.publish(hotmesh_1.KeyType.QUORUM, {
+            type: 'ping',
+            originator: this.guid,
+            details,
+        }, this.appId);
+        await (0, utils_1.sleepFor)(delay);
+        return quorum;
+    }
+    /**
+     * @private
+     */
+    async doRollCall(message) {
+        let iteration = 0;
+        const max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
+        if (this.rollCallInterval)
+            clearTimeout(this.rollCallInterval);
+        const base = message.interval / 2;
+        const amount = base + Math.ceil(Math.random() * base);
+        do {
+            await (0, utils_1.sleepFor)(Math.ceil(Math.random() * 1000));
+            await this.sayPong(this.appId, this.guid, null, true);
+            if (!message.interval)
+                return;
+            const { promise, timerId } = (0, utils_1.XSleepFor)(amount * 1000);
+            this.rollCallInterval = timerId;
+            await promise;
+        } while (this.rollCallInterval && iteration++ < max - 1);
+    }
+    /**
+     * @private
+     */
+    cancelRollCall() {
+        if (this.rollCallInterval) {
+            clearTimeout(this.rollCallInterval);
+            delete this.rollCallInterval;
+        }
+    }
+    /**
+     * @private
+     */
+    stop() {
+        this.cancelRollCall();
+    }
+    /**
+     * @private
+     */
+    async pub(quorumMessage) {
+        return await this.subscribe.publish(hotmesh_1.KeyType.QUORUM, quorumMessage, this.appId, quorumMessage.topic || quorumMessage.guid);
+    }
+    /**
+     * @private
+     */
+    async sub(callback) {
+        this.callbacks.push(callback);
+    }
+    /**
+     * @private
+     */
+    async unsub(callback) {
+        this.callbacks = this.callbacks.filter((cb) => cb !== callback);
+    }
+    /**
+     * @private
+     */
+    async rollCall(delay = enums_1.HMSH_QUORUM_DELAY_MS) {
+        await this.requestQuorum(delay, true);
+        const stream_depths = await this.engine.stream.getStreamDepths(this.profiles);
+        this.profiles.forEach(async (profile, index) => {
+            //if nothing in the table, the depth will be 0
+            //todo: separate table for every worker stream?
+            profile.stream_depth = stream_depths?.[index]?.depth ?? 0;
+        });
+        return this.profiles;
+    }
+    /**
+     * @private
+     */
+    async activate(version, delay = enums_1.HMSH_QUORUM_DELAY_MS, count = 0) {
+        version = version.toString();
+        const canActivate = await this.store.reserveScoutRole('activate', Math.ceil(delay * 6 / 1000) + 1);
+        if (!canActivate) {
+            //another engine is already activating the app version
+            this.logger.debug('quorum-activation-awaiting', { version });
+            await (0, utils_1.sleepFor)(delay * 6);
+            const app = await this.store.getApp(this.appId, true);
+            return app?.active == true && app?.version === version;
+        }
+        const config = await this.engine.getVID();
+        await this.requestQuorum(delay);
+        const q1 = await this.requestQuorum(delay);
+        const q2 = await this.requestQuorum(delay);
+        const q3 = await this.requestQuorum(delay);
+        if (q1 && q1 === q2 && q2 === q3) {
+            this.logger.info('quorum-rollcall-succeeded', { q1, q2, q3 });
+            this.subscribe.publish(hotmesh_1.KeyType.QUORUM, { type: 'activate', cache_mode: 'nocache', until_version: version }, this.appId);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            await this.store.releaseScoutRole('activate');
+            //confirm we received the activation message
+            if (this.engine.untilVersion === version) {
+                this.logger.info('quorum-activation-succeeded', { version });
+                const { id } = config;
+                const compiler = new compiler_1.CompilerService(this.store, this.engine.stream, this.logger);
+                return await compiler.activate(id, version);
+            }
+            else {
+                this.logger.error('quorum-activation-error', { version });
+                throw new Error(`UntilVersion Not Received. Version ${version} not activated`);
+            }
+        }
+        else {
+            this.logger.warn('quorum-rollcall-error', { q1, q2, q3, count });
+            this.store.releaseScoutRole('activate');
+            if (count < enums_1.HMSH_ACTIVATION_MAX_RETRY) {
+                //increase the delay (give the quorum time to respond) and try again
+                return await this.activate(version, delay * 2, count + 1);
+            }
+            throw new Error(`Quorum not reached. Version ${version} not activated.`);
+        }
+    }
+}
+exports.QuorumService = QuorumService;