@uber-clone/common 1.0.5 → 1.0.7

package/build/index.d.ts

@@ -11,3 +11,6 @@ export * from "./middlewares/validate-request";
 export * from "./events/kafka-client";
 export * from "./events/types";
 export * from "./events/subjects";
+export * from "./metrics/app.metrics";
+export * from "./utils/logger";
+export * from "./redis/redis-client";

package/build/index.js

@@ -24,8 +24,9 @@ __exportStar(require("./middlewares/current-user"), exports);
 __exportStar(require("./middlewares/error-handler"), exports);
 __exportStar(require("./middlewares/require-auth"), exports);
 __exportStar(require("./middlewares/validate-request"), exports);
-// export * from "./events/kafka-listener";
-// export * from "./events/kafka-publisher";
 __exportStar(require("./events/kafka-client"), exports);
 __exportStar(require("./events/types"), exports);
 __exportStar(require("./events/subjects"), exports);
+__exportStar(require("./metrics/app.metrics"), exports);
+__exportStar(require("./utils/logger"), exports);
+__exportStar(require("./redis/redis-client"), exports);

package/build/metrics/app.metrics.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response, NextFunction } from "express";
+export declare const metricsMiddleware: (req: Request, res: Response, next: NextFunction) => void;
+export declare const metricsEndpoint: (req: Request, res: Response) => Promise<void>;
+export declare const trackDatabaseQuery: <T>(operation: string, collection: string, query: () => Promise<T>) => Promise<T>;
+export declare const trackRedisOperation: <T>(operation: string, redisOp: () => Promise<T>) => Promise<T>;

package/build/metrics/app.metrics.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackRedisOperation = exports.trackDatabaseQuery = exports.metricsEndpoint = exports.metricsMiddleware = void 0;
+const prom_client_1 = __importDefault(require("prom-client"));
+// Create a Registry
+const register = new prom_client_1.default.Registry();
+// Add default metrics (CPU, memory, etc.)
+prom_client_1.default.collectDefaultMetrics({ register });
+// Custom Metrics
+const httpRequestDuration = new prom_client_1.default.Histogram({
+    name: "http_request_duration_seconds",
+    help: "Duration of HTTP requests in seconds",
+    labelNames: ["method", "route", "status_code"],
+    buckets: [0.1, 0.5, 1, 2, 5],
+    registers: [register],
+});
+const httpRequestTotal = new prom_client_1.default.Counter({
+    name: "http_requests_total",
+    help: "Total number of HTTP requests",
+    labelNames: ["method", "route", "status_code"],
+    registers: [register],
+});
+const activeConnections = new prom_client_1.default.Gauge({
+    name: "active_connections",
+    help: "Number of active connections",
+    registers: [register],
+});
+const databaseQueryDuration = new prom_client_1.default.Histogram({
+    name: "database_query_duration_seconds",
+    help: "Duration of database queries in seconds",
+    labelNames: ["operation", "collection"],
+    buckets: [0.01, 0.05, 0.1, 0.5, 1],
+    registers: [register],
+});
+const redisOperationDuration = new prom_client_1.default.Histogram({
+    name: "redis_operation_duration_seconds",
+    help: "Duration of Redis operations in seconds",
+    labelNames: ["operation", "status"],
+    buckets: [0.001, 0.005, 0.01, 0.05, 0.1],
+    registers: [register],
+});
+// Middleware to track HTTP metrics
+const metricsMiddleware = (req, res, next) => {
+    const start = Date.now();
+    activeConnections.inc();
+    res.on("finish", () => {
+        var _a;
+        const duration = (Date.now() - start) / 1000;
+        const route = ((_a = req.route) === null || _a === void 0 ? void 0 : _a.path) || req.path;
+        httpRequestDuration.observe({
+            method: req.method,
+            route: route,
+            status_code: res.statusCode,
+        }, duration);
+        httpRequestTotal.inc({
+            method: req.method,
+            route: route,
+            status_code: res.statusCode,
+        });
+        activeConnections.dec();
+    });
+    next();
+};
+exports.metricsMiddleware = metricsMiddleware;
+// Metrics endpoint
+const metricsEndpoint = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    res.set("Content-Type", register.contentType);
+    const metrics = yield register.metrics();
+    res.end(metrics);
+});
+exports.metricsEndpoint = metricsEndpoint;
+// Helper functions to track operations
+const trackDatabaseQuery = (operation, collection, query) => __awaiter(void 0, void 0, void 0, function* () {
+    const end = databaseQueryDuration.startTimer({ operation, collection });
+    try {
+        const result = yield query();
+        end();
+        return result;
+    }
+    catch (error) {
+        end();
+        throw error;
+    }
+});
+exports.trackDatabaseQuery = trackDatabaseQuery;
+const trackRedisOperation = (operation, redisOp) => __awaiter(void 0, void 0, void 0, function* () {
+    const end = redisOperationDuration.startTimer({
+        operation,
+        status: "success",
+    });
+    try {
+        const result = yield redisOp();
+        end();
+        return result;
+    }
+    catch (error) {
+        redisOperationDuration.labels(operation, "error").observe(0);
+        throw error;
+    }
+});
+exports.trackRedisOperation = trackRedisOperation;

