rhoam-shared-utils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jabez-Techzar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# rhoam-shared
+Rhoam Microservices Dependeny Packages

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "rhoam-shared-utils",
+  "version": "1.0.0",
+  "description": "Shared infrastructure utilities for Rhoam microservices",
+  "license": "MIT",
+  "author": "Jabez Nehemiah",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "scripts": {
+    "test": "node src/index.js"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "jsonwebtoken": "^9.0.2",
+    "kafkajs": "^2.2.4",
+    "winston": "^3.18.3",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/constants/constant.js

@@ -0,0 +1,173 @@
+export const KYC_ENUM = {
+    1: "Verified",
+    2: "Rejected",
+    3: "Mannual Approval Needed",
+    4: "Not Verified Yet",
+};
+
+export const ACTIVE_STATUS = {
+    1: "Active",
+    0: "In-Active",
+};
+
+export const TRANSACTION_STATUS = {
+    1: "Pending",
+    2: "Successful",
+    3: "Failed",
+};
+
+export const BASE_URLS = {
+    user_services: "http://localhost:3000/api/v1/users",
+    auth_services: "http://localhost:3000/api/v1/auth",
+    admin_services: "http://localhost:3000/api/v1/admin",
+};
+
+
+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",
+}
+
+
+export const GENDERS = {
+    1: 'Male',
+    2: 'Female',
+    3: 'Others',
+};
+
+export const OTP_APIS = {
+    1: 'WHATSAPP',
+    2: 'SMS',
+    3: 'TELEGRAM',
+    4: 'EMAIL',
+};
+
+export const FILE_TYPES = {
+    PROFILE_IMAGE: '1',
+    EKYC_PASSPORT: '2',
+    EKYC_SELFIE: '3',
+    EKYC_OTHER_DOCS: '4',
+    AI_CHAT_FILE: '5',
+};
+
+export const EXT_TYPES ={
+    IMAGE: '1',
+    DOC: '2',
+    PDF: '3',
+    EXCEL: '4',
+    VIDEO: '5',
+    AUDIO: '6',
+};
+
+export const RESPONSE_CODES = {
+    // Server errors
+    SERVER_ERROR: "SERVER_ERROR",
+    
+    // Authentication & Login
+    LOGIN_REQUIRED: "LOGIN_REQUIRED",
+    LOGIN_SUCCESSFUL: "LOGIN_SUCCESSFUL",
+    LOGIN_FAILED: "LOGIN_FAILED",
+    
+    // OTP related
+    OTP_SENT: "OTP_SENT",
+    OTP_VERIFIED: "OTP_VERIFIED",
+    OTP_INVALID: "OTP_INVALID",
+    OTP_EXPIRED: "OTP_EXPIRED",
+    
+    // Device & Session
+    NEW_DEVICE_DETECTED: "NEW_DEVICE_DETECTED",
+    INVALID_SESSION: "INVALID_SESSION",
+    SESSION_EXPIRED: "SESSION_EXPIRED",
+    
+    // Passcode (PIN)
+    PASSCODE_REQUIRED: "PASSCODE_REQUIRED",
+    PASSCODE_SETUP_REQUIRED: "PASSCODE_SETUP_REQUIRED",
+    PASSCODE_SETUP_SUCCESSFUL: "PASSCODE_SETUP_SUCCESSFUL",
+    PASSCODE_AUTH_SUCCESSFUL: "PASSCODE_AUTH_SUCCESSFUL",
+    PASSCODE_AUTH_FAILED: "PASSCODE_AUTH_FAILED",
+    PASSCODE_INVALID: "PASSCODE_INVALID",
+    PASSCODE_LOCKED: "PASSCODE_LOCKED",
+    
+    // Biometric
+    BIOMETRIC_SETUP_SUCCESSFUL: "BIOMETRIC_SETUP_SUCCESSFUL",
+    BIOMETRIC_AUTH_SUCCESSFUL: "BIOMETRIC_AUTH_SUCCESSFUL",
+    BIOMETRIC_AUTH_FAILED: "BIOMETRIC_AUTH_FAILED",
+    BIOMETRIC_NOT_AVAILABLE: "BIOMETRIC_NOT_AVAILABLE",
+    BIOMETRIC_NOT_ENROLLED: "BIOMETRIC_NOT_ENROLLED",
+    
+    // Account status
+    ACCOUNT_LOCKED: "ACCOUNT_LOCKED",
+    ACCOUNT_DEACTIVATED: "ACCOUNT_DEACTIVATED",
+    ACCOUNT_SUSPENDED: "ACCOUNT_SUSPENDED",
+    TOO_MANY_ATTEMPTS: "TOO_MANY_ATTEMPTS",
+    ACCOUNT_UNLOCKED: "ACCOUNT_UNLOCKED",
+    
+    // Tokens
+    INVALID_TOKEN: "INVALID_TOKEN",
+    TOKEN_EXPIRED: "TOKEN_EXPIRED",
+    REFRESH_TOKEN_REQUIRED: "REFRESH_TOKEN_REQUIRED",
+    
+    // Authorization
+    UNAUTHORIZED: "UNAUTHORIZED",
+    FORBIDDEN: "FORBIDDEN",
+    INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS",
+    
+    // Validation
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    INVALID_INPUT: "INVALID_INPUT",
+    MISSING_FIELDS: "MISSING_FIELDS",
+    
+    // Rate limiting
+    RATE_LIMITED: "RATE_LIMITED",
+    TOO_MANY_REQUESTS: "TOO_MANY_REQUESTS",
+
+    // Account Already Exists,
+    ACCOUNT_EXISTS: "ACCOUNT ALREADY EXISTS",
+    VERIFICATION_REQUIRED: "VERIFICATION_REQUIRED",
+    NO_ACCOUNT_FOUND: "NO ACCOUNT FOUND",
+
+    // Password Events
+    PASSWORD_CHANGED: "PASSWORD CHANGED",
+
+    // Ekyc Statuses
+    EKYC_INITIATED : "EKYC_INITIATED",
+    EKYC_NOT_INITIATED: "EKYC_NOT_INITIATED",
+    EKYC_STEP_ONE_COMPLETED: "EKYC STEP ONE COMPLETED",
+    EKYC_STEP_TWO_COMPLETED: "EKYC STEP TWO COMPLETED",
+    EKYC_STEP_THREE_COMPLETED: "EKYC STEP THREE COMPLETED",
+    EKYC_VERIFICATION_COMPLETE: "EKYC_VERIFICATION_COMPLETE",
+    EKYC_VERIFICATION_FAILED:"EKYC_VERIFICATION_FAILED",
+    EKYC_MANNUAL_APPROVAL_NEEDED: "EKYC_MANNUAL_APPROVAL_NEEDED",
+
+    // Operation
+    OPERATION_SUCCESS: "OPERATION_SUCCESS",
+    OPERATION_FAILED: "OPERATION_FAILED",
+
+    NOT_FOUND: "NOT_FOUND",
+
+
+};
+
+export const ROLES = {
+    1: 'Normal Users',
+    2: 'Admin Users'
+};
+
+export const EKYC_STEPS = {
+    PERSONAL_INFO: 1,
+    DOCUMENT_SUBMISSION: 2,
+    SELFIE_VERIFICATION: 3,
+};
+
+
+export const SERVICES_TYPE = {
+    1 : 'Authentication Service',
+    2 : 'User Service',
+    3 : 'API Gateway',
+    4 : 'Admin Service',
+    5 : 'Notification Service',
+    6 : 'EKYC Service',  
+};
+
+

