@blazedpath/commons 0.0.4

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@blazedpath/commons",
+  "version": "0.0.4",
+  "description": "commos library for blazedpath applications",
+  "main": "index.js",
+  "types": "dist/index.d.ts",
+  "license": "UNLICENSED",
+  "publishConfig": { "access": "public" },
+  "dependencies": {
+    "@hapi/boom": "^10.0.1",
+    "@hapi/call": "^9.0.1",
+    "@hapi/cookie": "^12.0.1",
+    "@hapi/jwt": "^3.2.0",
+    "@hapi/yar": "^11.0.3",
+    "crypto": "^1.0.1",
+    "dompurify": "^3.2.6",
+    "fs-extra": "^11.3.0",
+    "got": "^11.8.6",
+    "handlebars": "^4.7.8",
+    "jsdom": "^26.1.0",
+    "jwk-to-pem": "^2.0.7",
+    "nearley": "^2.20.1",
+    "path": "^0.12.7",
+    "semver": "^7.6.0",
+    "underscore": "^1.13.7",
+    "agenda": "^5.0.0",
+    "async-retry": "^1.3.3",
+    "@azure/msal-node": "^3.4.1",
+    "axios": "^1.12.0",
+    "clamav.js": "^0.12.0",
+    "crypto-js": "^4.2.0",
+    "decode-uri-component": "^0.4.1",
+    "h3lp": "^1.12.1",
+    "ioredis": "^5.6.0",
+    "jest": "^29.7.0",
+    "js-yaml": "^4.1.0",
+    "jsonpath": "^1.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "jwks-rsa": "^3.1.0",
+    "lru-cache": "^10.2.1",
+    "micromatch": "^4.0.8",
+    "mongodb": "^6.11.0",
+    "node-fetch": "^2.7.0",
+    "openid-client": "^5.6.4",
+    "pino": "^9.7.0",
+    "uuid": "^9.0.1",
+    "yargs": "^17.7.2",
+    "zod": "^3.25.56",
+    "dotenv": "^16.4.4",
+    "soap": "^0.45.0",
+    "generic-pool": "^3.9.0",
+    "dayjs": "^1.11.10",
+    "luxon": "^3.4.4",
+    "pg": "^8.11.3",
+    "pg-cursor": "^2.10.3",
+    "pgsql-ast-parser": "^12.0.1",
+    "sqlstring": "^2.3.3",
+    "electron-rebuild": "^3.2.9",
+    "nan": "2.18.0",
+    "oracledb": "^6.7.0",
+    "@mysql/xdevapi": "^8.0.35",
+    "mysql": "^2.18.1",
+    "named-placeholders": "^1.1.3",
+    "kafkajs": "^2.2.4",
+    "jsonschema": "^1.4.1",
+    "hazelcast-client": "^5.3.0"
+  },
+  "devDependencies": {
+    "@types/got": "9.6.12",
+    "@types/handlebars": "4.1.0",
+    "eslint": "7.32.0",
+    "eslint-config-standard": "16.0.3",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "5.2.0",
+    "@types/pg": "8.11.0",
+    "@types/underscore": "1.11.15",
+    "@types/mysql": "2.15.25",
+    "@types/node": "20.11.17",
+    "jest": "^29.7.0"
+  },
+    "bin": {
+    "blz-security": "."
+  },
+  "eslintConfig": {
+    "extends": "standard"
+  },
+  "scripts": {
+    "lint": "standard",
+    "test": "jest",
+    "postinstall": "npx electron-rebuild --version 7.1.10 -f -w oracledb"
+  },
+  "overrides": {
+    "shelljs": "0.9.2",
+    "cross-spawn": "7.0.6"
+  }
+}

package/process-managers/index.js