package/build/redis/redis-client.d.ts

@@ -0,0 +1,46 @@
+export interface GeoLocation {
+    type?: "Point";
+    coordinates: [number, number];
+    address?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postalCode?: string;
+}
+export interface RedisConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    cluster?: boolean;
+    connectTimeout?: number;
+    lazyConnect?: boolean;
+    retryDelay?: number;
+    maxRetries?: number;
+}
+export declare class RedisClient {
+    private config;
+    private redis;
+    private redlock;
+    private logger;
+    private isConnected;
+    constructor(config?: RedisConfig);
+    private initializeRedlock;
+    private setupEventListeners;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private ensureConnected;
+    healthCheck(): Promise<boolean>;
+    incrementCounter(key: string, incrementBy?: number): Promise<number>;
+    getCounterValue(key: string): Promise<number>;
+    acquireLock(lockKey: string, ttl?: number): Promise<any | string | null>;
+    releaseLock(lockOrKey: any | string | null): Promise<boolean>;
+    setCache(key: string, value: any, ttl?: number): Promise<void>;
+    getCache<T>(key: string): Promise<T | null>;
+    deleteCache(key: string): Promise<void>;
+    publish(channel: string, message: any): Promise<void>;
+    subscribe(channel: string, handler: (message: any) => void): Promise<void>;
+    flushAll(): Promise<void>;
+    getRedisInfo(): Promise<Record<string, string>>;
+}

package/build/redis/redis-client.js

