@blazedpath/commons 0.3.1 → 0.4.0

package/package.json

@@ -1,91 +1,84 @@
 {
   "name": "@blazedpath/commons",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "commos library for blazedpath applications",
-  "main": "dist/index.js",
-  "files": [
-    "dist"
-  ],
+  "main": "index.js",
   "types": "dist/index.d.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@azure/msal-node": "^3.4.1",
     "@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",
-    "@mysql/xdevapi": "^8.0.35",
+    "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": "^1.0.1",
     "crypto-js": "^4.2.0",
-    "dayjs": "^1.11.10",
     "decode-uri-component": "^0.4.1",
-    "dompurify": "^3.2.6",
-    "dotenv": "^16.4.4",
-    "electron-rebuild": "^3.2.9",
-    "fs-extra": "^11.3.0",
-    "generic-pool": "^3.9.0",
-    "got": "^11.8.6",
     "h3lp": "^1.12.1",
-    "handlebars": "^4.7.8",
-    "hazelcast-client": "^5.3.0",
     "ioredis": "^5.6.0",
     "jest": "^29.7.0",
     "js-yaml": "^4.1.0",
-    "jsdom": "^26.1.0",
     "jsonpath": "^1.1.1",
-    "jsonschema": "^1.4.1",
     "jsonwebtoken": "^9.0.2",
-    "jwk-to-pem": "^2.0.7",
     "jwks-rsa": "^3.1.0",
-    "kafkajs": "^2.2.4",
     "lru-cache": "^10.2.1",
-    "luxon": "^3.4.4",
     "micromatch": "^4.0.8",
     "mongodb": "^4.17.2",
-    "mysql": "^2.18.1",
-    "named-placeholders": "^1.1.3",
-    "nan": "2.18.0",
-    "nearley": "^2.20.1",
     "node-fetch": "^2.7.0",
     "openid-client": "^5.6.4",
-    "oracledb": "^6.7.0",
-    "path": "^0.12.7",
+    "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",
-    "pino": "^9.7.0",
-    "semver": "^7.6.0",
-    "soap": "^0.45.0",
     "sqlstring": "^2.3.3",
-    "underscore": "^1.13.7",
-    "uuid": "^9.0.1",
-    "yargs": "^17.7.2",
-    "zod": "^3.25.56"
+    "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",
-    "@types/mysql": "2.15.25",
-    "@types/node": "20.11.17",
-    "@types/pg": "8.11.0",
-    "@types/underscore": "1.11.15",
-    "esbuild": "^0.27.2",
     "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",
-    "rimraf": "^6.1.2",
-    "terser": "^5.46.0",
-    "typescript": "^5.9.3"
+    "@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": "."
@@ -95,19 +88,13 @@
   },
   "scripts": {
     "lint": "standard",
-    "test": "jest",
-    "postinstall": "npx electron-rebuild --version 7.1.10 -f -w oracledb",
-    "clean": "rimraf dist",
-    "build:js": "node scripts/build-js.cjs",
-    "build:types": "tsc -p tsconfig.types.json",
-    "build": "npm run clean && npm run build:js && npm run build:types",
-    "prepublishOnly": "npm run build"
+    "test": "jest"    
   },
   "overrides": {
     "shelljs": "0.9.2",
     "cross-spawn": "7.0.6",
     "glob": "^12.0.0",
-    "qs": "^6.14.1",
-    "jws": "^4.0.1"
+     "qs": "^6.14.1",
+      "jws": "^4.0.1"
   }
-}
+}

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;
+    }
+};

package/dist/blz-base/health/index.d.ts

@@ -1 +0,0 @@
-export function getHealthStatus(_buildSystem: any, _connections: any): Promise<{}>;

package/dist/blz-base/health/index.js

@@ -1 +0,0 @@
-const fetch=require("node-fetch"),logger=require("pino")(),safeRequire=function(e){try{return require.resolve(e),require(e)}catch(t){if("MODULE_NOT_FOUND"===t.code){let t=e.replace(/^\.\.\//,"");return e!==t?safeRequire(t):void 0}throw t}},mongoDb=safeRequire("../../../essentials/extensions/blz-mongodb/sources-backend-nodejs/index.js")||safeRequire("../../blz-mongodb/backend/index.js"),kafka=safeRequire("../../../essentials/extensions/blz-kafka/sources-backend-nodejs/index.js")||safeRequire("../../blz-kafka/backend/index.js"),rds=safeRequire("../../../essentials/extensions/blz-rds/sources-backend-nodejs/index.js")||safeRequire("../../blz-rds/backend/index.js");async function healthCheckMicroservice(e){let t={};const a=e.healthCheckPath?new URL(healthCheckPath.healthCheckPath,e.url).toString():new URL("/blz-health-status",e.url).toString();try{const n=await fetch(a);if(n.ok){const a=await n.json();t={name:e.name,type:e.type,status:n.status,statusCode:n.statusCode,error:"-",internal:a}}else t={name:e.name,type:e.type,status:"error",error:`HTTP Error: ${n.statusText}`}}catch(a){t={name:e.name,type:e.type,status:"error",error:a.message}}return t}async function healthCheckAllPossibleUrl(e){let t=["/blz-health-status","/health","/actuator/health","/"];e.healthCheckPath&&t.unshift(e.healthCheckPath);for(const a of t){const t=new URL(a,e.url).toString();try{const e=await fetch(t);if(e.ok&&"/blz-health-status"===a){const a=await e.json();return{status:e.status,url:t,data:a}}if(e.ok&&"/health"===a)return{status:e.status,url:t,data:"Connected with /Health API. httpCode 200."};if(e.ok)return{status:e.status,url:t,data:"Connected with standard Http code 200 protocol. Endpoint: "+a}}catch(e){logger.info(e)}}return{status:"error",message:"No valid health check endpoint found"}}async function getHealthStatus(e,t){let a=e.name,n=e.type,s={};s[a]={name:a,type:"Self",status:"ok",error:"-"};const r=[];for(const e in t)if(Object.prototype.hasOwnProperty.call(t,e)){const s=t[e];if(s.name!==a){const e=(async()=>{switch(s.type){case"Microservice":case"ProcessEngine":return{name:s.name,result:await healthCheckMicroservice(s)};case"RestApi":return{name:s.name,result:await healthCheckAllPossibleUrl(s)};case"Mongodb":{if(!mongoDb)return{name:s.name,type:s.type,result:{name:s.name,type:s.type,error:"mongoDb module not present"}};const e=await mongoDb.mongodbConnectionHealthCheck(s);return{name:s.name,result:{name:s.name,type:s.type,...e}}}case"Kafka":{if(!kafka)return{name:s.name,type:s.type,error:"kafka module not present"};const e=await kafka.kafkaConnectionHealthCheck(s);return{name:s.name,result:{name:s.name,type:s.type,...e}}}case"RelationalDatabase":{if(!rds)return{name:s.name,type:s.type,error:"rds module not present"};const e={callStack:[],callVariables:{},currentUrl:"",description:"GET /health",systemName:a,systemType:n},t=await rds.rdsConnectionHealthCheck(s,e);return{name:s.name,result:{name:s.name,type:s.type,...t}}}default:return{name:s.name,result:{name:s.name,type:s.type,status:"Not Implemented",error:"Not Implemented"}}}})();r.push(e)}}const o=await Promise.all(r);for(const{name:e,result:t}of o)s[e]=t;return s}function assembleHealthResponseObject(e,t){return{name:e.name,type:e.type,status:t.status,statusCode:t.statusCode,error:t.error,internal:t.internal}}module.exports={getHealthStatus:getHealthStatus};