package/src/helpers/helpers.js

@@ -0,0 +1,129 @@
+import * as CONSTANTS from "../constants/constant.js";
+import { logger } from "../utils/logger.js";
+import crypto from "crypto";
+import axios from "axios";
+const secret_key = "P(0p!e@e$k";
+const secret_iv = "Peop!eDe$k";
+const algorithm = "aes-256-cbc";
+const key = crypto.createHash("sha256").update(secret_key).digest();
+const iv = crypto.createHash("sha256").update(secret_iv).digest().subarray(0, 16);
+
+
+export const GetGender = (gender) => {
+
+    switch (parseInt(gender)) {
+        case CONSTANTS.GENDERS[1]:
+            return 'Male';
+            break;
+
+        case CONSTANTS.GENDERS[2]:
+            return 'Female';
+            break;
+
+        case CONSTANTS.GENDERS[3]:
+            return 'Other';
+            break;
+
+        default:
+            return 'Unknown';
+
+    }
+
+};
+
+export const CalculateAge = (dob) => {
+
+    const birthDate = new Date(dob);
+    const today = new Date();
+
+    let age = today.getFullYear() - birthDate.getFullYear();
+    const monthDiff = today.getMonth() - birthDate.getMonth();
+
+    if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birthDate.getDate())) {
+        age--;
+    }
+
+    return age;
+};
+
+
+// Base64 → Base64URL
+const toBase64Url = (str) =>
+    str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+
+// Base64URL → Base64
+const fromBase64Url = (str) =>
+    str.replace(/-/g, "+").replace(/_/g, "/");
+
+export const encryptId = (value) => {
+    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    let encrypted = cipher.update(String(value), "utf8", "base64");
+    encrypted += cipher.final("base64");
+
+    return toBase64Url(encrypted);
+};
+
+export const decryptId = (encryptedValue) => {
+    const decipher = crypto.createDecipheriv(algorithm, key, iv);
+    const base64 = fromBase64Url(encryptedValue);
+
+    let decrypted = decipher.update(base64, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+
+    return decrypted;
+};
+
+export const GetUserName = async (user_id) => {
+    try {
+        const response = await axios.post(
+            `${CONSTANTS.SERVICE_URLS.user_services}/fetch-user`,
+            { user_id }
+        );
+
+        const details = response?.data?.data?.details;
+
+        if (!details) return null;
+
+        return `${details.first_name} ${details.last_name}`;
+
+    } catch (exception) {
+        logger.error("Get User Name Error:", exception);
+        return false;
+    }
+};
+
+export const Displaydateformat = (date) => {
+    try {
+        if (!date) return null;
+
+        const d = new Date(date);
+
+        if (isNaN(d)) return null;
+
+        const day = String(d.getDate()).padStart(2, "0");
+        const month = String(d.getMonth() + 1).padStart(2, "0");
+        const year = d.getFullYear();
+
+        return `${day}-${month}-${year}`;
+    } catch (exception) {
+        return null;
+    }
+};
+
+export const Displaydatetimeformat = (date) => {
+    try {
+        if (!date) return null;
+        const d = new Date(date);
+
+        if (isNaN(d)) return null;
+        const day = String(d.getDate()).padStart(2, "0");
+        const month = String(d.getMonth() + 1).padStart(2, "0");
+        const year = d.getFullYear();
+        const hours = String(d.getHours()).padStart(2, "0");
+        const minutes = String(d.getMinutes()).padStart(2, "0");
+        return `${day}-${month}-${year} ${hours}:${minutes}`;
+    } catch (exception) {
+        return null;
+    }
+};
+

package/src/index.js

@@ -0,0 +1,9 @@
+export * from "./helpers/helpers.js";
+export * from "./constants/constant.js";
+export * from "./middleware/VerifyAdmin.js";
+export * from "./kafka/client.js";
+export * from "./kafka/producer.js";
+export * from "./kafka/consumer.js";
+export * from "./kafka/topics.js";
+export * from "./kafka/eventlistener.js";
+export { logger } from "./utils/logger.js";

package/src/kafka/client.js

@@ -0,0 +1,13 @@
+import { Kafka, logLevel } from "kafkajs";
+
+let kafka;
+export function getKafka(brokers = (process.env.KAFKA_BROKERS || "localhost:9092").split(",")) {
+  if (!kafka) {
+    kafka = new Kafka({
+      clientId: process.env.KAFKA_CLIENT_ID || "generic-service",
+      brokers,
+      logLevel: logLevel.NOTHING,
+    });
+  }
+  return kafka;
+}

package/src/kafka/consumer.js

@@ -0,0 +1,29 @@
+import { getKafka } from "./client.js";
+
+export async function createConsumer(groupId) {
+  const consumer = getKafka().consumer({ groupId });
+  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 });
+  await consumer.run({
+    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
+      }
+    }
+  });
+}
+
+export async function shutdownConsumer(consumer) {
+  if (consumer) {
+    await consumer.disconnect();
+    console.log("Kafka consumer disconnected");
+  }
+}

