@blazedpath/commons 0.0.4

package/README.md

@@ -0,0 +1,3 @@
+# @blazedpatht commons
+
+TODO:

package/blz-base/health/index.js

@@ -0,0 +1,215 @@
+const fetch = require('node-fetch');
+const logger = require('pino')();
+
+
+const safeRequire = function(path) {
+	try {
+		require.resolve(path);
+		return require(path);
+	} catch (err) {
+		if (err.code === 'MODULE_NOT_FOUND') {
+			let newPath = path.replace(/^\.\.\//, '');
+			if (path !== newPath) {
+				return safeRequire(newPath);
+			}
+			return undefined;
+		}
+		throw err;
+	}
+}
+
+
+// Try to load this modules. IF they are not present, they will be set to undefined
+const mongoDb = safeRequire ('../../../essentials/extensions/blz-mongodb/sources-backend-nodejs/index.js') ||
+              safeRequire ('../../blz-mongodb/backend/index.js');
+const kafka = safeRequire('../../../essentials/extensions/blz-kafka/sources-backend-nodejs/index.js') ||
+              safeRequire ('../../blz-kafka/backend/index.js');
+const rds = safeRequire('../../../essentials/extensions/blz-rds/sources-backend-nodejs/index.js') ||
+            safeRequire ('../../blz-rds/backend/index.js');
+
+// This function checks health for blz microservices and blz-bpm nodes.
+async function healthCheckMicroservice (connection) {
+    let healthResponse = {}
+    const fullUrl = (connection.healthCheckPath) ?  new URL(healthCheckPath.healthCheckPath, connection.url).toString() : 
+                                                    new URL("/blz-health-status", connection.url).toString();
+    try {
+        const response = await fetch(fullUrl);
+        if (response.ok) {
+            const data = await response.json();
+            healthResponse = {
+                name: connection.name, type: connection.type, 
+                status: response.status, statusCode: response.statusCode, error: "-", internal: data
+            };
+        } else {
+            healthResponse = { name: connection.name, type: connection.type, 
+                status: "error", 
+                error: `HTTP Error: ${response.statusText}`
+            };
+        }
+    } catch (error) {
+        healthResponse = {
+            name: connection.name, type: connection.type, 
+            status: "error", error: error.message
+        };
+    }
+    return healthResponse;
+}
+async function healthCheckAllPossibleUrl (connection) {
+    let possiblePaths = ["/blz-health-status", "/health", "/actuator/health", "/"];
+    if (connection.healthCheckPath) {
+        // leave the defined path first for evaluation if defined in the config
+        possiblePaths.unshift(connection.healthCheckPath);
+    }
+    for (const path of possiblePaths) {
+        const fullUrl = new URL(path, connection.url).toString();
+        try {
+            const response = await fetch(fullUrl);
+            if (response.ok && path === "/blz-health-status") {
+                const data = await response.json();
+                return { status: response.status, url: fullUrl, data };
+            } else if (response.ok && path === "/health") {
+                return { status: response.status, url: fullUrl, data: "Connected with /Health API. httpCode 200." };
+            } else if (response.ok) {
+                return { status: response.status, url: fullUrl, data: "Connected with standard Http code 200 protocol. Endpoint: " + path };
+            }
+        } catch (error) {
+            logger.info(error);
+        }
+    }
+    return { status: "error", message: "No valid health check endpoint found" };
+}
+
+async function getHealthStatus(_buildSystem, _connections) {
+    let selfName = _buildSystem.name;
+    let selfType = _buildSystem.type;
+    let healthResponse = {};
+
+    // Add self-health check
+    healthResponse[selfName] = { name: selfName, type: "Self", status: "ok", error: "-" };
+
+    // Prepare all health check promises
+    const healthPromises = [];
+
+    for (const key in _connections) {
+        if (Object.prototype.hasOwnProperty.call(_connections, key)) {
+            const connection = _connections[key];
+            if (connection.name !== selfName) {
+                const promise = (async () => {
+                    switch (connection.type) {
+                        case "Microservice":
+                        case "ProcessEngine":
+                            return {
+                                name: connection.name,
+                                result: await healthCheckMicroservice(connection)
+                            };
+
+                        case "RestApi":
+                            return {
+                                name: connection.name,
+                                result: await healthCheckAllPossibleUrl(connection)
+                            };
+
+                        case "Mongodb": {
+                            if (!mongoDb){
+                                return { 
+                                    name: connection.name,
+                                    type: connection.type,
+                                    result: {
+                                        name: connection.name,
+                                        type: connection.type,
+                                        error: 'mongoDb module not present'
+                                    }
+                                }
+                            }
+                            const mongoHealthResponse = await mongoDb.mongodbConnectionHealthCheck(connection);
+                            return {
+                                name: connection.name,
+                                result: {
+                                    name: connection.name,
+                                    type: connection.type,
+                                    ...mongoHealthResponse
+                                }
+                            };
+                        }
+
+                        case "Kafka": {
+                            if (!kafka){
+                                return { name: connection.name, type: connection.type, error: 'kafka module not present' }
+                            }
+                            const kafkaHealthResponse = await kafka.kafkaConnectionHealthCheck(connection);
+                            return {
+                                name: connection.name,
+                                result: {
+                                    name: connection.name,
+                                    type: connection.type,
+                                    ...kafkaHealthResponse
+                                }
+                            };
+                        }
+
+                        case "RelationalDatabase": {
+                            if (!rds){
+                                return { name: connection.name, type: connection.type, error: 'rds module not present' }
+                            }
+                            const callContext = {
+                                callStack: [],
+                                callVariables: {},
+                                currentUrl: '',
+                                description: 'GET /health',
+                                systemName: selfName,
+                                systemType: selfType
+                            };
+                            const rdsHealthResponse = await rds.rdsConnectionHealthCheck(connection, callContext);
+                            return {
+                                name: connection.name,
+                                result: {
+                                    name: connection.name,
+                                    type: connection.type,
+                                    ...rdsHealthResponse
+                                }
+                            };
+                        }
+
+                        default:
+                            return {
+                                name: connection.name,
+                                result: {
+                                    name: connection.name,
+                                    type: connection.type,
+                                    status: "Not Implemented",
+                                    error: "Not Implemented"
+                                }
+                            };
+                    }
+                })();
+                healthPromises.push(promise);
+            }
+        }
+    }
+
+    // Await all in parallel
+    const results = await Promise.all(healthPromises);
+    for (const { name, result } of results) {
+        healthResponse[name] = result;
+    }
+
+    return healthResponse;
+}
+
+// not yet used, but will be necesary in the future when object requires to be standardized 
+function assembleHealthResponseObject(connection, state) {
+    let healthResponse = {
+        name: connection.name, 
+        type: connection.type, 
+        status: state.status,
+        statusCode: state.statusCode,
+        error: state.error,
+        internal: state.internal
+    };
+    return healthResponse
+
+}
+
+module.exports = {
+    getHealthStatus
+};