@naman_deep_singh/server-utils 1.3.0 → 1.4.0

package/dist/cjs/middleware/session.middleware.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSession = useSession;
+// Session middleware helper (attaches sessionStore and helpers to req)
+function useSession(cookieName) {
+    return async (req, res, next) => {
+        try {
+            const store = req.app.locals.sessionStore;
+            if (!store)
+                return next();
+            const name = cookieName || req.app.locals.sessionCookieName || 'sid';
+            let sid = req.cookies?.[name];
+            if (!sid) {
+                const cookieHeader = req.headers.cookie;
+                if (cookieHeader) {
+                    const match = cookieHeader.split(';').map(s => s.trim()).find(s => s.startsWith(name + '='));
+                    if (match)
+                        sid = match.split('=')[1];
+                }
+            }
+            req.sessionId = sid;
+            req.sessionStore = store;
+            req.getSession = async () => {
+                if (!sid)
+                    return null;
+                try {
+                    return await store.get(sid);
+                }
+                catch (err) {
+                    console.error(`[Session] Failed to get session "${sid}":`, err);
+                    throw err;
+                }
+            };
+            req.createSession = async (id, data, ttl) => {
+                try {
+                    return await store.create(id, data, ttl);
+                }
+                catch (err) {
+                    console.error(`[Session] Failed to create session "${id}":`, err);
+                    throw err;
+                }
+            };
+            next();
+        }
+        catch (err) {
+            console.error('[Session] Unexpected error in useSession middleware:', err);
+            next();
+        }
+    };
+}

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

@@ -0,0 +1,11 @@
+import { RequestHandler } from "node_modules/@types/express";
+export interface ValidationRule {
+    field: string;
+    required?: boolean;
+    type?: 'string' | 'number' | 'email' | 'boolean';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    custom?: (value: unknown) => boolean | string;
+}
+export declare function createValidationMiddleware(rules: ValidationRule[]): RequestHandler;

package/dist/cjs/middleware/validation.middleware.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationMiddleware = createValidationMiddleware;
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
+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 === '')) {
+                errors.push(`${rule.field} is required`);
+                continue;
+            }
+            if (value === undefined || value === null)
+                continue;
+            if (rule.type) {
+                switch (rule.type) {
+                    case 'email':
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        if (!emailRegex.test(value)) {
+                            errors.push(`${rule.field} must be a valid email`);
+                        }
+                        break;
+                    case 'string':
+                        if (typeof value !== 'string') {
+                            errors.push(`${rule.field} must be a string`);
+                        }
+                        break;
+                    case 'number':
+                        if (typeof value !== 'number' && isNaN(Number(value))) {
+                            errors.push(`${rule.field} must be a number`);
+                        }
+                        break;
+                    case 'boolean':
+                        if (typeof value !== 'boolean') {
+                            errors.push(`${rule.field} must be a boolean`);
+                        }
+                        break;
+                }
+            }
+            if (rule.minLength && value.length < rule.minLength) {
+                errors.push(`${rule.field} must be at least ${rule.minLength} characters`);
+            }
+            if (rule.maxLength && value.length > rule.maxLength) {
+                errors.push(`${rule.field} must be no more than ${rule.maxLength} characters`);
+            }
+            if (rule.pattern && !rule.pattern.test(value)) {
+                errors.push(`${rule.field} format is invalid`);
+            }
+            if (rule.custom) {
+                const result = rule.custom(value);
+                if (result !== true) {
+                    errors.push(typeof result === 'string' ? result : `${rule.field} is invalid`);
+                }
+            }
+        }
+        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
+            });
+            return next(validationError);
+        }
+        next();
+    };
+}

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