@@ -0,0 +1,422 @@
+const { MongoClient, ObjectId } = require('mongodb');
+let Agenda = require('agenda');
+const AsyncRetry = require('async-retry');
+const logger = require('pino')();
+
+let removeTokenAndChilds = function (instanceData, tokenId, unset) {
+    delete instanceData.tokens[tokenId];
+    unset['tokens.' + tokenId] = '';
+    for (let otherTokenId in instanceData.tokens) {
+        let otherTokenData = instanceData.tokens[otherTokenId];
+        if (otherTokenData.parentTokenId === tokenId)
+            removeTokenAndChilds(instanceData, otherTokenId, unset);
+    }
+};
+
+let getInstance = function (instanceData) {
+    let instance = {
+        processName: instanceData.processName,
+        instanceId: instanceData._id,
+        model: instanceData.model,
+        tokens: []
+    };
+    for (let tokenId in instanceData.tokens) {
+        let tokenData = instanceData.tokens[tokenId];
+        let token = {
+            tokenId: tokenId,
+            nodeName: tokenData.nodeName,
+            hasError: tokenData.hasError ?? undefined
+        };
+        if (tokenData.parentTokenId)
+            token.parentTokenId = tokenData.parentTokenId;
+        instance.tokens.push(token);
+    }
+    return instance;
+};
+
+let writeMongo = async function (processName, instanceId, variableName, value) {
+        let set = {};
+        set[variableName] = value;
+        await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $set: set });
+        return null;
+};
+
+let tokenProcessorFn = null;
+
+module.exports = {
+    setConnection: async function (connection, tokenProcessor, config) {
+        tokenProcessorFn = tokenProcessor;
+        _processorConfig = config;
+        // seccion que hace el retry
+        let mongoClient = null;
+        if (connection.useRetries){
+            await AsyncRetry(async () => {
+                mongoClient = new MongoClient(connection.url, { useUnifiedTopology: true });
+                try {
+                  await mongoClient.connect();
+                } catch (err) {
+                  console.error('Error connecting to MongoDB:', err);
+                  throw err; // This will trigger a retry
+                } finally {
+                }
+              }, {
+                retries: connection.retryCount,
+                minTimeout: connection.minRetryInterval * 1000,
+                maxTimeout: connection.maxRetryInterval * 1000,
+              });
+        } else {
+            mongoClient = new MongoClient(connection.url, { useUnifiedTopology: true });
+            await mongoClient.connect();
+        }
+
+        // termino la seccion del retry
+        let mongoDb = mongoClient.db(connection.databaseName);
+        _mongodbCollectionInstances = mongoDb.collection('blz-instances');
+        _agenda = new Agenda({ mongo: mongoDb, db: { collection: 'blz-jobs' },  name: `worker-${process.pid}` });
+        _agenda.define('start', async function (job) {
+            module.exports.start(job.attrs.data.processName, {}, job.attrs.data.startNodeName, tokenProcessor);
+            await job.remove();
+        });
+        // This is the job in charge of processing the token.
+        _agenda.define('process-token', { concurrency: 1, lockLimit: 1, lockLifetime: 120000 }, async function (job) {
+            // 🧱 Prevent double execution manually
+            if (job.attrs.data.status === 'done' || job.attrs.data.running) {
+                if (job.attrs.data.status === 'done') {
+                    logger.info(`process-token skipped: already executed for token ${tokenId}`);
+                    await job.remove(); // cleanup
+                }
+                return;
+            }
+            // 🏁 Mark it as running
+            job.attrs.data.running = true;
+            await job.save();
+
+            const { processName, instanceId, tokenId, nodeName, inboundTransaction } = job.attrs.data;
+            let instanceData = null;
+            try {
+                instanceData = await _mongodbCollectionInstances.findOne({ _id: new ObjectId(instanceId) });
+
+                if (instanceData && instanceData.tokens[tokenId]) {
+                    await tokenProcessor(processName, instanceId, tokenId, nodeName, inboundTransaction);
+                }
+
+                // 🧩 3️⃣ Mark done.
+                job.attrs.data.status = 'done';
+                job.attrs.data.running = false;
+                await job.save();
+                await job.remove();
+            } catch (err) {
+                const safeError = (err instanceof Error)
+                    ? { message: err.message ?? err.data, stack: err.stack }
+                    : { ...err };
+
+                job.attrs.failCount = (job.attrs.failCount || 0) + 1;
+
+                if (job.attrs.failCount >= _processorConfig.retriesAfterError) {
+                    logger.error({
+                        msg: 'process-token failed maximum times, disabling job',
+                        processName,
+                        instanceId,
+                        tokenId,
+                        nodeName,
+                        failCount: job.attrs.failCount,
+                        error: safeError
+                    });
+
+                    job.attrs.disabled = true;
+                    const newTokens = { ...instanceData.tokens };
+                    if (newTokens[tokenId]) {
+                        newTokens[tokenId] = { ...newTokens[tokenId], hasError: true };
+                    }
+                    await writeMongo(processName, instanceId, 'tokens', newTokens);
+                } else {
+                    const retryInMs = 5000;
+                    logger.warn({
+                        msg: `process-token failed, scheduled new retry (attempt ${job.attrs.failCount}/${_processorConfig.retriesAfterError})`,
+                        processName,
+                        instanceId,
+                        tokenId,
+                        nodeName,
+                        failCount: job.attrs.failCount,
+                        nextRetryInMs: retryInMs,
+                        error: safeError
+                    });
+
+                    job.attrs.nextRunAt = new Date(Date.now() + retryInMs);
+                }
+                job.attrs.data.running = false;
+                await job.save();
+                return;
+            }
+        });
+
+        await _agenda.start();
+    },
+    start: async function (processName, startModel, startNodeName) {
+        let mongodbInstanceId = new ObjectId();
+        let instanceId = mongodbInstanceId.toHexString();
+        let tokenId = (new ObjectId).toHexString();
+        let instanceData = {
+            _id: mongodbInstanceId,
+            processName: processName,
+            model: startModel,
+            tokens: {},
+            compensations: {}
+        };
+        instanceData.tokens[tokenId] = { nodeName: startNodeName };
+        await _mongodbCollectionInstances.insertOne(instanceData);
+        console.log('Creating job for tokenId:', tokenId);
+        // // Prevent duplicates and Do not update an existing job if it exists
+        await _agenda.now('process-token', { processName: processName, instanceId: instanceId, tokenId: tokenId, nodeName: startNodeName }, { unique: { 'data.tokenId': tokenId }, insertOnly: true });
+        return instanceId;
+    },
+    resume: async function (processName, instanceId) {
+        let mongoInstance = await module.exports.getInstance(processName, instanceId)
+        // get token/node that has the the error
+        let jobId = null;
+        for( let i = 0; i < mongoInstance.tokens.length; ++i ) {
+            const item = mongoInstance.tokens[ i ];
+            if( item.hasError )
+                jobId = mongoInstance.tokens[0].tokenId;
+        }
+        if (!jobId) {
+            logger.warn(`No bpm mongoInstance.token found with errors for mongoInstance ${instanceId}`);
+            return null;
+        }        
+        const jobs = await _agenda.jobs({ 'data.tokenId': jobId });
+        const job = jobs[0];
+        if (!job) {
+            logger.warn(`No job found with id ${jobId}`);
+            return null;
+        }
+
+        // Re-enable the job
+        job.attrs.disabled = false;
+
+        // Clear any lock or failed timestamps to allow retry
+        job.attrs.lockedAt = null;
+        job.attrs.lastFinishedAt = null;
+        job.attrs.failedAt = null;
+        job.attrs.failReason = null;
+
+        // Save the updated job
+        await job.save();
+        // Reschedule or immediately run
+        await job.run();
+
+        logger.info(`BPM instance: ${instanceId} has been re-enabled, and is attempting to run again.`);
+        return null;
+    },
+    killAgendaJob: async function (agenda, jobId, options = {}) {
+
+    },
+    scheduleStart: async function (processName, startNodeName, datetime) {
+        let now = new Date(Date.now());
+        now = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), now.getUTCHours(), now.getUTCMinutes(), now.getUTCSeconds(), now.getUTCMilliseconds()));
+        await _agenda.schedule(datetime, 'start', { processName: processName, startNodeName: startNodeName });
+    },
+    killInstance: async function (processName, instanceId, instanceFinisher) {
+        await _mongodbCollectionInstances.deleteOne({ _id: { $eq: ObjectId(instanceId) } });
+        instanceFinisher(processName);
+    },
+    createToken: async function (processName, instanceId, nodeName, parentTokenId) {
+        let tokenId = (new ObjectId()).toHexString();
+        let tokenData = { nodeName: nodeName };
+        if (parentTokenId)
+            tokenData.parentTokenId = parentTokenId;
+        let set = {};
+        set['tokens.' + tokenId] = tokenData;
+        await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $set: set });
+        await _agenda.now('process-token', { processName: processName, instanceId: instanceId, tokenId: tokenId, nodeName: nodeName });
+    },
+    moveToken: async function (processName, instanceId, tokenId, targets, newGatewayNumber, tokenProcessor) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let tokenData = instanceData.tokens[tokenId];
+        if (tokenData) {
+            let parentTokenId = tokenData.parentTokenId;
+            let gatewayNumbers = tokenData.gatewayNumbers;
+            let unset = {};
+            let set = {};
+            removeTokenAndChilds(instanceData, tokenId, unset);
+            await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $unset: unset });
+            instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+            for (let i = 0; i < targets.length; i++) {
+                let target = targets[i];
+                let pass = true;
+                if (target.filterGatewayNumber) {
+                    for (let otherTokenId in instanceData.tokens) {
+                        let otherTokenData = instanceData.tokens[otherTokenId];
+                        if (otherTokenData.gatewayNumbers && otherTokenData.gatewayNumbers.indexOf(target.filterGatewayNumber) !== -1)
+                            pass = false;
+                    }
+                }
+                if (pass) {
+                    target.newTokenId = (new ObjectId()).toHexString();
+                    target.newTokenData = {nodeName: target.nodeName};
+                    if (parentTokenId)
+                        target.newTokenData.parentTokenId = parentTokenId;
+                    if (gatewayNumbers || newGatewayNumber) {
+                        target.newTokenData.gatewayNumbers = [];
+                        if (gatewayNumbers) {
+                            for (let j = 0; j < gatewayNumbers.length; j++) {
+                                let gatewayNumber = gatewayNumbers[j];
+                                if (gatewayNumber !== target.filterGatewayNumber)
+                                    target.newTokenData.gatewayNumbers.push(gatewayNumber);
+                            }
+                        }
+                        if (newGatewayNumber) {
+                            target.newTokenData.gatewayNumbers.push(newGatewayNumber);
+                        }
+                    }
+                    if (target.waitMessages)
+                        target.newTokenData.waitMessages = target.waitMessages;
+                    if (target.waitSignals)
+                        target.newTokenData.waitSignals = target.waitSignals;
+                    set['tokens.' + target.newTokenId] = target.newTokenData;
+                }
+            }
+            if (Object.keys(set).length === 0)
+                await _mongodbCollectionInstances.updateOne({_id: {$eq: ObjectId(instanceId)}}, { $unset: unset });
+            else
+                await _mongodbCollectionInstances.updateOne({_id: {$eq: ObjectId(instanceId)}}, { $unset: unset, $set: set });
+            for (let i = 0; i < targets.length; i++) {
+                let target = targets[i];
+                if (target.newTokenId) {
+                    if (target.immediateNodeName) {
+                        if (target.immediateSchedule) {
+                            await _agenda.now('process-token', { processName: processName, instanceId: instanceId, tokenId: target.newTokenId, nodeName: target.immediateNodeName, inboundTransaction: target.inbound });
+                        }
+                        else {
+                            await tokenProcessor(processName, instanceId, target.newTokenId, target.immediateNodeName, target.inbound);
+                        }
+                    }
+                    if (target.waitTimers) {
+                        for (let j = 0; j < target.waitTimers.length; j++) {
+                            let waitTimer = target.waitTimers[j];
+                            await _agenda.schedule(waitTimer.datetime, 'process-token', { processName: processName, instanceId: instanceId, tokenId: target.newTokenId, nodeName: waitTimer.nodeName, inboundTransaction: target.inbound });
+                        }
+                    }
+                }
+            }
+        }
+    },
+    killToken: async function (processName, instanceId, tokenId, subProcessFinisher, instanceFinisher, err) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let tokenData = instanceData.tokens[tokenId];
+        if (tokenData) {
+            let parentTokenId = tokenData.parentTokenId;
+            let unset = {};
+            removeTokenAndChilds(instanceData, tokenId, unset);
+            if (err) {
+                for (let otherTokenId in instanceData.tokens) {
+                    let otherTokenData = instanceData.tokens[otherTokenId];
+                    if (otherTokenData.parentTokenId === parentTokenId)
+                        removeTokenAndChilds(instanceData, otherTokenId, unset);
+                }
+            }
+            if (Object.keys(instanceData.tokens).length === 0) {
+                await _mongodbCollectionInstances.deleteOne({ _id: { $eq: ObjectId(instanceId) } });
+                instanceFinisher(processName, err);
+            }
+            else {
+                await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $unset: unset });
+                if (parentTokenId) {
+                    let subProcessFinished = true;
+                    for (let otherTokenId in instanceData.tokens) {
+                        let otherTokenData = instanceData.tokens[otherTokenId];
+                        if (otherTokenData.parentTokenId === parentTokenId)
+                            subProcessFinished = false;
+                    }
+                    if (subProcessFinished)
+                        subProcessFinisher(processName, instanceId, parentTokenId, err);
+                }
+            }
+        }
+    },
+    readModel: async function (processName, instanceId, variableName) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        if (instanceData) {
+            if (variableName === null || variableName === undefined)
+                return instanceData.model;
+            else
+                return instanceData.model[variableName];
+        }
+        return null;
+    },
+    writeModel: async function (processName, instanceId, variableName, value) {
+        let set = {};
+        set['model.' + variableName] = value;
+        await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $set: set });
+        return null;
+    },
+    getNodeName: async function (processName, instanceId, tokenId) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let nodeName = null;
+        if (instanceData) {
+            let tokenData = instanceData.tokens[tokenId];
+            if (tokenData)
+                nodeName = tokenData.nodeName;
+        }
+        return nodeName;
+    },
+    getReceivers: async function (processName, instanceId, messageKey, signalName) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let receivers = [];
+        if (instanceData) {
+            for (let tokenId in instanceData.tokens) {
+                let tokenData = instanceData.tokens[tokenId];
+                if (tokenData.waitMessages) {
+                    for (let i = 0; i < tokenData.waitMessages.length; i++) {
+                        let waitMessage = tokenData.waitMessages[i];
+                        if (waitMessage.messageKey === messageKey)
+                            receivers.push({ tokenId: tokenId, nodeName: waitMessage.nodeName });
+                    }
+                }
+                if (tokenData.waitSignals) {
+                    for (let i = 0; i < tokenData.waitSignals.length; i++) {
+                        let waitSignal = tokenData.waitSignals[i];
+                        if (waitSignal.signalName === signalName)
+                            receivers.push({ tokenId: tokenId, nodeName: waitSignal.nodeName });
+                    }
+                }
+            }
+        }
+        return receivers;
+    },
+    enqueueCompensation: async function (processName, instanceId, compensationKey, nodeName) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let compensations = instanceData.compensations[compensationKey];
+        if (compensations === null || compensations === undefined) {
+            compensations = [];
+            instanceData.compensations[compensationKey] = compensations;
+        }
+        compensations.push({ nodeName: nodeName, model: JSON.parse(JSON.stringify(instanceData.model)) });
+        let set = {};
+        set['compensations.' + compensationKey] = compensations;
+        await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $set: set });
+    },
+    compensate: async function (processName, instanceId, compensationKey, instanceCompensator) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let compensations = instanceData.compensations[compensationKey];
+        if (compensations) {
+            while (compensations.length > 0) {
+                let compensation = compensations.pop();
+                instanceCompensator(processName, instanceId, compensationKey, compensation.nodeName, compensation.model);
+            }
+        }
+        let set = {};
+        set['compensations.' + compensationKey] = [];
+        await _mongodbCollectionInstances.updateOne({ _id: { $eq: ObjectId(instanceId) } }, { $set: set });
+    },
+    listInstances: async function (processName, offset, limit) {
+        var mongodbCursor = await _mongodbCollectionInstances.find({ processName: { $eq: processName } }, { skip: offset, limit: limit });
+        return await mongodbCursor.map(function (instanceData) { return getInstance(instanceData); }).toArray();
+    },
+    getInstance: async function (processName, instanceId) {
+        var instanceData = await _mongodbCollectionInstances.findOne({ _id: { $eq: ObjectId(instanceId) } });
+        let instance = null;
+        if (instanceData)
+            instance = getInstance(instanceData);
+        return instance;
+    }
+};