@@ -0,0 +1,305 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+// libs/common/src/redis/redis-client.ts
+const redis_1 = require("redis");
+const redlock_1 = __importDefault(require("redlock"));
+const logger_1 = require("../utils/logger");
+class RedisClient {
+    constructor(config = {}) {
+        this.config = config;
+        this.redlock = null;
+        this.isConnected = false;
+        this.logger = new logger_1.Logger("RedisClient");
+        this.redis = (0, redis_1.createClient)({
+            url: process.env.REDIS_URL || "redis://redis-cluster:6379",
+            socket: {
+                reconnectStrategy: (retries) => {
+                    this.logger.debug(`Redis reconnection attempt ${retries}`);
+                    return Math.min(retries * 1000, 10000);
+                },
+                connectTimeout: 10000,
+            },
+            // password: config.password,
+            // database: config.db || 0,
+        });
+        this.initializeRedlock();
+        this.setupEventListeners();
+        this.connect().catch((err) => this.logger.error("Auto-connect failed:", err));
+    }
+    initializeRedlock() {
+        try {
+            this.redlock = new redlock_1.default([this.redis], {
+                driftFactor: 0.01,
+                retryCount: 3,
+                retryDelay: 200,
+                retryJitter: 100,
+            });
+            this.redlock.on("error", (error) => {
+                this.logger.error("Redlock error:", error);
+            });
+        }
+        catch (err) {
+            this.logger.warn("Redlock initialization failed:", err);
+            this.redlock = null;
+        }
+    }
+    setupEventListeners() {
+        this.redis.on("connect", () => {
+            this.isConnected = true;
+            this.logger.info("✅ Connected to Redis");
+        });
+        this.redis.on("error", (error) => {
+            this.logger.error("❌ Redis error:", error);
+            this.isConnected = false;
+        });
+        this.redis.on("end", () => {
+            this.logger.warn("⚠️ Redis connection closed");
+            this.isConnected = false;
+        });
+        this.redis.on("ready", () => {
+            this.logger.info("Redis client ready");
+            this.isConnected = true;
+        });
+    }
+    // Core Connection Methods
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected)
+                return;
+            try {
+                yield this.redis.connect();
+                this.isConnected = true;
+            }
+            catch (error) {
+                this.logger.error("Failed to connect to Redis:", error);
+                throw error;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.redis.quit();
+                this.isConnected = false;
+                this.logger.info("Redis connection closed");
+            }
+            catch (error) {
+                this.logger.error("Error disconnecting from Redis:", error);
+                throw error;
+            }
+        });
+    }
+    ensureConnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected) {
+                yield this.connect();
+            }
+        });
+    }
+    // Health Check
+    healthCheck() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.redis.ping();
+                return true;
+            }
+            catch (error) {
+                this.logger.error("Redis health check failed:", error);
+                return false;
+            }
+        });
+    }
+    incrementCounter(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, incrementBy = 1) {
+            return yield this.redis.incrBy(key, incrementBy);
+        });
+    }
+    getCounterValue(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = yield this.redis.get(key);
+            return val ? parseInt(val) : 0;
+        });
+    }
+    // ========== LOCKING METHODS ==========
+    acquireLock(lockKey_1) {
+        return __awaiter(this, arguments, void 0, function* (lockKey, ttl = 5000) {
+            yield this.ensureConnected();
+            if (this.redlock) {
+                try {
+                    const lock = yield this.redlock.acquire([lockKey], ttl);
+                    return lock;
+                }
+                catch (error) {
+                    return null;
+                }
+            }
+            // Fallback: SET NX
+            try {
+                const result = yield this.redis.set(lockKey, "locked", {
+                    NX: true,
+                    PX: ttl,
+                });
+                return result === "OK" ? lockKey : null;
+            }
+            catch (error) {
+                this.logger.error(`Error acquiring lock ${lockKey}:`, error);
+                return null;
+            }
+        });
+    }
+    releaseLock(lockOrKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!lockOrKey)
+                return true;
+            // Redlock instance
+            if (typeof lockOrKey === "object" &&
+                typeof lockOrKey.release === "function") {
+                try {
+                    (_a = this.redlock) === null || _a === void 0 ? void 0 : _a.release(lockOrKey.resources[0]);
+                    return true;
+                }
+                catch (error) {
+                    this.logger.warn("Error releasing Redlock:", error);
+                    return false;
+                }
+            }
+            // Fallback: key string
+            if (typeof lockOrKey === "string") {
+                try {
+                    yield this.redis.del(lockOrKey);
+                    return true;
+                }
+                catch (error) {
+                    this.logger.warn(`Error releasing lock ${lockOrKey}:`, error);
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
+    // ========== CACHING METHODS ==========
+    setCache(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const serialized = typeof value === "string" ? value : JSON.stringify(value);
+                if (ttl) {
+                    yield this.redis.setEx(key, ttl, serialized);
+                }
+                else {
+                    yield this.redis.set(key, serialized);
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error setting cache key ${key}:`, error);
+                throw error;
+            }
+        });
+    }
+    getCache(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const value = yield this.redis.get(key);
+                if (!value)
+                    return null;
+                try {
+                    return JSON.parse(value);
+                }
+                catch (_a) {
+                    return value;
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error getting cache key ${key}:`, error);
+                return null;
+            }
+        });
+    }
+    deleteCache(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.redis.del(key);
+            }
+            catch (error) {
+                this.logger.error(`Error deleting cache key ${key}:`, error);
+                throw error;
+            }
+        });
+    }
+    // ========== PUB/SUB METHODS ==========
+    publish(channel, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.redis.publish(channel, JSON.stringify(message));
+            }
+            catch (error) {
+                this.logger.error(`Error publishing to channel ${channel}:`, error);
+                throw error;
+            }
+        });
+    }
+    subscribe(channel, handler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscriber = this.redis.duplicate();
+            yield subscriber.connect();
+            yield subscriber.subscribe(channel, (message) => {
+                try {
+                    handler(JSON.parse(message));
+                }
+                catch (error) {
+                    this.logger.error(`Error handling message on ${channel}:`, error);
+                }
+            });
+            subscriber.on("error", (error) => {
+                this.logger.error(`Subscriber error for ${channel}:`, error);
+            });
+        });
+    }
+    // ========== UTILITY METHODS ==========
+    flushAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.redis.flushAll();
+                this.logger.warn("All Redis data cleared!");
+            }
+            catch (error) {
+                this.logger.error("Error flushing Redis:", error);
+                throw error;
+            }
+        });
+    }
+    getRedisInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const info = yield this.redis.info();
+                const lines = info.split("\n");
+                const result = {};
+                for (const line of lines) {
+                    if (line.includes(":")) {
+                        const [key, value] = line.split(":");
+                        result[key.trim()] = value.trim();
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                this.logger.error("Error getting Redis info:", error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RedisClient = RedisClient;

package/build/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export declare class Logger {
+    private logger;
+    constructor(service: string);
+    info(message: string, meta?: any): void;
+    error(message: string, error?: any): void;
+    warn(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+}

package/build/utils/logger.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+// libs/common/src/utils/logger.ts
+const winston_1 = __importDefault(require("winston"));
+class Logger {
+    constructor(service) {
+        this.logger = winston_1.default.createLogger({
+            level: process.env.LOG_LEVEL || "info",
+            format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.errors({ stack: true }), winston_1.default.format.json()),
+            defaultMeta: { service },
+            transports: [
+                new winston_1.default.transports.Console({
+                    format: winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.simple()),
+                }),
+                new winston_1.default.transports.File({
+                    filename: "logs/error.log",
+                    level: "error",
+                }),
+                new winston_1.default.transports.File({
+                    filename: "logs/combined.log",
+                }),
+            ],
+        });
+    }
+    info(message, meta) {
+        this.logger.info(message, meta);
+    }
+    error(message, error) {
+        this.logger.error(message, { error });
+    }
+    warn(message, meta) {
+        this.logger.warn(message, meta);
+    }
+    debug(message, meta) {
+        this.logger.debug(message, meta);
+    }
+}
+exports.Logger = Logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uber-clone/common",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
@@ -9,7 +9,7 @@
   "scripts": {
     "clean": "del-cli ./build/*",
     "build": "npm run clean && tsc",
-    "pub": "git add . && git commit -m \"New Updated\" && npm version patch && npm run build && npm publish"
+    "pub": "cd common && git add . && git commit -m \"New Updated\" && npm version patch && npm run build && npm publish"
   },
   "keywords": [],
   "author": "",
@@ -28,6 +28,9 @@
     "express-validator": "^7.2.1",
     "jsonwebtoken": "^9.0.2",
     "kafkajs": "^2.2.4",
-    "node-nats-streaming": "^0.3.2"
+    "prom-client": "^15.1.3",
+    "redis": "^5.9.0",
+    "redlock": "^5.0.0-beta.2",
+    "winston": "^3.18.3"
   }
 }