@naman_deep_singh/server-utils 1.4.0 → 1.4.2

package/README.md

@@ -1,6 +1,6 @@
 # @naman_deep_singh/server-utils
 
-**Version:** 1.4.0 (with integrated cache & session support)
+**Version:** 1.4.2 (with integrated cache & session support)
 
 Extensible server utilities for Express.js microservices with multi-protocol support, integrated caching, session management, and TypeScript.
 

package/dist/cjs/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;

package/dist/cjs/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/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/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/cjs/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/cjs/core/server.js

@@ -38,11 +38,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExpressServer = void 0;
 exports.createServer = createServer;
-const express_1 = __importStar(require("express"));
-const cache_1 = require("@naman_deep_singh/cache");
 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';
@@ -64,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;
@@ -112,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;
@@ -135,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);
@@ -154,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;
@@ -164,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);
@@ -173,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) {
@@ -201,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/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) {
@@ -257,7 +269,7 @@ class ExpressServer {
                                 catch (e) {
                                     // SessionStore may not have close; ignore
                                 }
-                            }
+                            },
                         });
                     }
                     // Start periodic health monitoring after server is running
@@ -307,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) {
@@ -315,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
@@ -335,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());
@@ -350,13 +360,16 @@ 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_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' });
                         }
@@ -380,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
@@ -389,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/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/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 './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/cjs/index.js

@@ -45,13 +45,13 @@ Object.defineProperty(exports, "getEnvBoolean", { enumerable: true, get: functio
 // Periodic health monitoring
 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("./core/server");
-const health_2 = require("./core/health");
 const shutdown_2 = require("./core/shutdown");
 const middleware_2 = require("./middleware");
 const utils_2 = require("./utils/utils");
-const periodic_health_2 = require("./core/periodic-health");
 // Default export for namespace usage
 const ServerUtils = {
     // Server creation

package/dist/cjs/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/cjs/middleware/auth.middleware.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAuthMiddleware = createAuthMiddleware;
-const security_1 = require("@naman_deep_singh/security");
 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;
+        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'
+                    reason: 'No token provided',
                 });
                 return next(error);
             }
@@ -25,7 +25,7 @@ function createAuthMiddleware(config) {
             if (!result.valid) {
                 const error = new errors_utils_1.UnauthorizedError(unauthorizedMessage, {
                     reason: 'Invalid or expired token',
-                    originalError: result.error?.message
+                    originalError: result.error?.message,
                 });
                 return next(error);
             }

package/dist/cjs/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/cjs/middleware/cache.middleware.js

@@ -28,12 +28,14 @@ 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/cjs/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/cjs/middleware/errorHandler.middleware.js

@@ -20,9 +20,11 @@ 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/cjs/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/cjs/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/cjs/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/cjs/middleware/plugins.middleware.js

@@ -9,12 +9,12 @@ exports.withAuth = withAuth;
 exports.validateFields = validateFields;
 exports.rateLimit = rateLimit;
 exports.requireAuth = requireAuth;
-const logging_middleware_1 = require("./logging.middleware");
+const auth_middleware_1 = require("./auth.middleware");
 const errorHandler_middleware_1 = require("./errorHandler.middleware");
+const logging_middleware_1 = require("./logging.middleware");
+const rateLimiter_middleware_1 = require("./rateLimiter.middleware");
 const requestId_middleware_1 = require("./requestId.middleware");
 const validation_middleware_1 = require("./validation.middleware");
-const rateLimiter_middleware_1 = require("./rateLimiter.middleware");
-const auth_middleware_1 = require("./auth.middleware");
 // Plugin versions
 function withLogging(format = 'simple') {
     return (app) => {

package/dist/cjs/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/cjs/middleware/rateLimiter.middleware.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRateLimitMiddleware = createRateLimitMiddleware;
 const rateLimitStore = new Map();
 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();
@@ -11,7 +11,7 @@ function createRateLimitMiddleware(config = {}) {
         if (!record || now > record.resetTime) {
             rateLimitStore.set(key, {
                 count: 1,
-                resetTime: now + windowMs
+                resetTime: now + windowMs,
             });
             return next();
         }
@@ -23,10 +23,10 @@ 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/cjs/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/cjs/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/cjs/middleware/session.middleware.js

@@ -13,7 +13,10 @@ 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/cjs/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/cjs/middleware/validation.middleware.js

@@ -7,7 +7,8 @@ function createValidationMiddleware(rules) {
         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;
             }
@@ -57,7 +58,7 @@ function createValidationMiddleware(rules) {
         if (errors.length > 0) {
             // Use ValidationError from errors-utils and let error middleware handle response
             const validationError = new errors_utils_1.ValidationError('Validation failed', {
-                validationErrors: errors
+                validationErrors: errors,
             });
             return next(validationError);
         }

package/dist/cjs/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/cjs/utils/utils.js

@@ -36,8 +36,8 @@ 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/esm/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;