@blazedpath/commons 0.0.11 → 0.1.1

package/blz-json-schema/index.js

@@ -1,13 +1,11 @@
 const validate = require('jsonschema').validate;
 
 module.exports = {
-    Backend: {
-        jsonSchemaValidate: function (data, schema) {
-            if (schema === undefined || schema === null)
-                throw new Error('schema undefined')
-            let result = validate(data, schema)
-            result.valid = (result.errors.length === 0)
-            return result
-        }
+    jsonSchemaValidate: function (data, schema) {
+        if (schema === undefined || schema === null)
+            throw new Error('schema undefined')
+        let result = validate(data, schema)
+        result.valid = (result.errors.length === 0)
+        return result   
     }
 };

package/blz-jwt/index.js

@@ -1,5 +1,4 @@
 const jwt = require('jsonwebtoken');
-const { Backend } = require('../blz-json-schema');
 
 class JwtSecretKeyNotDefined extends Error {
     constructor() {
@@ -18,107 +17,105 @@ function getJwtSecretKey() {
 }
 
 module.exports = {
-    Backend: {
-        JwtSecretKeyNotDefined,
+    JwtSecretKeyNotDefined,
 
-        jwtSign: function (payload, secret, algorithm) {
-            try {
-                switch (algorithm) {
-                    case 'HMAC-SHA256':
-                        return jwt.sign(payload, secret, { algorithm: 'HS256' });
-                    case 'HMAC-SHA384':
-                        return jwt.sign(payload, secret, { algorithm: 'HS384' });
-                    case 'HMAC-SHA512':
-                        return jwt.sign(payload, secret, { algorithm: 'HS512' });
-                    default:
-                        throw new Error('Invalid encryption algorithm');
-                }
-            } catch (jwterr) {
-                if (jwterr.name === 'TokenExpiredError') {
-                    let err = new Error();
-                    err.code = 'JwtExpired';
-                    err.data = { expiredAt: jwterr.expiredAt };
-                    throw err;
-                } else {
-                    throw jwterr;
-                }
+    jwtSign: function (payload, secret, algorithm) {
+        try {
+            switch (algorithm) {
+                case 'HMAC-SHA256':
+                    return jwt.sign(payload, secret, { algorithm: 'HS256' });
+                case 'HMAC-SHA384':
+                    return jwt.sign(payload, secret, { algorithm: 'HS384' });
+                case 'HMAC-SHA512':
+                    return jwt.sign(payload, secret, { algorithm: 'HS512' });
+                default:
+                    throw new Error('Invalid encryption algorithm');
+            }
+        } catch (jwterr) {
+            if (jwterr.name === 'TokenExpiredError') {
+                let err = new Error();
+                err.code = 'JwtExpired';
+                err.data = { expiredAt: jwterr.expiredAt };
+                throw err;
+            } else {
+                throw jwterr;
             }
-        },
+        }
+    },
 
-        jwtVerify: function (token, secret) {
-            try {
-                return jwt.verify(token, secret);
-            } catch (jwterr) {
-                if (jwterr.name === 'TokenExpiredError') {
-                    let err = new Error();
-                    err.code = 'JwtExpired';
-                    err.data = { expiredAt: jwterr.expiredAt };
-                    throw err;
-                } else {
-                    let err = new Error();
-                    err.code = 'JwtError';
-                    err.data = {};
-                    throw err;
-                }
+    jwtVerify: function (token, secret) {
+        try {
+            return jwt.verify(token, secret);
+        } catch (jwterr) {
+            if (jwterr.name === 'TokenExpiredError') {
+                let err = new Error();
+                err.code = 'JwtExpired';
+                err.data = { expiredAt: jwterr.expiredAt };
+                throw err;
+            } else {
+                let err = new Error();
+                err.code = 'JwtError';
+                err.data = {};
+                throw err;
             }
-        },
+        }
+    },
 
-        jwtDecode: function (token) {
-            try {
-                return jwt.decode(token);
-            } catch (jwterr) {
-                if (jwterr.name === 'TokenExpiredError') {
-                    let err = new Error();
-                    err.code = 'JwtExpired';
-                    err.data = { expiredAt: jwterr.expiredAt };
-                    throw err;
-                } else {
-                    let err = new Error();
-                    err.code = 'JwtError';
-                    err.data = {};
-                    throw err;
-                }
+    jwtDecode: function (token) {
+        try {
+            return jwt.decode(token);
+        } catch (jwterr) {
+            if (jwterr.name === 'TokenExpiredError') {
+                let err = new Error();
+                err.code = 'JwtExpired';
+                err.data = { expiredAt: jwterr.expiredAt };
+                throw err;
+            } else {
+                let err = new Error();
+                err.code = 'JwtError';
+                err.data = {};
+                throw err;
             }
-        },
+        }
+    },
 
-        jwtCreateToken: function (id, expiresIn = '10s') {
-            return jwt.sign({ id }, getJwtSecretKey(), { expiresIn });
-        },
+    jwtCreateToken: function (id, expiresIn = '10s') {
+        return jwt.sign({ id }, getJwtSecretKey(), { expiresIn });
+    },
 
-        jwtGetId: function (token) {
-            try {
-                const decoded = jwt.verify(token, getJwtSecretKey());
-                return decoded.id;
-            } catch (err) {
-                const error = new Error('Invalid or expired token');
-                error.code = 'JwtInvalid';
-                error.data = err.message;
-                throw error;
+    jwtGetId: function (token) {
+        try {
+            const decoded = jwt.verify(token, getJwtSecretKey());
+            return decoded.id;
+        } catch (err) {
+            const error = new Error('Invalid or expired token');
+            error.code = 'JwtInvalid';
+            error.data = err.message;
+            throw error;
+        }
+    },
+
+    jwtEncodeUrl: function (url, expiresIn = '10s') {
+        const [path, query] = url.split('?');
+        const parts = path.split('/').map(part => {
+            if (/^\d+$/.test(part)) {
+                return jwt.sign({ id: parseInt(part) }, getJwtSecretKey(), { expiresIn });
             }
-        },
+            return part;
+        });
+        return parts.join('/') + (query ? `?${query}` : '');
+    },
 
-        jwtEncodeUrl: function (url, expiresIn = '10s') {
-            const [path, query] = url.split('?');
-            const parts = path.split('/').map(part => {
-                if (/^\d+$/.test(part)) {
-                    return jwt.sign({ id: parseInt(part) }, getJwtSecretKey(), { expiresIn });
-                }
+    jwtDecodeUrl: function (url) {
+        const [path, query] = url.split('?');
+        const parts = path.split('/').map(part => {
+            try {
+                const decoded = jwt.verify(part, getJwtSecretKey());
+                return decoded.id?.toString() ?? part;
+            } catch {
                 return part;
-            });
-            return parts.join('/') + (query ? `?${query}` : '');
-        },
-
-        jwtDecodeUrl: function (url) {
-            const [path, query] = url.split('?');
-            const parts = path.split('/').map(part => {
-                try {
-                    const decoded = jwt.verify(part, getJwtSecretKey());
-                    return decoded.id?.toString() ?? part;
-                } catch {
-                    return part;
-                }
-            });
-            return parts.join('/') + (query ? `?${query}` : '');
-        }
+            }
+        });
+        return parts.join('/') + (query ? `?${query}` : '');
     }
 };

package/blz-kafka/index.js

@@ -31,11 +31,11 @@ const getConfig = async function (connection) {
     if (connection.brokers)
         kafkaConfig.brokers = connection.brokers.split(',');
     kafkaConfig.connectionTimeout = connection.connectionTimeout || 3000;
-    kafkaConfig.authenticationTimeout = connection.authenticationTimeout || 1000;
+    kafkaConfig.authenticationTimeout= connection.authenticationTimeout  || 1000;
     kafkaConfig.reauthenticationThreshold = connection.reauthenticationThreshold || 10000;
     if (connection.requestTimeout)
         kafkaConfig.requestTimeout = connection.requestTimeout;
-    if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor) {
+    if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor){
         kafkaConfig.retry = {};
         if (connection.connectionRetries)
             kafkaConfig.retry.retries = connection.connectionRetries;
@@ -81,16 +81,16 @@ let getOrCreateProducer = async function (connection) {
     if (producer) {
         return producer;
     }
-    let kafkaConfig = await getConfig(connection);
+    let kafkaConfig = await getConfig(connection);    
     let kafka = new Kafkajs.Kafka(kafkaConfig);
-    producer = kafka.producer({ createPartitioner: Kafkajs.Partitioners.LegacyPartitioner });
+    producer = kafka.producer({createPartitioner: Kafkajs.Partitioners.LegacyPartitioner});
     await producer.connect();
     producers[connection.name] = producer;
     return producer;
 };
 
 let getOrCreateAdmin = async function (connection, config) {
-    let kafkaConfig = await getConfig(connection);
+    let kafkaConfig = await getConfig(connection);    
     let kafka = new Kafkajs.Kafka(kafkaConfig);
     admin = kafka.admin();
     await admin.connect();
@@ -134,7 +134,7 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
             continue
         }
 
-        let connection = connections[buildKafkaConsumer.systemName];
+        let connection = connections[buildKafkaConsumer.systemName]; 
         // Check if kafka connection info is undefined
         if (!connection) {
             const kafkaBuildSystemConfig = buildConfigItems[buildKafkaConsumer.systemName]
@@ -153,11 +153,11 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
             if (connection.brokers)
                 kafkaConfig.brokers = connection.brokers.split(',');
             kafkaConfig.connectionTimeout = connection.connectionTimeout || 3000;
-            kafkaConfig.authenticationTimeout = connection.authenticationTimeout || 1000;
+            kafkaConfig.authenticationTimeout= connection.authenticationTimeout  || 1000;
             kafkaConfig.reauthenticationThreshold = connection.reauthenticationThreshold || 10000;
             if (connection.requestTimeout)
                 kafkaConfig.requestTimeout = connection.requestTimeout;
-            if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor) {
+            if (connection.connectionRetries || connection.connectionInitialRetryTime || connection.connectionMaxRetryTime || connection.connectionRetryFactor){
                 kafkaConfig.retry = {};
                 if (connection.connectionRetries)
                     kafkaConfig.retry.retries = connection.connectionRetries;
@@ -195,16 +195,16 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
                 }
             }
             kafkaConfig.logLevel = Kafkajs.logLevel.ERROR;
-            kafkaConfig.logCreator = () => {
+            kafkaConfig.logCreator = ()=> {
                 return ({ namespace, level, label, log }) => {
                     if (level === 1 && log.message && log.message.includes('The group is rebalancing')) {
                         // Do nothing or log at a different level for rebalancing errors
                         return;
-                    } else if (level === 1) {
+                    } else if (level === 1 ) {
                         runHelper.logError(`[${namespace}] : ${JSON.stringify(log.message)}`, namespace, log);
                     } else {
                         runHelper.log(`[${namespace}] : ${log.message}`);
-                    }
+                    }                   
                 }
             };
             kafka = new Kafkajs.Kafka(kafkaConfig);
@@ -219,7 +219,7 @@ async function createKafkaInstances(kafkaConsumers, connections, buildConfigItem
 //           en blz-builder es ... TODO
 // - kafkaConsumers: objeto con todos los consumers. Cada property del objeto es consumer
 // - connections: objeto con todas las conneciones con key
-async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper) {
+async function startKafkaConsumers (kafkas,config, kafkaConsumers, connections, runHelper) {
 
     for (let kafkaConsumerName in kafkaConsumers) {
         let buildKafkaConsumer = kafkaConsumers[kafkaConsumerName];
@@ -232,21 +232,21 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
         let kafkaErrorOptions = {};
         kafkaErrorOptions.errorOptions = connection.errorOptions ?? false;
         kafkaErrorOptions.manualCommit = connection.messageManualCommit ?? false;
-        kafkaErrorOptions.retries = connection.messageRetryCount ?? 5;
+        kafkaErrorOptions.retries =  connection.messageRetryCount ?? 5;
         kafkaErrorOptions.initialRetryTime = connection.initialRetryTime ?? 300;
         kafkaErrorOptions.factor = connection.messageRetryFactor ?? 2;
         kafkaErrorOptions.multiplier = connection.messageRetryMultiplier ?? 2;
         kafkaErrorOptions.traceAll = connection.traceAll ?? false;
-        kafkaErrorOptions.retryTopic = (buildKafkaConsumer.useErrorTopic && buildKafkaConsumer.parameterizedErrorTopic) ? config.parameters[buildKafkaConsumer.parameterizedErrorTopic.configParameterName] : '';
+        kafkaErrorOptions.retryTopic = (buildKafkaConsumer.useErrorTopic && buildKafkaConsumer.parameterizedErrorTopic)? config.parameters[ buildKafkaConsumer.parameterizedErrorTopic.configParameterName ] : '';
 
         let topics = [];
-        if (buildKafkaConsumer.topics) {
+        if (buildKafkaConsumer.topics){
             for (let i = 0; i < buildKafkaConsumer.topics.length; i++) {
                 let topic = buildKafkaConsumer.topics[i];
                 topics.push(topic);
             }
         }
-        if (buildKafkaConsumer.parameterizedTopics) {
+        if (buildKafkaConsumer.parameterizedTopics){
             for (let i = 0; i < buildKafkaConsumer.parameterizedTopics.length; i++) {
                 let parameterizedTopic = buildKafkaConsumer.parameterizedTopics[i];
                 const topic = config.parameters[parameterizedTopic.configParameterName];
@@ -263,13 +263,13 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
             continue
         }
         const groupId = buildKafkaConsumer.isParameterizedGroupId
-            ? config.parameters[buildKafkaConsumer.parameterizedGroupId.configParameterName]
+            ? config.parameters[ buildKafkaConsumer.parameterizedGroupId.configParameterName ]
             : buildKafkaConsumer.groupId
-
+        
         if (groupId === undefined || groupId === null || groupId.trim() === '') {
             console.error(`Kafka: ${kafkaConsumerName} consumer not had groupId defined`)
             continue
-        }
+        }        
         if (topics.length === 0) {
             console.error(`Kafka: ${kafkaConsumerName} consumer not had topics defined`)
             continue
@@ -296,7 +296,7 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
                             message: { key: consumeData.message.key, value: consumeData.message.value, headers: consumeData.message.headers }
                         };
                         await runHelper.runAlgorithm(callContext, { elementType: 'KafkaConsumer', elementName: kafkaConsumerName, path: buildKafkaConsumer.path, aliasesMatches: buildKafkaConsumer.aliasesMatches }, null, buildKafkaConsumer.algorithm, ctx0);
-                        if (kafkaErrorOptions.manualCommit) {
+						if (kafkaErrorOptions.manualCommit) {
                             await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
                         }
                     }
@@ -310,7 +310,7 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
         }
         // If Kafka is an actual server (!= mock). Use this section
         else {
-            try {
+            try{
                 let consumerOptions = {}
                 let consumerOptionsDefault = {
                     sessionTimeout: 60000,                // 60 seconds
@@ -327,7 +327,7 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
                         multiplier: 2                     // Backoff multiplier
                     }
                 };
-                if (connection.consumerOptions) {
+                if (connection.consumerOptions){
                     consumerOptions = { ...consumerOptionsDefault, ...connection.consumerOptions };
                 }
                 let consumer = kafka.consumer({ groupId: groupId });
@@ -340,8 +340,8 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
                     }
                     try {
                         await consumer.subscribe({ topic: topic, fromBeginning: buildKafkaConsumer.fromBeginning });
-                    } catch (err) {
-                        runHelper.logError(new Error(`Kafka: error whit topic ${topic}: ${err.message} `, err));
+                    } catch(err) {
+                        runHelper.logError(new Error(`Kafka: error whit topic ${topic}: ${err.message} `,err));                
                     }
                 }
                 // Handle group join and leave events
@@ -399,18 +399,18 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
                                 await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
                             }
                         } catch (err) {
-                            if (kafkaErrorOptions.traceAll) {
+                            if(kafkaErrorOptions.traceAll) {
                                 console.error(err);
                             }
-                            if (kafkaErrorOptions.retryTopic && kafkaErrorOptions.retryTopic !== '') {
+                            if(kafkaErrorOptions.retryTopic && kafkaErrorOptions.retryTopic !== '') {
                                 // sends message with error to retry topic
-                                await module.exports.Backend.kafkaSend(connection, kafkaErrorOptions.retryTopic, [message]);
+                                await module.exports.kafkaSend(connection, kafkaErrorOptions.retryTopic, [message]);
                                 // marks the message as read on original topic
                                 await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
-                            }
+                           }
                         }
                         await runHelper.terminateCallContext(callContext);
-                    },
+                    }, 
                     retry: {
                         retries: kafkaErrorOptions.retries,
                         initialRetryTime: kafkaErrorOptions.initialRetryTime,
@@ -429,96 +429,94 @@ async function startKafkaConsumers(kafkas, config, kafkaConsumers, connections,
             } catch (err) {
                 runHelper.logError(err);
             }
-        }
+        }        
         if (process.env.blz_traceAll === 'true' || process.env.blz_traceKafkaConsumers === 'true') {
             console.log('KAFKA CONSUMER | ' + kafkaConsumerName + ' | Start');
         }
-
+        
     }
 }
 // END: functions to initialize kafka consumers
 
 module.exports = {
-    Backend: {
-        kafkaConfig: async function (connection, config) {
-            if (!config || !config.topicsConfig || !config.topicsConfig.topics || !config.topicsConfig.topics.length || config.topicsConfig.topics.length === 0) {
-                throw new Error('Invalid config');
-            }
-            for (let i = 0; i < config.topicsConfig.topics.length; i++) {
-                let topic = config.topicsConfig.topics[i];
-                if (!topic.topic || topic.topic.trim().length === 0) {
-                    throw new Error(`Invalid topic ${i + 1} config`);
-                }
-            }
-            let result = false
-            let error = null;
-            let admin = null;
-            try {
-                let kafkaConfig = await getConfig(connection);
-                let kafka = new Kafkajs.Kafka(kafkaConfig);
-                admin = kafka.admin();
-                await admin.connect();
-                const currentTopics = await admin.listTopics();
-                let newsTopics = config.topicsConfig.topics.filter(topic => !currentTopics.includes(topic.topic));
-                if (newsTopics && newsTopics.length > 0) {
-                    config.topicsConfig.topics = newsTopics;
-                    result = await admin.createTopics(config.topicsConfig);
-                }
-            } catch (e) {
-                error = e;
-            } finally {
-                if (admin) {
-                    await admin.disconnect();
-                }
-            }
-            if (error) {
-                throw error;
+    kafkaConfig: async function (connection, config) {
+        if(!config || !config.topicsConfig || !config.topicsConfig.topics || !config.topicsConfig.topics.length || config.topicsConfig.topics.length === 0) {
+            throw new Error('Invalid config');
+        }
+        for (let i = 0; i < config.topicsConfig.topics.length; i++) {
+            let topic = config.topicsConfig.topics[i];
+            if (!topic.topic || topic.topic.trim().length === 0) {
+                throw new Error(`Invalid topic ${i+1} config`);
             }
-            return result;
-        },
-        kafkaGetTopics: async function (connection) {
-            let kafkaConfig = await getConfig(connection);
-            let kafka = new Kafkajs.Kafka(kafkaConfig);
-            const admin = kafka.admin();
+        }
+        let result = false
+        let error = null;
+        let admin = null;  
+        try {
+            let kafkaConfig = await getConfig(connection);    
+            let kafka = new Kafkajs.Kafka(kafkaConfig);            
+            admin = kafka.admin();
             await admin.connect();
-            const topics = await admin.listTopics();
-            await admin.disconnect();
-            return topics;
-        },
-        kafkaSend: async function (connection, topic, messages) {
-            if (connection.provider) {
-                await connection.provider.produce(connection, topic, messages);
-                return null;
-            }
-            let producer = await getOrCreateProducer(connection);
-            await producer.send({ topic: topic, messages: messages });
+            const currentTopics = await admin.listTopics();
+            let newsTopics = config.topicsConfig.topics.filter(topic => !currentTopics.includes(topic.topic));            
+            if(newsTopics && newsTopics.length > 0) {
+                config.topicsConfig.topics = newsTopics;
+                result = await admin.createTopics(config.topicsConfig);
+            } 
+        }catch(e) {
+            error = e;
+        } finally {
+            if(admin) {
+                await admin.disconnect();
+            }  
+        }
+        if(error) {
+            throw error;
+        }
+        return result;                
+    },
+    kafkaGetTopics: async function (connection) {
+        let kafkaConfig = await getConfig(connection);    
+        let kafka = new Kafkajs.Kafka(kafkaConfig);
+        const admin = kafka.admin();
+        await admin.connect();
+        const topics = await admin.listTopics();
+        await admin.disconnect();
+        return topics;
+    },
+    kafkaSend: async function (connection, topic, messages) {
+        if (connection.provider) {
+            await connection.provider.produce(connection, topic, messages);
             return null;
-        },
-        kafkaConnections: async function (kafkaConsumers, connections, buildConfigItems, runHelper) {
-            return createKafkaInstances(kafkaConsumers, connections, buildConfigItems, runHelper);
-        },
-        startKafkaConsumers: async function (kafkas, config, kafkaConsumers, connections, runHelper) {
-            startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper);
-        },
-        kafkaConnectionHealthCheck: async function (connection) {
-            if (!connection.brokers) {
-                return { status: "error", message: "Kafka broker list not defined" }
-            }
-            const kafka = new Kafkajs.Kafka({ brokers: [connection.brokers] });
-            try {
-                // Try to get metadata from Kafka to check the connection
-                const admin = kafka.admin();
-                await admin.connect();
-                // Fetch metadata (this will trigger a request to Kafka to see if it's reachable)
-                const metadata = await admin.fetchTopicMetadata({ topics: [] });
-                logger.info({ message: "Kafka is reachable!", metadata: metadata });
-                await admin.disconnect();  // Disconnect after metadata check
-                return { status: "ok", message: "Kafka connected, metadata vissible" };
-            } catch (error) {
-                logger.info({ message: "Kafka is not reachable", error: error });
-                return { status: "error", message: error.message };
-            }
-
         }
+        let producer = await getOrCreateProducer(connection);
+        await producer.send({ topic: topic, messages: messages });
+        return null;
+    },
+    kafkaConnections: async function(kafkaConsumers, connections, buildConfigItems, runHelper){
+        return createKafkaInstances(kafkaConsumers, connections, buildConfigItems, runHelper);
+    },
+    startKafkaConsumers: async function(kafkas,config, kafkaConsumers, connections, runHelper){
+        startKafkaConsumers(kafkas, config, kafkaConsumers, connections, runHelper); 
+    },
+    kafkaConnectionHealthCheck: async function (connection) {
+        if (!connection.brokers) {
+            return { status: "error", message: "Kafka broker list not defined" }
+        }
+        const kafka = new Kafkajs.Kafka({ brokers: [connection.brokers] });
+        try {
+            // Try to get metadata from Kafka to check the connection
+            const admin = kafka.admin();
+            await admin.connect();
+            // Fetch metadata (this will trigger a request to Kafka to see if it's reachable)
+            const metadata = await admin.fetchTopicMetadata({ topics: [] });
+            logger.info({message: "Kafka is reachable!", metadata:metadata});
+            await admin.disconnect();  // Disconnect after metadata check
+            return { status: "ok", message: "Kafka connected, metadata vissible" };
+        } catch (error) {
+            logger.info({ message: "Kafka is not reachable", error: error });
+            return { status: "error", message: error.message };
+        }
+
     }
 };