package/src/kafka/eventlistener.js

@@ -0,0 +1,29 @@
+import { createConsumer, subscribeRun } from "./consumer.js";
+
+/**
+ * Simplified helper to listen to a Kafka topic and handle events.
+ * @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.
+ */
+
+export async function listenToEvent(groupId, topic, handler) {
+    try {
+        const consumer = await createConsumer(groupId);
+
+        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");
+
+            const data = JSON.parse(value);
+            await handler(key, data);
+        });
+
+        console.log(`Listening to Kafka topic: ${topic} (group: ${groupId})`);
+        return consumer;
+    } catch (err) {
+        console.error(`Error initializing Kafka consumer for ${topic}:`, err.message);
+    }
+}

package/src/kafka/producer.js

@@ -0,0 +1,21 @@
+import { getKafka } from "./client.js";
+let producer;
+export async function getProducer() {
+  if (!producer) {
+    producer = getKafka().producer({ allowAutoTopicCreation: true });
+    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 });
+}
+export async function shutdownProducer() {
+  if (producer) {
+    await producer.disconnect();
+    producer = null;
+    console.log("Kafka producer disconnected");
+  }
+}

package/src/kafka/topics.js

@@ -0,0 +1,19 @@
+export const Topics = {
+    USER_EVENTS : 'user-events',
+    EKYC_EVENTS: 'ekyc-events',
+};
+
+export const Keys = {
+    USER_REGISTERED : 'user-registered',
+    USER_EMAIL_OTP: 'user-email-otp',
+    USER_MOBILE_OTP: 'user-mobile-otp',
+    USER_PASSWORD_CHANGED: 'user-password-changed',
+    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',
+    ERRORS : 'errors',
+    AUDIT_EVENTS : 'audit-event',
+    EKYC_VERIFICATION_COMPLETED : 'ekyc-verification-completed',
+    
+};

