@naman_deep_singh/server-utils 1.4.0 → 1.4.2

package/dist/esm/core/health.js

@@ -4,7 +4,7 @@ export function createHealthCheck(config = {}) {
         try {
             const checks = {
                 server: true,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             };
             // Run custom health checks
             for (const check of customChecks) {
@@ -15,16 +15,16 @@ export 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/esm/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/esm/core/periodic-health.js

@@ -9,7 +9,7 @@ export 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);
@@ -18,7 +18,7 @@ export 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`);
     }
@@ -31,8 +31,8 @@ export 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/esm/core/server.d.ts

@@ -1,6 +1,7 @@
-import { Server } from 'http';
-import { Application } from 'express';
-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>;
@@ -49,8 +50,8 @@ export declare class ExpressServer implements ServerInstance {
     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/esm/core/server.js

@@ -1,8 +1,9 @@
-import express, { json, raw } from 'express';
-import { CacheFactory, SessionStore } from '@naman_deep_singh/cache';
 import crypto from 'crypto';
+import { CacheFactory, SessionStore } from '@naman_deep_singh/cache';
+import express, { json, raw } from 'express';
 import { PeriodicHealthMonitor } from './periodic-health';
 import { createGracefulShutdown } from './shutdown';
+import { useSession } from '../middleware';
 export class ExpressServer {
     constructor(name = 'Express Server', version = '1.0.0', config = {}) {
         this.status = 'stopped';
@@ -24,7 +25,7 @@ export 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;
@@ -72,21 +73,24 @@ export 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;
@@ -95,7 +99,12 @@ export 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);
@@ -114,7 +123,11 @@ export 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 CacheFactory.createWithFallback(cfg);
                     this.app.locals.cache = cache;
                     this.cache = cache;
@@ -124,7 +137,7 @@ export 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);
@@ -133,7 +146,8 @@ export 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) {
@@ -161,8 +175,6 @@ export 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/middleware');
                         this.app.use(useSession(cookieName));
                         console.log(`✅ [${serverName}] Session middleware enabled (cookie: ${cookieName}, TTL: ${ttl}s)`);
                     }
@@ -217,7 +229,7 @@ export class ExpressServer {
                                 catch (e) {
                                     // SessionStore may not have close; ignore
                                 }
-                            }
+                            },
                         });
                     }
                     // Start periodic health monitoring after server is running
@@ -267,7 +279,7 @@ export 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) {
@@ -275,7 +287,6 @@ export 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
@@ -295,7 +306,6 @@ export 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());
@@ -310,13 +320,16 @@ export class ExpressServer {
             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
                             .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' });
                         }
@@ -340,7 +353,6 @@ export 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
@@ -349,7 +361,7 @@ export 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/esm/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/esm/core/shutdown.js

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

package/dist/esm/index.d.ts

@@ -1,19 +1,19 @@
 export { ExpressServer, createServer } from './core/server';
-export type { ServerInstance, ServerInfo, GrpcService, RpcMethod, WebhookConfig } 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 './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 { 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 { ExpressServer, createServer } from './core/server';
-import { createHealthCheck, withHealthCheck, addHealthCheck } from './core/health';
-import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './core/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/utils';
+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/esm/index.js

@@ -3,22 +3,22 @@ export { ExpressServer, createServer } from './core/server';
 // Express re-exports (to avoid direct Express dependency in services)
 export { Router } from 'express';
 // Health check utilities
-export { createHealthCheck, withHealthCheck, addHealthCheck } from './core/health';
+export { createHealthCheck, withHealthCheck, addHealthCheck, } from './core/health';
 // Graceful shutdown utilities
-export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './core/shutdown';
+export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown, } from './core/shutdown';
 // Middleware utilities
-export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, cacheResponse, useSession } from './middleware';
+export { createLoggingMiddleware, createErrorHandler, createRequestIdMiddleware, createValidationMiddleware, createRateLimitMiddleware, createAuthMiddleware, withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, validateFields, rateLimit, requireAuth, cacheResponse, useSession, } from './middleware';
 // Utility functions
-export { getEnv, getEnvNumber, getEnvBoolean } from './utils/utils';
+export { getEnv, getEnvNumber, getEnvBoolean, } from './utils/utils';
 // Periodic health monitoring
 export { PeriodicHealthMonitor } from './core/periodic-health';
+import { addHealthCheck, createHealthCheck, withHealthCheck, } from './core/health';
+import { PeriodicHealthMonitor } from './core/periodic-health';
 // Import all exports for default export
 import { ExpressServer, createServer } from './core/server';
-import { createHealthCheck, withHealthCheck, addHealthCheck } from './core/health';
-import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './core/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/utils';
-import { PeriodicHealthMonitor } from './core/periodic-health';
+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';
 // Default export for namespace usage
 const ServerUtils = {
     // Server creation

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

@@ -1,4 +1,4 @@
-import { Request, RequestHandler } from "node_modules/@types/express";
+import type { Request, RequestHandler } from 'node_modules/@types/express';
 export interface AuthConfig {
     secret: string;
     unauthorizedMessage?: string;

package/dist/esm/middleware/auth.middleware.js

@@ -1,19 +1,19 @@
-import { extractToken, safeVerifyToken } from "@naman_deep_singh/security";
-import { UnauthorizedError } from "@naman_deep_singh/errors-utils";
+import { UnauthorizedError } from '@naman_deep_singh/errors-utils';
+import { extractToken, safeVerifyToken } from '@naman_deep_singh/security';
 export function createAuthMiddleware(config) {
     const { secret, unauthorizedMessage = 'Unauthorized access', tokenExtractor = (req) => extractToken({
         header: req.headers.authorization || undefined,
         cookies: req.cookies,
         query: req.query,
-        body: req.body
-    }) } = config;
+        body: req.body,
+    }), } = config;
     return async (req, res, next) => {
         try {
             // Extract token from request
             const token = tokenExtractor(req);
             if (!token) {
                 const error = new UnauthorizedError(unauthorizedMessage, {
-                    reason: 'No token provided'
+                    reason: 'No token provided',
                 });
                 return next(error);
             }
@@ -22,7 +22,7 @@ export function createAuthMiddleware(config) {
             if (!result.valid) {
                 const error = new UnauthorizedError(unauthorizedMessage, {
                     reason: 'Invalid or expired token',
-                    originalError: result.error?.message
+                    originalError: result.error?.message,
                 });
                 return next(error);
             }

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

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

package/dist/esm/middleware/cache.middleware.js

@@ -25,12 +25,14 @@ export function cacheResponse(ttl) {
                 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);
                             });

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

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

package/dist/esm/middleware/errorHandler.middleware.js

@@ -17,9 +17,11 @@ export function createErrorHandler() {
             data: undefined,
             error: {
                 message,
-                ...(process.env.NODE_ENV !== 'production' && { details: { stack: errorObj.stack } })
+                ...(process.env.NODE_ENV !== 'production' && {
+                    details: { stack: errorObj.stack },
+                }),
             },
-            meta: null
+            meta: null,
         });
     };
 }

package/dist/esm/middleware/index.d.ts

@@ -2,9 +2,9 @@ export { AuthConfig, createAuthMiddleware } from './auth.middleware';
 export { cacheResponse } from './cache.middleware';
 export { createErrorHandler } from './errorHandler.middleware';
 export { createLoggingMiddleware } from './logging.middleware';
-export { RateLimitConfig, createRateLimitMiddleware } from './rateLimiter.middleware';
+export { RateLimitConfig, createRateLimitMiddleware, } from './rateLimiter.middleware';
 export { createRequestIdMiddleware } from './requestId.middleware';
 export { useSession } from './session.middleware';
-export { ValidationRule, createValidationMiddleware } from './validation.middleware';
-export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth } from './plugins.middleware';
-export { validateFields, rateLimit, requireAuth } from './plugins.middleware';
+export { ValidationRule, createValidationMiddleware, } from './validation.middleware';
+export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, } from './plugins.middleware';
+export { validateFields, rateLimit, requireAuth, } from './plugins.middleware';

package/dist/esm/middleware/index.js

@@ -7,14 +7,14 @@ export { createErrorHandler } from './errorHandler.middleware';
 // Logging Middleware
 export { createLoggingMiddleware } from './logging.middleware';
 // Rate Limiter Middleware
-export { createRateLimitMiddleware } from './rateLimiter.middleware';
+export { createRateLimitMiddleware, } from './rateLimiter.middleware';
 // Request ID Middleware
 export { createRequestIdMiddleware } from './requestId.middleware';
 // Session Middleware
 export { useSession } from './session.middleware';
 // Validation Middleware
-export { createValidationMiddleware } from './validation.middleware';
+export { createValidationMiddleware, } from './validation.middleware';
 // Plugin middleware functions (for application-level middleware)
-export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth } from './plugins.middleware';
+export { withLogging, withErrorHandler, withRequestId, withValidation, withRateLimit, withAuth, } from './plugins.middleware';
 // Convenience middleware functions (for route-level middleware)
-export { validateFields, rateLimit, requireAuth } from './plugins.middleware';
+export { validateFields, rateLimit, requireAuth, } from './plugins.middleware';

package/dist/esm/middleware/logging.middleware.d.ts

@@ -1,2 +1,2 @@
-import { RequestHandler } from "node_modules/@types/express";
+import type { RequestHandler } from 'node_modules/@types/express';
 export declare function createLoggingMiddleware(format?: 'simple' | 'detailed'): RequestHandler;

package/dist/esm/middleware/plugins.middleware.d.ts

@@ -1,8 +1,8 @@
-import { RequestHandler } from 'express';
-import { ServerPlugin } from '../types';
-import { ValidationRule } from './validation.middleware';
-import { RateLimitConfig } from './rateLimiter.middleware';
-import { AuthConfig } from './auth.middleware';
+import type { RequestHandler } from 'express';
+import type { ServerPlugin } from '../types';
+import type { AuthConfig } from './auth.middleware';
+import type { RateLimitConfig } from './rateLimiter.middleware';
+import type { ValidationRule } from './validation.middleware';
 export declare function withLogging(format?: 'simple' | 'detailed'): ServerPlugin;
 export declare function withErrorHandler(): ServerPlugin;
 export declare function withRequestId(): ServerPlugin;

package/dist/esm/middleware/plugins.middleware.js

@@ -1,9 +1,9 @@
-import { createLoggingMiddleware } from './logging.middleware';
+import { createAuthMiddleware } from './auth.middleware';
 import { createErrorHandler } from './errorHandler.middleware';
+import { createLoggingMiddleware } from './logging.middleware';
+import { createRateLimitMiddleware } from './rateLimiter.middleware';
 import { createRequestIdMiddleware } from './requestId.middleware';
 import { createValidationMiddleware } from './validation.middleware';
-import { createRateLimitMiddleware } from './rateLimiter.middleware';
-import { createAuthMiddleware } from './auth.middleware';
 // Plugin versions
 export function withLogging(format = 'simple') {
     return (app) => {

package/dist/esm/middleware/rateLimiter.middleware.d.ts

@@ -1,4 +1,4 @@
-import { Request, RequestHandler } from "node_modules/@types/express";
+import type { Request, RequestHandler } from 'node_modules/@types/express';
 export interface RateLimitConfig {
     windowMs?: number;
     maxRequests?: number;

package/dist/esm/middleware/rateLimiter.middleware.js

@@ -1,6 +1,6 @@
 const rateLimitStore = new Map();
 export function createRateLimitMiddleware(config = {}) {
-    const { windowMs = 15 * 60 * 1000, maxRequests = 100, message = 'Too many requests, please try again later', keyGenerator = (req) => req.ip || 'unknown' } = config;
+    const { windowMs = 15 * 60 * 1000, maxRequests = 100, message = 'Too many requests, please try again later', keyGenerator = (req) => req.ip || 'unknown', } = config;
     return (req, res, next) => {
         const key = keyGenerator(req);
         const now = Date.now();
@@ -8,7 +8,7 @@ export function createRateLimitMiddleware(config = {}) {
         if (!record || now > record.resetTime) {
             rateLimitStore.set(key, {
                 count: 1,
-                resetTime: now + windowMs
+                resetTime: now + windowMs,
             });
             return next();
         }
@@ -20,10 +20,10 @@ export function createRateLimitMiddleware(config = {}) {
                 error: {
                     message,
                     details: {
-                        retryAfter: Math.ceil((record.resetTime - now) / 1000)
-                    }
+                        retryAfter: Math.ceil((record.resetTime - now) / 1000),
+                    },
                 },
-                meta: null
+                meta: null,
             });
         }
         record.count++;

package/dist/esm/middleware/requestId.middleware.d.ts

@@ -1,2 +1,2 @@
-import { RequestHandler } from "node_modules/@types/express";
+import type { RequestHandler } from 'node_modules/@types/express';
 export declare function createRequestIdMiddleware(): RequestHandler;

package/dist/esm/middleware/session.middleware.d.ts

@@ -1,2 +1,2 @@
-import { RequestHandler } from "node_modules/@types/express";
+import type { RequestHandler } from 'node_modules/@types/express';
 export declare function useSession(cookieName?: string): RequestHandler;

package/dist/esm/middleware/session.middleware.js

@@ -10,7 +10,10 @@ export function useSession(cookieName) {
             if (!sid) {
                 const cookieHeader = req.headers.cookie;
                 if (cookieHeader) {
-                    const match = cookieHeader.split(';').map(s => s.trim()).find(s => s.startsWith(name + '='));
+                    const match = cookieHeader
+                        .split(';')
+                        .map((s) => s.trim())
+                        .find((s) => s.startsWith(`${name}=`));
                     if (match)
                         sid = match.split('=')[1];
                 }

package/dist/esm/middleware/validation.middleware.d.ts

@@ -1,4 +1,4 @@
-import { RequestHandler } from "node_modules/@types/express";
+import type { RequestHandler } from 'node_modules/@types/express';
 export interface ValidationRule {
     field: string;
     required?: boolean;

package/dist/esm/middleware/validation.middleware.js

@@ -1,10 +1,11 @@
-import { ValidationError } from "@naman_deep_singh/errors-utils";
+import { ValidationError } from '@naman_deep_singh/errors-utils';
 export function createValidationMiddleware(rules) {
     return (req, res, next) => {
         const errors = [];
         for (const rule of rules) {
             const value = req.body[rule.field];
-            if (rule.required && (value === undefined || value === null || value === '')) {
+            if (rule.required &&
+                (value === undefined || value === null || value === '')) {
                 errors.push(`${rule.field} is required`);
                 continue;
             }
@@ -54,7 +55,7 @@ export function createValidationMiddleware(rules) {
         if (errors.length > 0) {
             // Use ValidationError from errors-utils and let error middleware handle response
             const validationError = new ValidationError('Validation failed', {
-                validationErrors: errors
+                validationErrors: errors,
             });
             return next(validationError);
         }

package/dist/esm/types/index.d.ts

@@ -1,4 +1,4 @@
-import express from 'express';
+import type express from 'express';
 export interface CorsOptions {
     origin?: string | string[] | boolean | RegExp | ((origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) => void);
     methods?: string | string[];

package/dist/esm/utils/utils.js

@@ -31,8 +31,8 @@ export function getEnvBoolean(key, defaultValue) {
         return defaultValue;
     }
     const normalized = value.toLowerCase();
-    if (normalized !== "true" && normalized !== "false") {
+    if (normalized !== 'true' && normalized !== 'false') {
         throw new Error(`Environment variable ${key} must be 'true' or 'false'`);
     }
-    return normalized === "true";
+    return normalized === 'true';
 }

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

@@ -1,5 +1,5 @@
-import { Application, RequestHandler } from 'express';
-import { HealthCheckConfig, ServerPlugin } from '../types';
+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;