@naman_deep_singh/server-utils 1.0.6 → 1.0.8

package/dist/index.d.ts

@@ -6,12 +6,14 @@ export { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
 export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
 export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, type ValidationRule, type RateLimitConfig, type AuthConfig } from './middleware';
 export { getEnv, getEnvNumber, getEnvBoolean } from './utils';
-export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin, SocketIOConfig, SocketInstance } from './types';
+export { PeriodicHealthMonitor } from './periodic-health';
+export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin, SocketIOConfig, SocketInstance, PeriodicHealthCheckConfig, HealthCheckService } from './types';
 import { ExpressServer, createServer } from './server';
 import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
 import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
 import { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth } from './middleware';
 import { getEnv, getEnvNumber, getEnvBoolean } from './utils';
+import { PeriodicHealthMonitor } from './periodic-health';
 declare const ServerUtils: {
     createServer: typeof createServer;
     ExpressServer: typeof ExpressServer;
@@ -39,5 +41,6 @@ declare const ServerUtils: {
     getEnv: typeof getEnv;
     getEnvNumber: typeof getEnvNumber;
     getEnvBoolean: typeof getEnvBoolean;
+    PeriodicHealthMonitor: typeof PeriodicHealthMonitor;
 };
 export default ServerUtils;

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnvBoolean = exports.getEnvNumber = exports.getEnv = exports.requireAuth = exports.rateLimit = exports.validateFields = exports.withAuth = exports.withRateLimit = exports.withValidation = exports.withRequestId = exports.withErrorHandler = exports.withLogging = exports.createAuthMiddleware = exports.createRateLimitMiddleware = exports.createValidationMiddleware = exports.createRequestIdMiddleware = exports.createErrorHandler = exports.createLoggingMiddleware = exports.startServerWithShutdown = exports.withGracefulShutdown = exports.createGracefulShutdown = exports.addHealthCheck = exports.withHealthCheck = exports.createHealthCheck = exports.Router = exports.createServer = exports.ExpressServer = void 0;
+exports.PeriodicHealthMonitor = exports.getEnvBoolean = exports.getEnvNumber = exports.getEnv = exports.requireAuth = exports.rateLimit = exports.validateFields = exports.withAuth = exports.withRateLimit = exports.withValidation = exports.withRequestId = exports.withErrorHandler = exports.withLogging = exports.createAuthMiddleware = exports.createRateLimitMiddleware = exports.createValidationMiddleware = exports.createRequestIdMiddleware = exports.createErrorHandler = exports.createLoggingMiddleware = exports.startServerWithShutdown = exports.withGracefulShutdown = exports.createGracefulShutdown = exports.addHealthCheck = exports.withHealthCheck = exports.createHealthCheck = exports.Router = exports.createServer = exports.ExpressServer = void 0;
 // Core server utilities
 var server_1 = require("./server");
 Object.defineProperty(exports, "ExpressServer", { enumerable: true, get: function () { return server_1.ExpressServer; } });
@@ -40,12 +40,16 @@ var utils_1 = require("./utils");
 Object.defineProperty(exports, "getEnv", { enumerable: true, get: function () { return utils_1.getEnv; } });
 Object.defineProperty(exports, "getEnvNumber", { enumerable: true, get: function () { return utils_1.getEnvNumber; } });
 Object.defineProperty(exports, "getEnvBoolean", { enumerable: true, get: function () { return utils_1.getEnvBoolean; } });
+// Periodic health monitoring
+var periodic_health_1 = require("./periodic-health");
+Object.defineProperty(exports, "PeriodicHealthMonitor", { enumerable: true, get: function () { return periodic_health_1.PeriodicHealthMonitor; } });
 // Import all exports for default export
 const server_2 = require("./server");
 const health_2 = require("./health");
 const shutdown_2 = require("./shutdown");
 const middleware_2 = require("./middleware");
 const utils_2 = require("./utils");
+const periodic_health_2 = require("./periodic-health");
 // Default export for namespace usage
 const ServerUtils = {
     // Server creation
@@ -78,6 +82,8 @@ const ServerUtils = {
     // Utils
     getEnv: utils_2.getEnv,
     getEnvNumber: utils_2.getEnvNumber,
-    getEnvBoolean: utils_2.getEnvBoolean
+    getEnvBoolean: utils_2.getEnvBoolean,
+    // Periodic Health Monitoring
+    PeriodicHealthMonitor: periodic_health_2.PeriodicHealthMonitor,
 };
 exports.default = ServerUtils;

package/dist/periodic-health.d.ts

@@ -0,0 +1,11 @@
+import { PeriodicHealthCheckConfig } from './types';
+export declare class PeriodicHealthMonitor {
+    private intervals;
+    private config;
+    private serviceName;
+    constructor(config: PeriodicHealthCheckConfig, serviceName: string);
+    start(): void;
+    stop(): void;
+    private checkServiceHealth;
+    getHealthStatus(): Promise<Record<string, boolean>>;
+}

package/dist/periodic-health.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeriodicHealthMonitor = void 0;
+class PeriodicHealthMonitor {
+    constructor(config, serviceName) {
+        this.intervals = [];
+        this.config = config;
+        this.serviceName = serviceName;
+    }
+    start() {
+        if (!this.config.enabled || !this.config.services?.length) {
+            return;
+        }
+        const interval = this.config.interval || 30000;
+        this.config.services.forEach(service => {
+            const intervalId = setInterval(async () => {
+                await this.checkServiceHealth(service);
+            }, interval);
+            this.intervals.push(intervalId);
+        });
+        console.log(`📊 ${this.serviceName}: Periodic health monitoring enabled (${interval}ms interval) for ${this.config.services.length} service(s)`);
+    }
+    stop() {
+        this.intervals.forEach(interval => clearInterval(interval));
+        this.intervals = [];
+        console.log(`🛑 ${this.serviceName}: Periodic health monitoring stopped`);
+    }
+    async checkServiceHealth(service) {
+        try {
+            const controller = new AbortController();
+            const timeout = service.timeout || 5000;
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(service.url, {
+                method: 'GET',
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': `${this.serviceName}-health-monitor`
+                }
+            });
+            clearTimeout(timeoutId);
+            if (response.ok) {
+                console.log(`🟢 ${service.name} is healthy`);
+                return true;
+            }
+            else {
+                console.log(`🔴 ${service.name} returned ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.log(`🔴 ${service.name} health check failed: ${errorMessage}`);
+            return false;
+        }
+    }
+    // Get current health status of all services
+    async getHealthStatus() {
+        if (!this.config.services?.length) {
+            return {};
+        }
+        const results = {};
+        await Promise.all(this.config.services.map(async (service) => {
+            results[service.name] = await this.checkServiceHealth(service);
+        }));
+        return results;
+    }
+}
+exports.PeriodicHealthMonitor = PeriodicHealthMonitor;

package/dist/server.d.ts

@@ -54,8 +54,10 @@ export declare class ExpressServer implements ServerInstance {
     private grpcServer?;
     private rpcMethods;
     private socketIO?;
+    private healthMonitor?;
     constructor(name?: string, version?: string, config?: ServerConfig);
     private setupMiddleware;
+    private setupPeriodicHealthMonitoring;
     start(): Promise<ServerInstance>;
     stop(): Promise<void>;
     getInfo(): ServerInfo;

package/dist/server.js

@@ -7,6 +7,7 @@ exports.ExpressServer = void 0;
 exports.createServer = createServer;
 const express_1 = __importDefault(require("express"));
 const shutdown_1 = require("./shutdown");
+const periodic_health_1 = require("./periodic-health");
 const crypto_1 = __importDefault(require("crypto"));
 class ExpressServer {
     constructor(name = 'Express Server', version = '1.0.0', config = {}) {
@@ -26,10 +27,13 @@ class ExpressServer {
             customMiddleware: config.customMiddleware || [],
             healthCheck: config.healthCheck ?? true,
             gracefulShutdown: config.gracefulShutdown ?? true,
-            socketIO: config.socketIO
+            socketIO: config.socketIO,
+            periodicHealthCheck: config.periodicHealthCheck || { enabled: false }
         };
         // Apply middleware based on configuration
         this.setupMiddleware();
+        // Setup periodic health monitoring
+        this.setupPeriodicHealthMonitoring();
     }
     setupMiddleware() {
         // Apply CORS if enabled
@@ -87,6 +91,11 @@ class ExpressServer {
             });
         }
     }
+    setupPeriodicHealthMonitoring() {
+        if (this.config.periodicHealthCheck?.enabled) {
+            this.healthMonitor = new periodic_health_1.PeriodicHealthMonitor(this.config.periodicHealthCheck, this.config.name);
+        }
+    }
     async start() {
         this.status = 'starting';
         return new Promise((resolve, reject) => {
@@ -98,9 +107,17 @@ class ExpressServer {
                         (0, shutdown_1.createGracefulShutdown)(this.server, {
                             onShutdown: async () => {
                                 this.status = 'stopping';
+                                // Stop health monitoring during shutdown
+                                if (this.healthMonitor) {
+                                    this.healthMonitor.stop();
+                                }
                             }
                         });
                     }
+                    // Start periodic health monitoring after server is running
+                    if (this.healthMonitor) {
+                        this.healthMonitor.start();
+                    }
                     resolve(this);
                 });
                 this.server.on('error', reject);
@@ -117,6 +134,10 @@ class ExpressServer {
         if (this.grpcServer) {
             this.grpcServer.forceShutdown();
         }
+        // Stop periodic health monitoring
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+        }
         // Stop Socket.IO server if running
         if (this.socketIO) {
             this.socketIO.close();

package/dist/types.d.ts

@@ -19,9 +19,20 @@ export interface ServerConfig {
     healthCheck?: boolean | string;
     gracefulShutdown?: boolean;
     socketIO?: SocketIOConfig;
+    periodicHealthCheck?: PeriodicHealthCheckConfig;
     name?: string;
     version?: string;
 }
+export interface PeriodicHealthCheckConfig {
+    enabled?: boolean;
+    interval?: number;
+    services?: HealthCheckService[];
+}
+export interface HealthCheckService {
+    name: string;
+    url: string;
+    timeout?: number;
+}
 export interface SocketIOConfig {
     enabled?: boolean;
     cors?: boolean | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/server-utils",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Extensible server utilities for Express.js microservices with TypeScript",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -13,15 +13,15 @@ export { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
 export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
 
 // Middleware utilities
-export { 
-  createLoggingMiddleware, 
-  createErrorHandler, 
+export {
+  createLoggingMiddleware,
+  createErrorHandler,
   createRequestIdMiddleware,
   createValidationMiddleware,
   createRateLimitMiddleware,
   createAuthMiddleware,
-  withLogging, 
-  withErrorHandler, 
+  withLogging,
+  withErrorHandler,
   withRequestId,
   withValidation,
   withRateLimit,
@@ -41,30 +41,35 @@ export {
   getEnvBoolean
 } from './utils';
 
+// Periodic health monitoring
+export { PeriodicHealthMonitor } from './periodic-health';
+
 // Types
-export type { 
-  ServerConfig, 
-  HealthCheckConfig, 
-  HealthCheck, 
-  GracefulShutdownConfig, 
+export type {
+  ServerConfig,
+  HealthCheckConfig,
+  HealthCheck,
+  GracefulShutdownConfig,
   ServerPlugin,
   SocketIOConfig,
-  SocketInstance 
+  SocketInstance,
+  PeriodicHealthCheckConfig,
+  HealthCheckService
 } from './types';
 
 // Import all exports for default export
 import { ExpressServer, createServer } from './server';
 import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
 import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
-import { 
-  createLoggingMiddleware, 
-  createErrorHandler, 
+import {
+  createLoggingMiddleware,
+  createErrorHandler,
   createRequestIdMiddleware,
   createValidationMiddleware,
   createRateLimitMiddleware,
   createAuthMiddleware,
-  withLogging, 
-  withErrorHandler, 
+  withLogging,
+  withErrorHandler,
   withRequestId,
   withValidation,
   withRateLimit,
@@ -74,23 +79,24 @@ import {
   requireAuth
 } from './middleware';
 import { getEnv, getEnvNumber, getEnvBoolean } from './utils';
+import { PeriodicHealthMonitor } from './periodic-health';
 
 // Default export for namespace usage
 const ServerUtils = {
   // Server creation
   createServer,
   ExpressServer,
-  
+
   // Health checks
   createHealthCheck,
   withHealthCheck,
   addHealthCheck,
-  
+
   // Graceful shutdown
   createGracefulShutdown,
   withGracefulShutdown,
   startServerWithShutdown,
-  
+
   // Middleware
   createLoggingMiddleware,
   createErrorHandler,
@@ -107,11 +113,14 @@ const ServerUtils = {
   validateFields,
   rateLimit,
   requireAuth,
-  
+
   // Utils
   getEnv,
   getEnvNumber,
-  getEnvBoolean
+  getEnvBoolean,
+
+  // Periodic Health Monitoring
+  PeriodicHealthMonitor,
 };
 
 export default ServerUtils;

package/src/periodic-health.ts

@@ -0,0 +1,83 @@
+import { PeriodicHealthCheckConfig, HealthCheckService } from './types';
+
+export class PeriodicHealthMonitor {
+  private intervals: NodeJS.Timeout[] = [];
+  private config: PeriodicHealthCheckConfig;
+  private serviceName: string;
+
+  constructor(config: PeriodicHealthCheckConfig, serviceName: string) {
+    this.config = config;
+    this.serviceName = serviceName;
+  }
+
+  start(): void {
+    if (!this.config.enabled || !this.config.services?.length) {
+      return;
+    }
+
+    const interval = this.config.interval || 30000;
+
+    this.config.services.forEach(service => {
+      const intervalId = setInterval(async () => {
+        await this.checkServiceHealth(service);
+      }, interval);
+
+      this.intervals.push(intervalId);
+    });
+
+    console.log(`📊 ${this.serviceName}: Periodic health monitoring enabled (${interval}ms interval) for ${this.config.services.length} service(s)`);
+  }
+
+  stop(): void {
+    this.intervals.forEach(interval => clearInterval(interval));
+    this.intervals = [];
+    console.log(`🛑 ${this.serviceName}: Periodic health monitoring stopped`);
+  }
+
+  private async checkServiceHealth(service: HealthCheckService): Promise<boolean> {
+    try {
+      const controller = new AbortController();
+      const timeout = service.timeout || 5000;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(service.url, {
+        method: 'GET',
+        signal: controller.signal,
+        headers: {
+          'User-Agent': `${this.serviceName}-health-monitor`
+        }
+      });
+
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        console.log(`🟢 ${service.name} is healthy`);
+        return true;
+      } else {
+        console.log(`🔴 ${service.name} returned ${response.status}`);
+        return false;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      console.log(`🔴 ${service.name} health check failed: ${errorMessage}`);
+      return false;
+    }
+  }
+
+  // Get current health status of all services
+  async getHealthStatus(): Promise<Record<string, boolean>> {
+    if (!this.config.services?.length) {
+      return {};
+    }
+
+    const results: Record<string, boolean> = {};
+
+    await Promise.all(
+      this.config.services.map(async service => {
+        results[service.name] = await this.checkServiceHealth(service);
+      })
+    );
+
+    return results;
+  }
+}

package/src/server.ts

@@ -2,6 +2,7 @@ import express from 'express';
 import { Server } from 'http';
 import { ServerConfig, SocketIOConfig, SocketInstance } from './types';
 import { createGracefulShutdown } from './shutdown';
+import { PeriodicHealthMonitor } from './periodic-health';
 import crypto from 'crypto';
 
 export interface GrpcService {
@@ -68,6 +69,7 @@ export class ExpressServer implements ServerInstance {
   private grpcServer?: GrpcServerInstance;
   private rpcMethods: RpcMethod = {};
   private socketIO?: { close(): void };
+  private healthMonitor?: PeriodicHealthMonitor;
 
   constructor(
     name: string = 'Express Server',
@@ -87,11 +89,15 @@ export class ExpressServer implements ServerInstance {
       customMiddleware: config.customMiddleware || [],
       healthCheck: config.healthCheck ?? true,
       gracefulShutdown: config.gracefulShutdown ?? true,
-      socketIO: config.socketIO
+      socketIO: config.socketIO,
+      periodicHealthCheck: config.periodicHealthCheck || { enabled: false }
     };
 
     // Apply middleware based on configuration
     this.setupMiddleware();
+
+    // Setup periodic health monitoring
+    this.setupPeriodicHealthMonitoring();
   }
 
   private setupMiddleware(): void {
@@ -153,6 +159,15 @@ export class ExpressServer implements ServerInstance {
     }
   }
 
+  private setupPeriodicHealthMonitoring(): void {
+    if (this.config.periodicHealthCheck?.enabled) {
+      this.healthMonitor = new PeriodicHealthMonitor(
+        this.config.periodicHealthCheck,
+        this.config.name
+      );
+    }
+  }
+
   async start(): Promise<ServerInstance> {
     this.status = 'starting';
 
@@ -166,10 +181,19 @@ export class ExpressServer implements ServerInstance {
             createGracefulShutdown(this.server!, {
               onShutdown: async () => {
                 this.status = 'stopping';
+                // Stop health monitoring during shutdown
+                if (this.healthMonitor) {
+                  this.healthMonitor.stop();
+                }
               }
             });
           }
 
+          // Start periodic health monitoring after server is running
+          if (this.healthMonitor) {
+            this.healthMonitor.start();
+          }
+
           resolve(this);
         });
 
@@ -189,6 +213,11 @@ export class ExpressServer implements ServerInstance {
       this.grpcServer.forceShutdown();
     }
 
+    // Stop periodic health monitoring
+    if (this.healthMonitor) {
+      this.healthMonitor.stop();
+    }
+
     // Stop Socket.IO server if running
     if (this.socketIO) {
       this.socketIO.close();
@@ -331,7 +360,7 @@ export class ExpressServer implements ServerInstance {
       };
 
       // Configure CORS
-      const corsConfig = config.cors === true 
+      const corsConfig = config.cors === true
         ? { origin: '*', methods: ['GET', 'POST'] }
         : config.cors || undefined;
 

package/src/types.ts

@@ -21,10 +21,23 @@ export interface ServerConfig {
   healthCheck?: boolean | string;
   gracefulShutdown?: boolean;
   socketIO?: SocketIOConfig;
+  periodicHealthCheck?: PeriodicHealthCheckConfig;
   name?: string;
   version?: string;
 }
 
+export interface PeriodicHealthCheckConfig {
+  enabled?: boolean;
+  interval?: number;
+  services?: HealthCheckService[];
+}
+
+export interface HealthCheckService {
+  name: string;
+  url: string;
+  timeout?: number;
+}
+
 export interface SocketIOConfig {
   enabled?: boolean;
   cors?: boolean | {