@hotmeshio/hotmesh 0.3.32 → 0.4.1

package/build/services/collator/index.js

@@ -1 +1,293 @@
-'use strict';const r=b;(function(c,d){const q=b,e=c();while(!![]){try{const f=parseInt(q(0x1ab))/0x1*(-parseInt(q(0x190))/0x2)+-parseInt(q(0x18a))/0x3*(parseInt(q(0x165))/0x4)+-parseInt(q(0x172))/0x5*(parseInt(q(0x196))/0x6)+-parseInt(q(0x1a6))/0x7*(parseInt(q(0x1a5))/0x8)+parseInt(q(0x1a1))/0x9+parseInt(q(0x184))/0xa*(parseInt(q(0x1a4))/0xb)+parseInt(q(0x1ad))/0xc;if(f===d)break;else e['push'](e['shift']());}catch(g){e['push'](e['shift']());}}}(a,0x46bc1));function a(){const R=['config','../../types/collator','isInactive','129130kRZAyd','resolveReentryDimension','notarizeEarlyExit','verifyInteger','888000001000001','MISSING','51LdOVmm','targetLength','lastIndexOf','forEach','getDimensionalAddress','INACTIVE','43182rODIBr','jid','transitions','collateSynthetic','store','notarizeReentry','6qoQBJC','aid','authorizeReentry','CollationFaultType','isArray','CollationError','exec','trigger','FORBIDDEN','enter','bindAncestorArray','3164769LUtYwB','indexOf','type','418CPAahH','8kvfMLK','3589691zsZWPY','notarizeEntry','substring','cycle','__esModule','15QIWKyJ','ancestors','5185020NWPOdz','length','getDimensionsById','context','isPrimed','DUPLICATE','27512eWnbRV','join','find','push','999000000000000','isDuplicate','getDigitAtIndex','notarizeContinuation','collator-trigger-activity-not-found','dad','getSeed','getDimensionalIndex','reverse','155435gdwctj','notarizeInception','getTriggerSeed','CollatorService','metadata','split','getDimensionalSeed','toString','leg','verifySyntheticInteger','activities','notarizeEarlyCompletion','defineProperty','collate','ancestor'];a=function(){return R;};return a();}Object[r(0x17e)](exports,r(0x1aa),{'value':!0x0}),exports[r(0x175)]=void 0x0;const errors_1=require('../../modules/errors'),collator_1=require(r(0x182));function b(c,d){const e=a();return b=function(f,g){f=f-0x163;let h=e[f];return h;},b(c,d);}class CollatorService{static['assertJobActive'](c,d,f,g=0x0){if(c<=g)throw new errors_1['InactiveJobError'](d,c,f);}static[r(0x18e)](c,d=!0x1){const s=r;let f=c[s(0x1b0)][s(0x176)][s(0x16e)]||c['metadata'][s(0x16e)];return d&&f&&0x2===c[s(0x17a)]&&(f=f[s(0x1a8)](0x0,f[s(0x18c)](','))+',0'),CollatorService[s(0x1af)]([...c[s(0x181)]['ancestors'],c[s(0x176)]['aid']],f);}static[r(0x185)](c){const t=r,d=c['config'][t(0x180)],f=c[t(0x181)][t(0x1ac)][t(0x1a2)](d),g=c[t(0x176)][t(0x16e)][t(0x177)](',');return g[t(0x1ae)]=f+0x1,g[t(0x168)]('0'),g[t(0x166)](',');}static async[r(0x1a7)](c,d){const u=r,f=await c['store'][u(0x17f)](c[u(0x1b0)][u(0x176)]['jid'],c['metadata'][u(0x197)],-0x5af3107a4000,this['getDimensionalAddress'](c),d);return this[u(0x187)](f,0x1,'enter'),f;}static async[r(0x198)](c,d){const v=r;return await c['store'][v(0x17f)](c[v(0x1b0)][v(0x176)][v(0x191)],c['metadata'][v(0x197)],-0x9184e72a000,this[v(0x18e)](c),d);}static async[r(0x186)](c,d){const w=r;return await c[w(0x194)]['collate'](c[w(0x1b0)][w(0x176)][w(0x191)],c['metadata'][w(0x197)],-0xa012317b000,this[w(0x18e)](c),d);}static async[r(0x17d)](c,d){const x=r,f=c[x(0x181)][x(0x1a9)]?0x9184e72a000:0xa012317b000;return await c[x(0x194)][x(0x17f)](c[x(0x1b0)][x(0x176)][x(0x191)],c[x(0x176)][x(0x197)],0xf4241-f,this[x(0x18e)](c),d);}static async[r(0x173)](c,d,f){const y=r;d&&await c['store'][y(0x193)](c[y(0x1b0)][y(0x176)][y(0x191)],d,0xf4240,f);}static async['isInceptionOverage'](c,d){const z=r;if(d)return await c[z(0x194)][z(0x193)](c[z(0x1b0)][z(0x176)][z(0x191)],d,0xf4240)>0xf4240;return!0x1;}static async[r(0x195)](c,d,f){const A=r,g=c[A(0x1b0)]['metadata'][A(0x191)],h=f||c[A(0x194)]['transact']();await c[A(0x194)][A(0x17f)](g,c['metadata'][A(0x197)],0xf4240,this['getDimensionalAddress'](c,!0x0),h),await c[A(0x194)][A(0x193)](g,d,0xf4240,h);const [j,k]=await h[A(0x19c)](),m=Array[A(0x19a)](j)?j[0x1]:j,p=Array[A(0x19a)](k)?k[0x1]:k;return this[A(0x187)](m,0x2,A(0x19f)),this[A(0x17b)](p),m;}static async[r(0x16c)](c,d){const B=r;return await c['store'][B(0x17f)](c[B(0x1b0)][B(0x176)]['jid'],c[B(0x176)]['aid'],0x1,this[B(0x18e)](c),d);}static async['notarizeCompletion'](c,d){const C=r,f=c[C(0x181)][C(0x1a9)]?0x0:0xe8d4a51000;return await c['store'][C(0x17f)](c['context'][C(0x176)][C(0x191)],c['metadata'][C(0x197)],0x1-f,this[C(0x18e)](c),d);}static['getDigitAtIndex'](c,d){const D=r,f=c[D(0x179)]();if(d<0x0||d>=f[D(0x1ae)])return null;return parseInt(f[d],0xa);}static[r(0x170)](c){const E=r,d=c[E(0x179)]();if(d['length']<0x9)return null;const f=d['substring'](0x3,0x9);return parseInt(f,0xa)-0x1;}static['isDuplicate'](c,d){const F=r;return this[F(0x16b)](c,d)<0x8;}static[r(0x183)](c){const G=r;return this[G(0x16b)](c,0x2)<0x9;}static['isPrimed'](c,d){return 0x1==d?-0x5af3107a4000!=c:this['getDigitAtIndex'](c,0x0)<0x9&&this['getDigitAtIndex'](c,0x1)<0x9;}static[r(0x17b)](c){const H=r,d=c[H(0x179)]();if(parseInt(d[d['length']-0x1],0xa)>0x0)throw new errors_1['CollationError'](c,0x2,'enter',collator_1[H(0x199)]['INACTIVE']);if(c>=0x1e8480)throw new errors_1[(H(0x19b))](c,0x2,H(0x19f),collator_1[H(0x199)][H(0x164)]);}static[r(0x187)](c,d,f){const I=r;let g;if(0x1===d&&I(0x19f)===f?this[I(0x163)](c,0x1)?this[I(0x16a)](c,0x0)?g=collator_1[I(0x199)][I(0x164)]:0x331a2bfa73000!=c&&(g=collator_1['CollationFaultType']['INVALID']):g=collator_1[I(0x199)][I(0x189)]:0x1===d&&'exit'===f?-0x9184e72a000===c?g=collator_1[I(0x199)]['MISSING']:this[I(0x16a)](c,0x1)&&(g=collator_1[I(0x199)][I(0x164)]):0x2===d&&'enter'===f&&(this[I(0x163)](c,0x2)?this[I(0x183)](c)&&(g=collator_1[I(0x199)][I(0x18f)]):g=collator_1[I(0x199)][I(0x19e)]),g)throw new errors_1['CollationError'](c,d,f,g);}static[r(0x1af)](c,d){const J=r,f={'$ADJACENT':d+',0'};let g=d;return c[J(0x171)]()[J(0x18d)](h=>{const K=J;f[h]=g,g=g[K(0x1a8)](0x0,g[K(0x18c)](','));}),f;}static[r(0x16f)](){const L=r;return L(0x169);}static[r(0x174)](){const M=r;return M(0x188);}static['compile'](c){const N=r;CollatorService[N(0x1a0)](c);}static[r(0x1a0)](c){const O=r;c[O(0x18d)](d=>{const P=O,f={},g=Object['keys'](d[P(0x17c)])[P(0x167)](j=>P(0x19d)===d['activities'][j][P(0x1a3)]);if(!g)throw new Error(P(0x16d));const h=(j,k)=>{const Q=P;f[j]=k,d[Q(0x17c)][j][Q(0x1ac)]=k,(d[Q(0x192)]?.[j]||[])['forEach'](l=>{h(l['to'],[...k,j]);});};h(g,[]);});}static[r(0x178)](c=0x0){return','+c;}}exports[r(0x175)]=CollatorService,CollatorService[r(0x18b)]=0xf;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollatorService = void 0;
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../../types/collator");
+class CollatorService {
+    /**
+     * Upon re/entry, verify that the job status is active
+     */
+    static assertJobActive(status, jobId, activityId, threshold = 0) {
+        if (status <= threshold) {
+            throw new errors_1.InactiveJobError(jobId, status, activityId);
+        }
+    }
+    /**
+     * returns the dimensional address (dad) for the target; due
+     * to the nature of the notary system, the dad for leg 2 entry
+     * must target the `0` index while leg 2 exit must target the
+     * current index (0)
+     */
+    static getDimensionalAddress(activity, isEntry = false) {
+        let dad = activity.context.metadata.dad || activity.metadata.dad;
+        if (isEntry && dad && activity.leg === 2) {
+            dad = `${dad.substring(0, dad.lastIndexOf(','))},0`;
+        }
+        return CollatorService.getDimensionsById([...activity.config.ancestors, activity.metadata.aid], dad);
+    }
+    /**
+     * resolves the dimensional address for the
+     * ancestor in the graph to go back to. this address
+     * is determined by trimming the last digits from
+     * the `dad` (including the target).
+     * the target activity index is then set to `0`, so that
+     * the origin node can be queried for approval/entry.
+     */
+    static resolveReentryDimension(activity) {
+        const targetActivityId = activity.config.ancestor;
+        const ancestors = activity.config.ancestors;
+        const ancestorIndex = ancestors.indexOf(targetActivityId);
+        const dimensions = activity.metadata.dad.split(','); //e.g., `,0,0,1,0`
+        dimensions.length = ancestorIndex + 1;
+        dimensions.push('0');
+        return dimensions.join(',');
+    }
+    static async notarizeEntry(activity, transaction) {
+        //decrement by -100_000_000_000_000
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -100000000000000, this.getDimensionalAddress(activity), transaction);
+        this.verifyInteger(amount, 1, 'enter');
+        return amount;
+    }
+    static async authorizeReentry(activity, transaction) {
+        //set second digit to 8, allowing for re-entry
+        //decrement by -10_000_000_000_000
+        const amount = await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -10000000000000, this.getDimensionalAddress(activity), transaction);
+        return amount;
+    }
+    static async notarizeEarlyExit(activity, transaction) {
+        //decrement the 2nd and 3rd digits to fully deactivate (`cycle` activities use this command to fully exit after leg 1) (should result in `888000000000000`)
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, -11000000000000, this.getDimensionalAddress(activity), transaction);
+    }
+    static async notarizeEarlyCompletion(activity, transaction) {
+        //initialize both `possible` (1m) and `actualized` (1) zero dimension, while decrementing the 2nd
+        //3rd digit is optionally kept open if the activity might be used in a cycle
+        const decrement = activity.config.cycle
+            ? 10000000000000
+            : 11000000000000;
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1000001 - decrement, this.getDimensionalAddress(activity), transaction);
+    }
+    /**
+     * sets the synthetic inception key (in case of an overage occurs).
+     */
+    static async notarizeInception(activity, guid, transaction) {
+        if (guid) {
+            await activity.store.collateSynthetic(activity.context.metadata.jid, guid, 1000000, transaction);
+        }
+    }
+    /**
+     * ignore those ID collisions that are due to re-entry overages
+     */
+    static async isInceptionOverage(activity, guid) {
+        if (guid) {
+            const amount = await activity.store.collateSynthetic(activity.context.metadata.jid, guid, 1000000);
+            return amount > 1000000;
+        }
+        return false;
+    }
+    /**
+     * verifies both the concrete and synthetic keys for the activity; concrete keys
+     * exist in the original model and are effectively the 'real' keys. In reality,
+     * hook activities are atomized during compilation to create a synthetic DAG that
+     * is used to track the status of the graph in a distributed environment. The
+     * synthetic key represents different dimensional realities and is used to
+     * track re-entry overages (it distinguishes between the original and re-entry).
+     * The essential challenge is: is this a re-entry that is purposeful in
+     * order to induce cycles, or is the re-entry due to a failure in the system?
+     */
+    static async notarizeReentry(activity, guid, transaction) {
+        const jid = activity.context.metadata.jid;
+        const localMulti = transaction || activity.store.transact();
+        //increment by 1_000_000 (indicates re-entry and is used to drive the 'dimensional address' for adjacent activities (minus 1))
+        await activity.store.collate(jid, activity.metadata.aid, 1000000, this.getDimensionalAddress(activity, true), localMulti);
+        await activity.store.collateSynthetic(jid, guid, 1000000, localMulti);
+        const [_amountConcrete, _amountSynthetic] = await localMulti.exec();
+        const amountConcrete = Array.isArray(_amountConcrete)
+            ? _amountConcrete[1]
+            : _amountConcrete;
+        const amountSynthetic = Array.isArray(_amountSynthetic)
+            ? _amountSynthetic[1]
+            : _amountSynthetic;
+        this.verifyInteger(amountConcrete, 2, 'enter');
+        this.verifySyntheticInteger(amountSynthetic);
+        return amountConcrete;
+    }
+    static async notarizeContinuation(activity, transaction) {
+        //keep open; actualize the leg2 dimension (+1)
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1, this.getDimensionalAddress(activity), transaction);
+    }
+    static async notarizeCompletion(activity, transaction) {
+        //1) ALWAYS actualize leg2 dimension (+1)
+        //2) IF the activity is used in a cycle, don't close leg 2!
+        const decrement = activity.config.cycle ? 0 : 1000000000000;
+        return await activity.store.collate(activity.context.metadata.jid, activity.metadata.aid, 1 - decrement, this.getDimensionalAddress(activity), transaction);
+    }
+    static getDigitAtIndex(num, targetDigitIndex) {
+        const numStr = num.toString();
+        if (targetDigitIndex < 0 || targetDigitIndex >= numStr.length) {
+            return null;
+        }
+        const digit = parseInt(numStr[targetDigitIndex], 10);
+        return digit;
+    }
+    static getDimensionalIndex(num) {
+        const numStr = num.toString();
+        if (numStr.length < 9) {
+            return null;
+        }
+        const extractedStr = numStr.substring(3, 9);
+        const extractedInt = parseInt(extractedStr, 10);
+        return extractedInt - 1;
+    }
+    static isDuplicate(num, targetDigitIndex) {
+        return this.getDigitAtIndex(num, targetDigitIndex) < 8;
+    }
+    static isInactive(num) {
+        return this.getDigitAtIndex(num, 2) < 9;
+    }
+    static isPrimed(amount, leg) {
+        //activity entry is not allowed if paths not properly pre-set
+        if (leg == 1) {
+            return amount != -100000000000000;
+        }
+        else {
+            return (this.getDigitAtIndex(amount, 0) < 9 &&
+                this.getDigitAtIndex(amount, 1) < 9);
+        }
+    }
+    /**
+     * During compilation, the graphs are compiled into structures necessary
+     * for distributed processing; these are referred to as 'synthetic DAGs',
+     * because they are not part of the original graph, but are used to track
+     * the status of the graph in a distributed environment. This check ensures
+     * that the 'synthetic key' is not a duplicate. (which is different than
+     * saying the 'key' is not a duplicate)
+     */
+    static verifySyntheticInteger(amount) {
+        const samount = amount.toString();
+        const isCompletedValue = parseInt(samount[samount.length - 1], 10);
+        if (isCompletedValue > 0) {
+            //already done error (ack/delete clearly failed; this is a duplicate)
+            throw new errors_1.CollationError(amount, 2, 'enter', collator_1.CollationFaultType.INACTIVE);
+        }
+        else if (amount >= 2000000) {
+            //duplicate synthetic key (this is a duplicate job ID)
+            throw new errors_1.CollationError(amount, 2, 'enter', collator_1.CollationFaultType.DUPLICATE);
+        }
+    }
+    static verifyInteger(amount, leg, stage) {
+        let faultType;
+        if (leg === 1 && stage === 'enter') {
+            if (!this.isPrimed(amount, 1)) {
+                faultType = collator_1.CollationFaultType.MISSING;
+            }
+            else if (this.isDuplicate(amount, 0)) {
+                faultType = collator_1.CollationFaultType.DUPLICATE;
+            }
+            else if (amount != 899000000000000) {
+                faultType = collator_1.CollationFaultType.INVALID;
+            }
+        }
+        else if (leg === 1 && stage === 'exit') {
+            if (amount === -10000000000000) {
+                faultType = collator_1.CollationFaultType.MISSING;
+            }
+            else if (this.isDuplicate(amount, 1)) {
+                faultType = collator_1.CollationFaultType.DUPLICATE;
+            }
+        }
+        else if (leg === 2 && stage === 'enter') {
+            if (!this.isPrimed(amount, 2)) {
+                faultType = collator_1.CollationFaultType.FORBIDDEN;
+            }
+            else if (this.isInactive(amount)) {
+                faultType = collator_1.CollationFaultType.INACTIVE;
+            }
+        }
+        if (faultType) {
+            throw new errors_1.CollationError(amount, leg, stage, faultType);
+        }
+    }
+    static getDimensionsById(ancestors, dad) {
+        //ancestors is an ordered list of all ancestors, starting with the trigger (['t1', 'a1', 'a2'])
+        //dad is the dimensional address of the ancestors list (',0,5,3')
+        //loop through the ancestors list and create a map of the ancestor to the dimensional address.
+        //return { 't1': ',0', 'a1': ',0,5', 'a1': ',0,5,3', $ADJACENT: ',0,5,3,0' };
+        // `adjacent` is a special key that is used to track the dimensional address of adjacent activities
+        const map = { $ADJACENT: `${dad},0` };
+        let dadStr = dad;
+        ancestors.reverse().forEach((ancestor) => {
+            map[ancestor] = dadStr;
+            dadStr = dadStr.substring(0, dadStr.lastIndexOf(','));
+        });
+        return map;
+    }
+    /**
+     * All non-trigger activities are assigned a status seed by their parent
+     */
+    static getSeed() {
+        return '999000000000000';
+    }
+    /**
+     * All trigger activities are assigned a status seed in a completed state
+     */
+    static getTriggerSeed() {
+        return '888000001000001';
+    }
+    /**
+     * entry point for compiler-type activities. This is called by the compiler
+     * to bind the sorted activity IDs to the trigger activity. These are then used
+     * at runtime by the activities to track job/activity status.
+     * @param graphs
+     */
+    static compile(graphs) {
+        CollatorService.bindAncestorArray(graphs);
+    }
+    /**
+     * binds the ancestor array to each activity.
+     * Used in conjunction with the dimensional
+     *  address (dad). If dad is `,0,1,0,0` and the
+     * ancestor array is `['t1', 'a1', 'a2']` for
+     * activity 'a3', then the SAVED DAD
+     * will always have the trailing
+     * 0's removed. This ensures that the addressing
+     * remains consistent even if the graph changes.
+     *   id    DAD           SAVED DAD
+     * * t1 => ,0        =>  [empty]
+     * * a1 => ,0,1      =>  ,0,1
+     * * a2 => ,0,1,0    =>  ,0,1
+     * * a3 => ,0,1,0,0  =>  ,0,1
+     *
+     */
+    static bindAncestorArray(graphs) {
+        graphs.forEach((graph) => {
+            const ancestors = {};
+            const startingNode = Object.keys(graph.activities).find((activity) => graph.activities[activity].type === 'trigger');
+            if (!startingNode) {
+                throw new Error('collator-trigger-activity-not-found');
+            }
+            const dfs = (node, parentList) => {
+                ancestors[node] = parentList;
+                graph.activities[node]['ancestors'] = parentList;
+                const transitions = graph.transitions?.[node] || [];
+                transitions.forEach((transition) => {
+                    dfs(transition.to, [...parentList, node]);
+                });
+            };
+            // Start the DFS traversal
+            dfs(startingNode, []);
+        });
+    }
+    /**
+     * All activities exist on a dimensional plane. Zero
+     * is the default. A value of
+     * `AxY,0,0,0,0,1,0,0` would reflect that
+     * an ancestor activity was dimensionalized beyond
+     * the default.
+     */
+    static getDimensionalSeed(index = 0) {
+        return `,${index}`;
+    }
+}
+exports.CollatorService = CollatorService;
+//max int digit count that supports `hincrby`
+CollatorService.targetLength = 15;