package/src/middleware/VerifyAdmin.js

@@ -0,0 +1,28 @@
+import jwt from "jsonwebtoken";
+import dotenv from "dotenv";
+dotenv.config();
+
+export const VerifyAdmin = (req, res, next) => {
+    try {
+        const authHeader = req.headers.authorization;
+
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            return res.status(401).json({ message: "Authorization token missing" });
+        }
+
+        const token = authHeader.split(" ")[1];
+
+        const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+        if (!decoded?.admin) {
+            return res.status(403).json({ message: "Access denied: Admins only" });
+        }
+
+        req.user = decoded;
+        next();
+        
+    } catch (err) {
+        console.error("Token verification failed:", err.message);
+        return res.status(401).json({ message: "Invalid or expired token" });
+    }
+};

package/src/utils/logger.js

@@ -0,0 +1,37 @@
+import { createLogger, format, transports } from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import path from "path";
+
+const logFormat = format.printf(
+    ({ level, message, timestamp, stack }) =>
+        `${timestamp} [${level}] : ${stack || message}`
+);
+
+export const logger = createLogger({
+    level: "info",
+    format: format.combine(
+        format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        format.errors({ stack: true }),
+        logFormat
+    ),
+    transports: [
+        new transports.Console({
+            format: format.combine(format.colorize(), logFormat),
+        }),
+
+        new DailyRotateFile({
+            filename: path.join("logs", "error-%DATE%.log"),
+            datePattern: "YYYY-MM-DD",
+            level: "error",
+            maxSize: "20m",
+            maxFiles: "14d",
+        }),
+
+        new DailyRotateFile({
+            filename: path.join("logs", "combined-%DATE%.log"),
+            datePattern: "YYYY-MM-DD",
+            maxSize: "20m",
+            maxFiles: "14d",
+        }),
+    ],
+});

package/types/rhoam-shared.d.ts

@@ -0,0 +1,5 @@
+// types/rhoam-shared.d.ts
+declare module 'rhoam-shared' {
+  export const someFunction: () => void;
+  export const someVariable: string;
+}