@@ -0,0 +1,5 @@
+import { Application, RequestHandler } from 'express';
+import { 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/esm/{periodic-health.d.ts → core/periodic-health.d.ts}

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

package/dist/esm/{server.d.ts → core/server.d.ts}

@@ -1,6 +1,6 @@
-import express from 'express';
 import { Server } from 'http';
-import { ServerConfig, SocketIOConfig } from './types';
+import { Application } from 'express';
+import { ServerConfig, SocketIOConfig } from '../types';
 export interface GrpcService {
     service: Record<string, unknown>;
     implementation: Record<string, (...args: unknown[]) => unknown>;
@@ -26,7 +26,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,7 +46,7 @@ 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>;

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

@@ -1,8 +1,8 @@
-import express from 'express';
-import { createGracefulShutdown } from './shutdown';
-import { PeriodicHealthMonitor } from './periodic-health';
-import crypto from 'crypto';
+import express, { json, raw } from 'express';
 import { CacheFactory, SessionStore } from '@naman_deep_singh/cache';
+import crypto from 'crypto';
+import { PeriodicHealthMonitor } from './periodic-health';
+import { createGracefulShutdown } from './shutdown';
 export class ExpressServer {
     constructor(name = 'Express Server', version = '1.0.0', config = {}) {
         this.status = 'stopped';
@@ -59,7 +59,7 @@ export class ExpressServer {
         }
         // Apply JSON parser if enabled
         if (this.config.json) {
-            this.app.use(express.json());
+            this.app.use(json());
         }
         // Apply cookie parser if enabled
         if (this.config.cookieParser) {
@@ -162,7 +162,7 @@ export class ExpressServer {
                     // attach session middleware globally so req.sessionStore is available
                     try {
                         // eslint-disable-next-line @typescript-eslint/no-var-requires
-                        const { useSession } = require('./middleware');
+                        const { useSession } = require('../middleware/middleware');
                         this.app.use(useSession(cookieName));
                         console.log(`✅ [${serverName}] Session middleware enabled (cookie: ${cookieName}, TTL: ${ttl}s)`);
                     }
@@ -306,7 +306,7 @@ export class ExpressServer {
         }
     }
     addWebhook(config) {
-        this.app.post(config.path, express.raw({ type: 'application/json' }), async (req, res) => {
+        this.app.post(config.path, raw({ type: 'application/json' }), async (req, res) => {
             try {
                 // Verify signature if secret provided
                 if (config.secret) {

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

@@ -1,5 +1,5 @@
 import { Server } from 'http';
-import { GracefulShutdownConfig, ServerPlugin } from './types';
+import { 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/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 { 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';
-export { PeriodicHealthMonitor } from './periodic-health';
+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 './server';
-import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
-import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
+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';
-import { PeriodicHealthMonitor } from './periodic-health';
+import { getEnv, getEnvNumber, getEnvBoolean } from './utils/utils';
+import { PeriodicHealthMonitor } from './core/periodic-health';
 declare const ServerUtils: {
     createServer: typeof createServer;
     ExpressServer: typeof ExpressServer;

package/dist/esm/index.js

@@ -1,24 +1,24 @@
 // Core server utilities
-export { ExpressServer, createServer } from './server';
+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 './health';
+export { createHealthCheck, withHealthCheck, addHealthCheck } from './core/health';
 // Graceful shutdown utilities
-export { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './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';
 // Utility functions
-export { getEnv, getEnvNumber, getEnvBoolean } from './utils';
+export { getEnv, getEnvNumber, getEnvBoolean } from './utils/utils';
 // Periodic health monitoring
-export { PeriodicHealthMonitor } from './periodic-health';
+export { PeriodicHealthMonitor } from './core/periodic-health';
 // Import all exports for default export
-import { ExpressServer, createServer } from './server';
-import { createHealthCheck, withHealthCheck, addHealthCheck } from './health';
-import { createGracefulShutdown, withGracefulShutdown, startServerWithShutdown } from './shutdown';
+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';
-import { PeriodicHealthMonitor } from './periodic-health';
+import { getEnv, getEnvNumber, getEnvBoolean } from './utils/utils';
+import { PeriodicHealthMonitor } from './core/periodic-health';
 // Default export for namespace usage
 const ServerUtils = {
     // Server creation

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

@@ -0,0 +1,7 @@
+import { 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/esm/middleware/auth.middleware.js

@@ -0,0 +1,38 @@
+import { extractToken, safeVerifyToken } from "@naman_deep_singh/security";
+import { UnauthorizedError } from "@naman_deep_singh/errors-utils";
+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;
+    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'
+                });
+                return next(error);
+            }
+            // Use safe verify token from security package
+            const result = safeVerifyToken(token, secret);
+            if (!result.valid) {
+                const error = new 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 UnauthorizedError(unauthorizedMessage, error instanceof Error ? { originalError: error.message } : error);
+            return next(unauthorizedError);
+        }
+    };
+}

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

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

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

@@ -0,0 +1,53 @@
+// Cache response middleware (per-route opt-in)
+export 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/esm/middleware/errorHandler.middleware.d.ts

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

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

@@ -0,0 +1,25 @@
+// Error handling middleware
+export 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
+        });
+    };
+}

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

@@ -0,0 +1,10 @@
+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 { 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';

package/dist/esm/middleware/index.js

@@ -0,0 +1,20 @@
+// Authentication Middleware
+export { createAuthMiddleware } from './auth.middleware';
+// Cache Middleware
+export { cacheResponse } from './cache.middleware';
+// Error Handler Middleware
+export { createErrorHandler } from './errorHandler.middleware';
+// Logging Middleware
+export { createLoggingMiddleware } from './logging.middleware';
+// Rate Limiter 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';
+// Plugin middleware functions (for application-level 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';

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

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

package/dist/esm/middleware/logging.middleware.js

@@ -0,0 +1,16 @@
+// Logging middleware
+export function createLoggingMiddleware(format = 'simple') {
+    return (req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+            const duration = Date.now() - start;
+            if (format === 'detailed') {
+                console.log(`${req.method} ${req.url} - ${res.statusCode} - ${duration}ms - ${req.ip}`);
+            }
+            else {
+                console.log(`${req.method} ${req.url} - ${res.statusCode}`);
+            }
+        });
+        next();
+    };
+}

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

@@ -0,0 +1,14 @@
+import { RequestHandler } from 'express';
+import { ServerPlugin } from '../types';
+import { ValidationRule } from './validation.middleware';
+import { RateLimitConfig } from './rateLimiter.middleware';
+import { AuthConfig } from './auth.middleware';
+export declare function withLogging(format?: 'simple' | 'detailed'): ServerPlugin;
+export declare function withErrorHandler(): ServerPlugin;
+export declare function withRequestId(): ServerPlugin;
+export declare function withValidation(rules: ValidationRule[]): ServerPlugin;
+export declare function withRateLimit(config?: RateLimitConfig): ServerPlugin;
+export declare function withAuth(config: AuthConfig): ServerPlugin;
+export declare function validateFields(rules: ValidationRule[]): RequestHandler;
+export declare function rateLimit(config?: RateLimitConfig): RequestHandler;
+export declare function requireAuth(config: AuthConfig): RequestHandler;

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

@@ -0,0 +1,47 @@
+import { createLoggingMiddleware } from './logging.middleware';
+import { createErrorHandler } from './errorHandler.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) => {
+        app.use(createLoggingMiddleware(format));
+    };
+}
+export function withErrorHandler() {
+    return (app) => {
+        app.use(createErrorHandler());
+    };
+}
+export function withRequestId() {
+    return (app) => {
+        app.use(createRequestIdMiddleware());
+    };
+}
+export function withValidation(rules) {
+    return (app) => {
+        app.use(createValidationMiddleware(rules));
+    };
+}
+export function withRateLimit(config = {}) {
+    return (app) => {
+        app.use(createRateLimitMiddleware(config));
+    };
+}
+export function withAuth(config) {
+    return (app) => {
+        app.use(createAuthMiddleware(config));
+    };
+}
+// Convenience functions for route-specific middleware
+export function validateFields(rules) {
+    return createValidationMiddleware(rules);
+}
+export function rateLimit(config = {}) {
+    return createRateLimitMiddleware(config);
+}
+export function requireAuth(config) {
+    return createAuthMiddleware(config);
+}

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

@@ -0,0 +1,8 @@
+import { Request, RequestHandler } from "node_modules/@types/express";
+export interface RateLimitConfig {
+    windowMs?: number;
+    maxRequests?: number;
+    message?: string;
+    keyGenerator?: (req: Request) => string;
+}
+export declare function createRateLimitMiddleware(config?: RateLimitConfig): RequestHandler;

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

@@ -0,0 +1,32 @@
+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;
+    return (req, res, next) => {
+        const key = keyGenerator(req);
+        const now = Date.now();
+        const record = rateLimitStore.get(key);
+        if (!record || now > record.resetTime) {
+            rateLimitStore.set(key, {
+                count: 1,
+                resetTime: now + windowMs
+            });
+            return next();
+        }
+        if (record.count >= maxRequests) {
+            return res.status(429).json({
+                success: false,
+                message,
+                data: undefined,
+                error: {
+                    message,
+                    details: {
+                        retryAfter: Math.ceil((record.resetTime - now) / 1000)
+                    }
+                },
+                meta: null
+            });
+        }
+        record.count++;
+        next();
+    };
+}

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

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

package/dist/esm/middleware/requestId.middleware.js

@@ -0,0 +1,9 @@
+// Request ID middleware
+export function createRequestIdMiddleware() {
+    return (req, res, next) => {
+        const requestId = Math.random().toString(36).substring(2, 15);
+        req.requestId = requestId;
+        res.setHeader('X-Request-ID', requestId);
+        next();
+    };
+}

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

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