@naman_deep_singh/server-utils 1.3.0 → 1.4.1

package/README.md

@@ -1,6 +1,6 @@
 # @naman_deep_singh/server-utils
 
-**Version:** 1.3.0 (with integrated cache & session support)
+**Version:** 1.4.1 (with integrated cache & session support)
 
 Extensible server utilities for Express.js microservices with multi-protocol support, integrated caching, session management, and TypeScript.
 
@@ -158,15 +158,29 @@ server.app.use('/api', rateLimit({
 }));
 ```
 
+
 ### Authentication Middleware
 ```typescript
 import { requireAuth } from '@naman_deep_singh/server-utils';
 
 server.app.use('/protected', requireAuth({
-  tokenExtractor: (req) => req.headers.authorization?.substring(7),
-  tokenValidator: async (token) => {
-    // Verify JWT token
-    return jwt.verify(token, process.env.JWT_SECRET);
+  secret: process.env.JWT_SECRET!,
+  unauthorizedMessage: 'Invalid or expired token'
+}));
+```
+
+**Advanced Configuration:**
+```typescript
+import { createAuthMiddleware } from '@naman_deep_singh/server-utils';
+
+server.app.use('/api', createAuthMiddleware({
+  secret: process.env.JWT_SECRET!,
+  unauthorizedMessage: 'Access denied',
+  tokenExtractor: (req) => {
+    // Custom token extraction logic
+    // By default, uses sophisticated extractToken from @naman_deep_singh/security
+    // that checks Authorization headers, cookies, query params, and body
+    return req.headers.authorization?.substring(7);
   }
 }));
 ```

package/dist/cjs/core/health.d.ts

@@ -0,0 +1,5 @@
+import type { Application, RequestHandler } from 'express';
+import type { HealthCheckConfig, ServerPlugin } from '../types';
+export declare function createHealthCheck(config?: HealthCheckConfig): RequestHandler;
+export declare function withHealthCheck(path?: string, config?: HealthCheckConfig): ServerPlugin;
+export declare function addHealthCheck(app: Application, path?: string, config?: HealthCheckConfig): void;

package/dist/cjs/{health.js → core/health.js}

@@ -9,7 +9,7 @@ function createHealthCheck(config = {}) {
         try {
             const checks = {
                 server: true,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             };
             // Run custom health checks
             for (const check of customChecks) {
@@ -20,16 +20,16 @@ function createHealthCheck(config = {}) {
                     checks[check.name] = false;
                 }
             }
-            const isHealthy = Object.values(checks).every(status => status === true || typeof status === 'number');
+            const isHealthy = Object.values(checks).every((status) => status === true || typeof status === 'number');
             res.status(isHealthy ? 200 : 503).json({
                 status: isHealthy ? 'healthy' : 'unhealthy',
-                checks
+                checks,
             });
         }
         catch (error) {
             res.status(503).json({
                 status: 'unhealthy',
-                error: 'Health check failed'
+                error: 'Health check failed',
             });
         }
     };

package/dist/cjs/{periodic-health.d.ts → core/periodic-health.d.ts}

@@ -1,4 +1,4 @@
-import { PeriodicHealthCheckConfig } from './types';
+import type { PeriodicHealthCheckConfig } from '../types';
 export declare class PeriodicHealthMonitor {
     private intervals;
     private config;

package/dist/cjs/{periodic-health.js → core/periodic-health.js}

@@ -12,7 +12,7 @@ class PeriodicHealthMonitor {
             return;
         }
         const interval = this.config.interval || 30000;
-        this.config.services.forEach(service => {
+        this.config.services.forEach((service) => {
             const intervalId = setInterval(async () => {
                 await this.checkServiceHealth(service);
             }, interval);
@@ -21,7 +21,7 @@ class PeriodicHealthMonitor {
         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.forEach((interval) => clearInterval(interval));
         this.intervals = [];
         console.log(`🛑 ${this.serviceName}: Periodic health monitoring stopped`);
     }
@@ -34,8 +34,8 @@ class PeriodicHealthMonitor {
                 method: 'GET',
                 signal: controller.signal,
                 headers: {
-                    'User-Agent': `${this.serviceName}-health-monitor`
-                }
+                    'User-Agent': `${this.serviceName}-health-monitor`,
+                },
             });
             clearTimeout(timeoutId);
             if (response.ok) {

package/dist/{types → cjs/core}/server.d.ts

@@ -1,6 +1,7 @@
-import express from 'express';
-import { Server } from 'http';
-import { ServerConfig, SocketIOConfig } from './types';
+import { ICache, SessionStore } from '@naman_deep_singh/cache';
+import type { Server } from 'http';
+import type { Application } from 'express';
+import type { ServerConfig, SocketIOConfig } from '../types';
 export interface GrpcService {
     service: Record<string, unknown>;
     implementation: Record<string, (...args: unknown[]) => unknown>;
@@ -26,7 +27,7 @@ export interface ServerInstanceConfig extends Required<Omit<ServerConfig, 'socke
     socketIO?: SocketIOConfig;
 }
 export interface ServerInstance {
-    app: express.Application;
+    app: Application;
     server?: Server;
     config: ServerInstanceConfig;
     start(): Promise<ServerInstance>;
@@ -46,11 +47,11 @@ export interface ServerInfo {
     startTime: Date;
 }
 export declare class ExpressServer implements ServerInstance {
-    app: express.Application;
+    app: Application;
     server?: Server;
     config: ServerInstanceConfig;
-    cache?: import('@naman_deep_singh/cache').ICache<unknown>;
-    sessionStore?: import('@naman_deep_singh/cache').SessionStore | undefined;
+    cache?: ICache<unknown>;
+    sessionStore?: SessionStore | undefined;
     private status;
     private grpcServices;
     private grpcServer?;

package/dist/cjs/{server.js → core/server.js}

@@ -1,15 +1,49 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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"));
 const cache_1 = require("@naman_deep_singh/cache");
+const express_1 = __importStar(require("express"));
+const periodic_health_1 = require("./periodic-health");
+const shutdown_1 = require("./shutdown");
+const middleware_1 = require("../middleware");
 class ExpressServer {
     constructor(name = 'Express Server', version = '1.0.0', config = {}) {
         this.status = 'stopped';
@@ -31,7 +65,7 @@ class ExpressServer {
             socketIO: config.socketIO,
             periodicHealthCheck: config.periodicHealthCheck || { enabled: false },
             cache: config.cache || { enabled: false },
-            session: config.session || { enabled: false }
+            session: config.session || { enabled: false },
         };
         // Initialize locals for cache/session
         this.app.locals.cache = undefined;
@@ -66,7 +100,7 @@ class ExpressServer {
         }
         // Apply JSON parser if enabled
         if (this.config.json) {
-            this.app.use(express_1.default.json());
+            this.app.use((0, express_1.json)());
         }
         // Apply cookie parser if enabled
         if (this.config.cookieParser) {
@@ -79,21 +113,24 @@ class ExpressServer {
             }
         }
         // Apply custom middleware
-        if (this.config.customMiddleware && this.config.customMiddleware.length > 0) {
-            this.config.customMiddleware.forEach(middleware => {
+        if (this.config.customMiddleware &&
+            this.config.customMiddleware.length > 0) {
+            this.config.customMiddleware.forEach((middleware) => {
                 this.app.use(middleware);
             });
         }
         // Add health check if enabled
         if (this.config.healthCheck) {
-            const healthPath = typeof this.config.healthCheck === 'string' ? this.config.healthCheck : '/health';
+            const healthPath = typeof this.config.healthCheck === 'string'
+                ? this.config.healthCheck
+                : '/health';
             this.app.get(healthPath, async (req, res) => {
                 const base = {
                     status: 'healthy',
                     service: this.config.name,
                     version: this.config.version,
                     uptime: Date.now() - this.config.startTime.getTime(),
-                    timestamp: new Date().toISOString()
+                    timestamp: new Date().toISOString(),
                 };
                 // If cache is enabled, include its health
                 const cache = req.app.locals.cache;
@@ -102,7 +139,12 @@ class ExpressServer {
                         base.cache = await cache.isAlive();
                     }
                     catch (e) {
-                        base.cache = { isAlive: false, adapter: 'unknown', timestamp: new Date(), error: e.message };
+                        base.cache = {
+                            isAlive: false,
+                            adapter: 'unknown',
+                            timestamp: new Date(),
+                            error: e.message,
+                        };
                     }
                 }
                 res.status(200).json(base);
@@ -121,7 +163,11 @@ class ExpressServer {
                     }
                     console.log(`🔄 [${serverName}] Initializing cache adapter: ${config.cache.adapter || 'memory'}...`);
                     // Use createWithFallback to prefer primary and fall back to memory when configured
-                    const cfg = { ...(cacheConfig || {}), ttl: cacheConfig?.ttl ?? config.cache?.defaultTTL };
+                    const cfg = {
+                        ...(cacheConfig || {}),
+                        ttl: cacheConfig?.ttl ??
+                            config.cache?.defaultTTL,
+                    };
                     const cache = await cache_1.CacheFactory.createWithFallback(cfg);
                     this.app.locals.cache = cache;
                     this.cache = cache;
@@ -131,7 +177,7 @@ class ExpressServer {
                         req.cache = cache;
                         next();
                     });
-                    console.log(`✅ [${serverName}] Cache initialized successfully (adapter: ${(cacheConfig.adapter || 'memory')})`);
+                    console.log(`✅ [${serverName}] Cache initialized successfully (adapter: ${cacheConfig.adapter || 'memory'})`);
                 }
                 catch (err) {
                     console.error(`❌ [${serverName}] Failed to initialize cache (fallback to memory if enabled):`, err instanceof Error ? err.message : err);
@@ -140,7 +186,8 @@ class ExpressServer {
             }
             // Initialize session if enabled
             if (config.session && config.session.enabled) {
-                const cookieName = config.session.cookieName || `${serverName.replace(/\s+/g, '_').toLowerCase()}.sid`;
+                const cookieName = config.session.cookieName ||
+                    `${serverName.replace(/\s+/g, '_').toLowerCase()}.sid`;
                 const ttl = config.session.ttl ?? 3600;
                 let cache = this.app.locals.cache;
                 if (!cache) {
@@ -168,9 +215,7 @@ class ExpressServer {
                     this.sessionStore = store;
                     // attach session middleware globally so req.sessionStore is available
                     try {
-                        // eslint-disable-next-line @typescript-eslint/no-var-requires
-                        const { useSession } = require('./middleware');
-                        this.app.use(useSession(cookieName));
+                        this.app.use((0, middleware_1.useSession)(cookieName));
                         console.log(`✅ [${serverName}] Session middleware enabled (cookie: ${cookieName}, TTL: ${ttl}s)`);
                     }
                     catch (err) {
@@ -224,7 +269,7 @@ class ExpressServer {
                                 catch (e) {
                                     // SessionStore may not have close; ignore
                                 }
-                            }
+                            },
                         });
                     }
                     // Start periodic health monitoring after server is running
@@ -274,7 +319,7 @@ class ExpressServer {
             port: this.config.port,
             uptime: Date.now() - this.config.startTime.getTime(),
             status: this.status,
-            startTime: this.config.startTime
+            startTime: this.config.startTime,
         };
     }
     addGrpcService(service, implementation, port = 50051) {
@@ -282,7 +327,6 @@ class ExpressServer {
         // Lazy load gRPC to avoid dependency issues
         if (!this.grpcServer) {
             try {
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
                 const grpc = require('@grpc/grpc-js');
                 this.grpcServer = new grpc.Server();
                 // Add all services
@@ -302,7 +346,6 @@ class ExpressServer {
     addRpcMethods(methods, path = '/rpc') {
         Object.assign(this.rpcMethods, methods);
         try {
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
             const jayson = require('jayson');
             const rpcServer = jayson.server(this.rpcMethods);
             this.app.use(path, rpcServer.middleware());
@@ -313,17 +356,20 @@ class ExpressServer {
         }
     }
     addWebhook(config) {
-        this.app.post(config.path, express_1.default.raw({ type: 'application/json' }), async (req, res) => {
+        this.app.post(config.path, (0, express_1.raw)({ type: 'application/json' }), async (req, res) => {
             try {
                 // Verify signature if secret provided
                 if (config.secret) {
-                    const signature = req.headers['x-hub-signature-256'] || req.headers['x-signature-256'];
+                    const signature = req.headers['x-hub-signature-256'] ||
+                        req.headers['x-signature-256'];
                     if (signature) {
                         const expectedSignature = crypto_1.default
                             .createHmac('sha256', config.secret)
                             .update(req.body)
                             .digest('hex');
-                        const providedSignature = Array.isArray(signature) ? signature[0] : signature;
+                        const providedSignature = Array.isArray(signature)
+                            ? signature[0]
+                            : signature;
                         if (!providedSignature.includes(expectedSignature)) {
                             return res.status(401).json({ error: 'Invalid signature' });
                         }
@@ -347,7 +393,6 @@ class ExpressServer {
             throw new Error(`${this.config.name}: Server must be started before adding Socket.IO`);
         }
         try {
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
             const { Server } = require('socket.io');
             // Configure CORS
             const corsConfig = config.cors === true
@@ -356,7 +401,7 @@ class ExpressServer {
             // Create Socket.IO server
             const io = new Server(this.server, {
                 cors: config.cors ? corsConfig : undefined,
-                path: config.path || '/socket.io'
+                path: config.path || '/socket.io',
             });
             // Store reference for cleanup
             this.socketIO = io;

package/dist/cjs/{shutdown.d.ts → core/shutdown.d.ts}

@@ -1,5 +1,5 @@
-import { Server } from 'http';
-import { GracefulShutdownConfig, ServerPlugin } from './types';
+import type { Server } from 'http';
+import type { GracefulShutdownConfig, ServerPlugin } from '../types';
 export declare function createGracefulShutdown(server: Server, config?: GracefulShutdownConfig): void;
 export declare function withGracefulShutdown(config?: GracefulShutdownConfig): ServerPlugin;
 export declare function startServerWithShutdown(app: import('express').Application, port: number, shutdownConfig?: GracefulShutdownConfig, serverName?: string, serverVersion?: string): Server;

package/dist/cjs/{shutdown.js → core/shutdown.js}

@@ -37,6 +37,7 @@ function withGracefulShutdown(config = {}) {
     return (app, serverConfig) => {
         // This plugin needs to be applied after server.listen()
         // Store config for later use
+        ;
         app.__gracefulShutdownConfig = config;
     };
 }
@@ -50,7 +51,7 @@ function startServerWithShutdown(app, port, shutdownConfig = {}, serverName, ser
     const enhancedConfig = {
         ...config,
         serverName,
-        serverVersion
+        serverVersion,
     };
     createGracefulShutdown(server, enhancedConfig);
     return server;

package/dist/cjs/index.d.ts

@@ -1,19 +1,19 @@
-export { ExpressServer, createServer } from './server';
-export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig } from './server';
+export { ExpressServer, createServer } from './core/server';
+export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig, } from './core/server';
 export { Request, Response, NextFunction, Router, Application } from 'express';
 export type { RequestHandler, ErrorRequestHandler } from 'express';
-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, cacheResponse, useSession, type ValidationRule, type RateLimitConfig, type AuthConfig } from './middleware';
-export { getEnv, getEnvNumber, getEnvBoolean } from './utils';
-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';
+export { createHealthCheck, withHealthCheck, addHealthCheck, } from './core/health';
+export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown, } from './core/shutdown';
+export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, cacheResponse, useSession, type ValidationRule, type RateLimitConfig, type AuthConfig, } from './middleware';
+export { getEnv, getEnvNumber, getEnvBoolean, } from './utils/utils';
+export { PeriodicHealthMonitor } from './core/periodic-health';
+export type { ServerConfig, HealthCheckConfig, HealthCheck, GracefulShutdownConfig, ServerPlugin, SocketIOConfig, SocketInstance, PeriodicHealthCheckConfig, HealthCheckService, } from './types';
+import { addHealthCheck, createHealthCheck, withHealthCheck } from './core/health';
+import { PeriodicHealthMonitor } from './core/periodic-health';
+import { ExpressServer, createServer } from './core/server';
+import { createGracefulShutdown, startServerWithShutdown, withGracefulShutdown } from './core/shutdown';
+import { createAuthMiddleware, createErrorHandler, createLoggingMiddleware, createRateLimitMiddleware, createRequestIdMiddleware, createValidationMiddleware, rateLimit, requireAuth, validateFields, withAuth, withErrorHandler, withLogging, withRateLimit, withRequestId, withValidation } from './middleware';
+import { getEnv, getEnvBoolean, getEnvNumber } from './utils/utils';
 declare const ServerUtils: {
     createServer: typeof createServer;
     ExpressServer: typeof ExpressServer;

package/dist/cjs/index.js

@@ -2,19 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PeriodicHealthMonitor = exports.getEnvBoolean = exports.getEnvNumber = exports.getEnv = exports.useSession = exports.cacheResponse = 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");
+var server_1 = require("./core/server");
 Object.defineProperty(exports, "ExpressServer", { enumerable: true, get: function () { return server_1.ExpressServer; } });
 Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
 // Express re-exports (to avoid direct Express dependency in services)
 var express_1 = require("express");
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return express_1.Router; } });
 // Health check utilities
-var health_1 = require("./health");
+var health_1 = require("./core/health");
 Object.defineProperty(exports, "createHealthCheck", { enumerable: true, get: function () { return health_1.createHealthCheck; } });
 Object.defineProperty(exports, "withHealthCheck", { enumerable: true, get: function () { return health_1.withHealthCheck; } });
 Object.defineProperty(exports, "addHealthCheck", { enumerable: true, get: function () { return health_1.addHealthCheck; } });
 // Graceful shutdown utilities
-var shutdown_1 = require("./shutdown");
+var shutdown_1 = require("./core/shutdown");
 Object.defineProperty(exports, "createGracefulShutdown", { enumerable: true, get: function () { return shutdown_1.createGracefulShutdown; } });
 Object.defineProperty(exports, "withGracefulShutdown", { enumerable: true, get: function () { return shutdown_1.withGracefulShutdown; } });
 Object.defineProperty(exports, "startServerWithShutdown", { enumerable: true, get: function () { return shutdown_1.startServerWithShutdown; } });
@@ -38,20 +38,20 @@ Object.defineProperty(exports, "requireAuth", { enumerable: true, get: function
 Object.defineProperty(exports, "cacheResponse", { enumerable: true, get: function () { return middleware_1.cacheResponse; } });
 Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return middleware_1.useSession; } });
 // Utility functions
-var utils_1 = require("./utils");
+var utils_1 = require("./utils/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");
+var periodic_health_1 = require("./core/periodic-health");
 Object.defineProperty(exports, "PeriodicHealthMonitor", { enumerable: true, get: function () { return periodic_health_1.PeriodicHealthMonitor; } });
+const health_2 = require("./core/health");
+const periodic_health_2 = require("./core/periodic-health");
 // Import all exports for default export
-const server_2 = require("./server");
-const health_2 = require("./health");
-const shutdown_2 = require("./shutdown");
+const server_2 = require("./core/server");
+const shutdown_2 = require("./core/shutdown");
 const middleware_2 = require("./middleware");
-const utils_2 = require("./utils");
-const periodic_health_2 = require("./periodic-health");
+const utils_2 = require("./utils/utils");
 // Default export for namespace usage
 const ServerUtils = {
     // Server creation

package/dist/cjs/middleware/auth.middleware.d.ts

@@ -0,0 +1,7 @@
+import type { Request, RequestHandler } from 'node_modules/@types/express';
+export interface AuthConfig {
+    secret: string;
+    unauthorizedMessage?: string;
+    tokenExtractor?: (req: Request) => string | null;
+}
+export declare function createAuthMiddleware(config: AuthConfig): RequestHandler;

package/dist/cjs/middleware/auth.middleware.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthMiddleware = createAuthMiddleware;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+const security_1 = require("@naman_deep_singh/security");
+function createAuthMiddleware(config) {
+    const { secret, unauthorizedMessage = 'Unauthorized access', tokenExtractor = (req) => (0, security_1.extractToken)({
+        header: req.headers.authorization || undefined,
+        cookies: req.cookies,
+        query: req.query,
+        body: req.body,
+    }), } = config;
+    return async (req, res, next) => {
+        try {
+            // Extract token from request
+            const token = tokenExtractor(req);
+            if (!token) {
+                const error = new errors_utils_1.UnauthorizedError(unauthorizedMessage, {
+                    reason: 'No token provided',
+                });
+                return next(error);
+            }
+            // Use safe verify token from security package
+            const result = (0, security_1.safeVerifyToken)(token, secret);
+            if (!result.valid) {
+                const error = new errors_utils_1.UnauthorizedError(unauthorizedMessage, {
+                    reason: 'Invalid or expired token',
+                    originalError: result.error?.message,
+                });
+                return next(error);
+            }
+            // Attach the verified payload as user
+            req.user = result.payload;
+            next();
+        }
+        catch (error) {
+            const unauthorizedError = new errors_utils_1.UnauthorizedError(unauthorizedMessage, error instanceof Error ? { originalError: error.message } : error);
+            return next(unauthorizedError);
+        }
+    };
+}

package/dist/cjs/middleware/cache.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { RequestHandler } from 'node_modules/@types/express';
+export declare function cacheResponse(ttl?: number): RequestHandler;

package/dist/cjs/middleware/cache.middleware.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheResponse = cacheResponse;
+// Cache response middleware (per-route opt-in)
+function cacheResponse(ttl) {
+    return async (req, res, next) => {
+        try {
+            if (req.method !== 'GET')
+                return next();
+            const cache = (req.cache ?? req.app.locals.cache);
+            const defaultTTL = req.app.locals.cacheDefaultTTL;
+            if (!cache || typeof cache.get !== 'function')
+                return next();
+            const key = `${req.originalUrl}`;
+            try {
+                const cached = await cache.get(key);
+                if (cached !== null && cached !== undefined) {
+                    res.setHeader('X-Cache', 'HIT');
+                    return res.json(cached);
+                }
+            }
+            catch (cacheErr) {
+                console.error(`[Cache] Failed to retrieve key "${key}":`, cacheErr);
+                // Continue without cache hit
+            }
+            const originalJson = res.json.bind(res);
+            res.json = (body) => {
+                try {
+                    const expiry = ttl ?? defaultTTL;
+                    if (expiry && cache && typeof cache.set === 'function') {
+                        ;
+                        cache.set(key, body, expiry).catch((err) => {
+                            console.error(`[Cache] Failed to set key "${key}" with TTL ${expiry}:`, err);
+                        });
+                    }
+                    else if (cache) {
+                        if (typeof cache.set === 'function') {
+                            ;
+                            cache.set(key, body).catch((err) => {
+                                console.error(`[Cache] Failed to set key "${key}":`, err);
+                            });
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error(`[Cache] Error during cache.set operation:`, e);
+                }
+                res.setHeader('X-Cache', 'MISS');
+                return originalJson(body);
+            };
+            next();
+        }
+        catch (err) {
+            console.error('[Cache] Unexpected error in cacheResponse middleware:', err);
+            next();
+        }
+    };
+}

package/dist/cjs/middleware/errorHandler.middleware.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorRequestHandler } from 'node_modules/@types/express';
+export declare function createErrorHandler(): ErrorRequestHandler;

package/dist/cjs/middleware/errorHandler.middleware.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorHandler = createErrorHandler;
+// Error handling middleware
+function createErrorHandler() {
+    return (err, req, res, next) => {
+        console.error('Error:', err);
+        if (res.headersSent) {
+            return next(err);
+        }
+        // Type guard for error objects
+        const errorObj = err;
+        const status = errorObj.status || errorObj.statusCode || 500;
+        const message = process.env.NODE_ENV === 'production'
+            ? 'Internal Server Error'
+            : errorObj.message || 'Unknown error';
+        res.status(status).json({
+            success: false,
+            message,
+            data: undefined,
+            error: {
+                message,
+                ...(process.env.NODE_ENV !== 'production' && {
+                    details: { stack: errorObj.stack },
+                }),
+            },
+            meta: null,
+        });
+    };
+}