@blazedpath/commons 0.2.1 → 0.3.1

package/process-managers/index.js

@@ -1,422 +0,0 @@
-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;
-    }
-};