rhoam-shared-utils 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhoam-shared-utils",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Shared infrastructure utilities for Rhoam microservices",
   "license": "MIT",
   "author": "Jabez Nehemiah",

package/src/constants/constant.js

@@ -24,9 +24,9 @@ export const BASE_URLS = {
 
 
 export const SERVICE_URLS = {
-    user_services: "http://localhost:4001/api/v1/users",
-    auth_services: "http://localhost:4000/api/v1/auth",
-    admin_services: "http://locahost:4003/api/v1/admin",
+    user_services: "http://user-service:4001/api/v1/users",
+    auth_services: "http://auth-service:4000/api/v1/auth",
+    admin_services: "http://admin-service:4003/api/v1/admin",
 }
 
 

package/src/kafka/client.js

@@ -1,12 +1,30 @@
 import { Kafka, logLevel } from "kafkajs";
 
 let kafka;
-export function getKafka(brokers = (process.env.KAFKA_BROKERS || "localhost:9092").split(",")) {
+
+const DEFAULT_BROKERS = (process.env.KAFKA_BROKERS || "localhost:9092").split(",");
+const DEFAULT_LOG_LEVEL = "INFO";
+
+function parseLogLevel(level) {
+  const normalized = String(level || DEFAULT_LOG_LEVEL).trim().toUpperCase();
+  const map = {
+    NOTHING: logLevel.NOTHING,
+    ERROR: logLevel.ERROR,
+    WARN: logLevel.WARN,
+    INFO: logLevel.INFO,
+    DEBUG: logLevel.DEBUG,
+  };
+  return map[normalized] ?? logLevel.INFO;
+}
+
+export function getKafka(brokers = DEFAULT_BROKERS) {
   if (!kafka) {
     kafka = new Kafka({
       clientId: process.env.KAFKA_CLIENT_ID || "generic-service",
       brokers,
-      logLevel: logLevel.NOTHING,
+      logLevel: parseLogLevel(process.env.KAFKA_LOG_LEVEL),
+      connectionTimeout: Number(process.env.KAFKA_CONNECTION_TIMEOUT_MS || 3000),
+      requestTimeout: Number(process.env.KAFKA_REQUEST_TIMEOUT_MS || 30000),
     });
   }
   return kafka;

package/src/kafka/consumer.js

@@ -1,23 +1,55 @@
 import { getKafka } from "./client.js";
 
-export async function createConsumer(groupId) {
-  const consumer = getKafka().consumer({ groupId });
+const DEFAULT_SESSION_TIMEOUT = Number(process.env.KAFKA_CONSUMER_SESSION_TIMEOUT_MS || 30000);
+const DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY = Number(process.env.KAFKA_CONSUMER_PARTITIONS_CONCURRENTLY || 1);
+
+export async function createConsumer(groupId, options = {}) {
+  const consumer = getKafka().consumer({
+    groupId,
+    sessionTimeout: options.sessionTimeout || DEFAULT_SESSION_TIMEOUT,
+    ...options.consumerConfig,
+  });
   await consumer.connect();
   console.log(`Kafka consumer connected (group: ${groupId})`);
   return consumer;
 }
 
-export async function subscribeRun(consumer, topic, onMessage, fromBeginning = false) {
-  await consumer.subscribe({ topic, fromBeginning });
+export async function subscribeRun(consumer, topic, onMessage, fromBeginning = false, options = {}) {
+  await consumer.subscribe({ topic, fromBeginning, ...options.subscribeConfig });
+
   await consumer.run({
+    partitionsConsumedConcurrently: options.partitionsConsumedConcurrently ?? DEFAULT_PARTITIONS_CONSUMED_CONCURRENTLY,
     eachMessage: async ({ topic, partition, message }) => {
-      try {
-        await onMessage({ topic, partition, message });
-      } catch (err) {
-        console.error("Consumer handler error:", err.message);
-        // TODO: push to DLQ if needed
+      const maxHandlerRetries = Number(options.maxHandlerRetries ?? 3);
+      let attempt = 0;
+      let lastError;
+
+      while (attempt <= maxHandlerRetries) {
+        try {
+          await onMessage({ topic, partition, message });
+          return;
+        } catch (err) {
+          lastError = err;
+          attempt += 1;
+          console.error(`Consumer handler error, attempt ${attempt}/${maxHandlerRetries}:`, err?.message || err);
+          if (attempt > maxHandlerRetries) {
+            if (typeof options.onError === "function") {
+              await options.onError({ topic, partition, message, error: err });
+            }
+            if (options.throwOnError) {
+              throw err;
+            }
+            break;
+          }
+          const delayMs = Math.min(1000 * 2 ** (attempt - 1), 30000);
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      }
+
+      if (lastError) {
+        console.error(`Dropping message after ${maxHandlerRetries} retries for topic:${topic}, partition:${partition}`);
       }
-    }
+    },
   });
 }
 

package/src/kafka/eventlistener.js

@@ -5,25 +5,46 @@ import { createConsumer, subscribeRun } from "./consumer.js";
  * @param {string} groupId - Kafka consumer group ID (unique per service).
  * @param {string} topic - Kafka topic name to subscribe to.
  * @param {function} handler - Function called for each event message.
+ * @param {object} [options] - Optional listener settings.
  */
+export async function listenToEvent(groupId, topic, handler, options = {}) {
+    if (!groupId || !topic || typeof handler !== "function") {
+      throw new Error("listenToEvent requires groupId, topic, and handler");
+    }
 
-export async function listenToEvent(groupId, topic, handler) {
     try {
-        const consumer = await createConsumer(groupId);
+        const consumer = await createConsumer(groupId, options);
 
         await subscribeRun(consumer, topic, async ({ message }) => {
             const key = message.key?.toString();
             const value = message.value?.toString();
 
-            if (!key || !value) return console.warn("Skipped empty Kafka message");
+            if (!key || !value) {
+                console.warn("Skipped empty Kafka message", { topic, partition: message.partition });
+                return;
+            }
+
+            let data;
+            try {
+                data = JSON.parse(value);
+            } catch (err) {
+                console.error("Failed to parse message", err.message);
+                if (typeof options.onError === "function") {
+                    await options.onError({ topic, message, error: err });
+                }
+                return;
+            }
 
-            const data = JSON.parse(value);
             await handler(key, data);
-        });
+        }, false, options);
 
         console.log(`Listening to Kafka topic: ${topic} (group: ${groupId})`);
         return consumer;
     } catch (err) {
         console.error(`Error initializing Kafka consumer for ${topic}:`, err.message);
+        if (typeof options.onError === "function") {
+            await options.onError({ topic, error: err });
+        }
+        throw err;
     }
 }

package/src/kafka/producer.js

@@ -1,17 +1,52 @@
 import { getKafka } from "./client.js";
 let producer;
-export async function getProducer() {
+
+export async function getProducer(options = {}) {
   if (!producer) {
-    producer = getKafka().producer({ allowAutoTopicCreation: true });
+    producer = getKafka().producer({
+      allowAutoTopicCreation: options.allowAutoTopicCreation !== undefined ? options.allowAutoTopicCreation : true,
+      idempotent: options.idempotent !== undefined ? options.idempotent : true,
+      ...options.producerConfig,
+    });
     await producer.connect();
     console.log("Kafka producer connected");
   }
   return producer;
 }
-export async function publish(topic, messages, headers = {}) {
-  const p = await getProducer();
-  await p.send({ topic, messages, headers });
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export async function publish(topic, messages, headers = {}, options = {}) {
+  if (!topic) {
+    throw new Error("Topic is required for publish");
+  }
+  if (!messages || !messages.length) {
+    throw new Error("Messages array is required for publish");
+  }
+
+  const p = await getProducer(options);
+  const maxRetries = Number(options.retries ?? 5);
+  let attempt = 0;
+
+  while (true) {
+    try {
+      await p.send({ topic, messages, headers });
+      return;
+    } catch (err) {
+      attempt += 1;
+      const errMsg = err?.message || String(err);
+      console.error(`Kafka publish failed (attempt ${attempt}/${maxRetries}):`, errMsg);
+
+      if (attempt >= maxRetries) {
+        throw err;
+      }
+
+      const backoffMs = Number(options.retryBackoffMs ?? Math.min(1000 * 2 ** (attempt - 1), 30000));
+      await delay(backoffMs);
+    }
+  }
 }
+
 export async function shutdownProducer() {
   if (producer) {
     await producer.disconnect();

package/src/kafka/topics.js

@@ -1,6 +1,10 @@
 export const Topics = {
     USER_EVENTS : 'user-events',
     EKYC_EVENTS: 'ekyc-events',
+    LOG_EVENTS: 'log-events',
+    PAYMENT_EVENTS: 'payment-events',
+    CHAT_EVENTS: 'chat-events',
+    SECURITY_EVENTS: 'security-events',
 };
 
 export const Keys = {
@@ -8,12 +12,24 @@ export const Keys = {
     USER_EMAIL_OTP: 'user-email-otp',
     USER_MOBILE_OTP: 'user-mobile-otp',
     USER_PASSWORD_CHANGED: 'user-password-changed',
+    USER_DELETED: 'user-deleted',
     USER_FCM_REGISTER: 'user-fcm-store',
     USER_DETAILS_UPDATE: 'user-details-update',
     EKYC_DOCUMENT_UPLOAD: 'ekyc-user-document-upload',
     EKYC_DOCUMENT_DELETED: 'ekyc-user-document-delete',
+    EKYC_VERIFICATION_COMPLETED : 'ekyc-verification-completed',
     ERRORS : 'errors',
     AUDIT_EVENTS : 'audit-event',
-    EKYC_VERIFICATION_COMPLETED : 'ekyc-verification-completed',
+    USER_TRACKING : 'user-tracking',
+    PAYMENT_RECEIVED: 'payment-received',
+    PAYMENT_REQUESTED: 'payment-requested',
+    PAYMENT_SENT: 'payment-sent',
+    PAYMENT_SPLIT_INITIATE: 'payment-split-initated',
+    PAYMENT_SPLIT_PAID: 'payment-split-paid',
+    MESSAGE_RECEIVED: 'message-received',
+    MESSAGE_SENT: 'message-sent',
+    NEW_DEVICE_LOGIN : 'new-device-login',
+    DEVICE_SIGNED_OUT: 'device-signed-out',
+    PASSWORD_CHANGED : 'password-changed',
     
 };