@naman_deep_singh/server-utils 1.0.8 → 1.2.0

package/dist/esm/server.js

@@ -0,0 +1,386 @@
+import express from 'express';
+import { createGracefulShutdown } from './shutdown';
+import { PeriodicHealthMonitor } from './periodic-health';
+import crypto from 'crypto';
+import { CacheFactory, SessionStore } from '@naman_deep_singh/cache';
+export class ExpressServer {
+    constructor(name = 'Express Server', version = '1.0.0', config = {}) {
+        this.status = 'stopped';
+        this.grpcServices = [];
+        this.rpcMethods = {};
+        this.app = express();
+        this.config = {
+            name,
+            version,
+            startTime: new Date(),
+            port: config.port || 3000,
+            cors: config.cors ?? true,
+            helmet: config.helmet ?? true,
+            json: config.json ?? true,
+            cookieParser: config.cookieParser ?? false,
+            customMiddleware: config.customMiddleware || [],
+            healthCheck: config.healthCheck ?? true,
+            gracefulShutdown: config.gracefulShutdown ?? true,
+            socketIO: config.socketIO,
+            periodicHealthCheck: config.periodicHealthCheck || { enabled: false },
+            cache: config.cache || { enabled: false },
+            session: config.session || { enabled: false }
+        };
+        // Initialize locals for cache/session
+        this.app.locals.cache = undefined;
+        this.app.locals.sessionStore = undefined;
+        this.app.locals.cacheDefaultTTL = config.cache?.defaultTTL;
+        // Apply middleware based on configuration
+        this.setupMiddleware();
+        // Setup periodic health monitoring
+        this.setupPeriodicHealthMonitoring();
+    }
+    setupMiddleware() {
+        // Apply CORS if enabled
+        if (this.config.cors) {
+            try {
+                const cors = require('cors');
+                const corsOptions = typeof this.config.cors === 'object' ? this.config.cors : undefined;
+                this.app.use(cors(corsOptions));
+            }
+            catch (error) {
+                console.warn(`${this.config.name}: CORS middleware not available. Install cors package.`);
+            }
+        }
+        // Apply Helmet if enabled
+        if (this.config.helmet) {
+            try {
+                const helmet = require('helmet');
+                this.app.use(helmet());
+            }
+            catch (error) {
+                console.warn(`${this.config.name}: Helmet middleware not available. Install helmet package.`);
+            }
+        }
+        // Apply JSON parser if enabled
+        if (this.config.json) {
+            this.app.use(express.json());
+        }
+        // Apply cookie parser if enabled
+        if (this.config.cookieParser) {
+            try {
+                const cookieParser = require('cookie-parser');
+                this.app.use(cookieParser());
+            }
+            catch (error) {
+                console.warn(`${this.config.name}: Cookie parser middleware not available. Install cookie-parser package.`);
+            }
+        }
+        // Apply custom 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';
+            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()
+                };
+                // If cache is enabled, include its health
+                const cache = req.app.locals.cache;
+                if (cache && typeof cache.isAlive === 'function') {
+                    try {
+                        base.cache = await cache.isAlive();
+                    }
+                    catch (e) {
+                        base.cache = { isAlive: false, adapter: 'unknown', timestamp: new Date(), error: e.message };
+                    }
+                }
+                res.status(200).json(base);
+            });
+        }
+    }
+    async setupCacheAndSession(config, serverName) {
+        try {
+            // Initialize cache if enabled
+            if (config.cache && config.cache.enabled) {
+                try {
+                    const provided = config.cache.options;
+                    let cacheConfig = provided && typeof provided === 'object' ? provided : undefined;
+                    if (!cacheConfig) {
+                        cacheConfig = { adapter: config.cache.adapter || 'memory' };
+                    }
+                    console.log(`🔄 [${serverName}] Initializing cache adapter: ${config.cache.adapter || 'memory'}...`);
+                    // Use createWithFallback to prefer primary and fall back to memory when configured
+                    const cache = await CacheFactory.createWithFallback({
+                        ...(cacheConfig || {}),
+                        ttl: cacheConfig?.ttl ?? config.cache?.defaultTTL
+                    });
+                    this.app.locals.cache = cache;
+                    this.cache = cache;
+                    this.app.locals.cacheDefaultTTL = config.cache?.defaultTTL;
+                    // attach per-request helper middleware
+                    this.app.use((req, _res, next) => {
+                        req.cache = cache;
+                        next();
+                    });
+                    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);
+                    // Cache initialization error is critical but we continue to allow graceful fallback
+                }
+            }
+            // Initialize session if enabled
+            if (config.session && config.session.enabled) {
+                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) {
+                    // fallback to in-memory cache for session store
+                    try {
+                        cache = CacheFactory.create({ adapter: 'memory' });
+                        this.app.locals.cache = cache;
+                        this.cache = cache;
+                        console.log(`📝 [${serverName}] Session store using in-memory cache`);
+                    }
+                    catch (e) {
+                        console.error(`❌ [${serverName}] Failed to create in-memory cache for sessions:`, e instanceof Error ? e.message : e);
+                    }
+                }
+                else {
+                    console.log(`📝 [${serverName}] Session store initialized with configured cache adapter`);
+                }
+                if (!cache) {
+                    console.error(`❌ [${serverName}] CRITICAL: Session enabled but no cache available to store sessions. Session functionality will be unavailable.`);
+                }
+                else {
+                    const store = new SessionStore(cache, { ttl });
+                    this.app.locals.sessionStore = store;
+                    this.app.locals.sessionCookieName = cookieName;
+                    this.sessionStore = store;
+                    // attach session middleware globally so req.sessionStore is available
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-var-requires
+                        const { useSession } = require('./middleware');
+                        this.app.use(useSession(cookieName));
+                        console.log(`✅ [${serverName}] Session middleware enabled (cookie: ${cookieName}, TTL: ${ttl}s)`);
+                    }
+                    catch (err) {
+                        console.error(`❌ [${serverName}] Session middleware not available:`, err instanceof Error ? err.message : err);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`❌ [${serverName}] Error during cache/session setup:`, err instanceof Error ? err.message : err);
+        }
+    }
+    setupPeriodicHealthMonitoring() {
+        if (this.config.periodicHealthCheck?.enabled) {
+            this.healthMonitor = new PeriodicHealthMonitor(this.config.periodicHealthCheck, this.config.name);
+        }
+    }
+    async start() {
+        this.status = 'starting';
+        // Initialize cache and session before starting the server
+        await this.setupCacheAndSession(this.config, this.config.name);
+        return new Promise((resolve, reject) => {
+            try {
+                this.server = this.app.listen(this.config.port, () => {
+                    this.status = 'running';
+                    console.log(`🚀 ${this.config.name} v${this.config.version} running on http://localhost:${this.config.port}`);
+                    if (this.config.gracefulShutdown) {
+                        createGracefulShutdown(this.server, {
+                            onShutdown: async () => {
+                                this.status = 'stopping';
+                                // Stop health monitoring during shutdown
+                                if (this.healthMonitor) {
+                                    this.healthMonitor.stop();
+                                }
+                                // Close cache and session store if present
+                                try {
+                                    const cache = this.app.locals.cache;
+                                    if (cache && typeof cache.close === 'function') {
+                                        await cache.close();
+                                    }
+                                }
+                                catch (e) {
+                                    console.warn(`${this.config.name}: Error closing cache`, e);
+                                }
+                                try {
+                                    const store = this.app.locals.sessionStore;
+                                    if (store && typeof store.close === 'function') {
+                                        await store.close();
+                                    }
+                                }
+                                catch (e) {
+                                    // SessionStore may not have close; ignore
+                                }
+                            }
+                        });
+                    }
+                    // Start periodic health monitoring after server is running
+                    if (this.healthMonitor) {
+                        this.healthMonitor.start();
+                    }
+                    resolve(this);
+                });
+                this.server.on('error', reject);
+            }
+            catch (error) {
+                this.status = 'stopped';
+                reject(error);
+            }
+        });
+    }
+    async stop() {
+        this.status = 'stopping';
+        // Stop gRPC server if running
+        if (this.grpcServer) {
+            this.grpcServer.forceShutdown();
+        }
+        // Stop periodic health monitoring
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+        }
+        // Stop Socket.IO server if running
+        if (this.socketIO) {
+            this.socketIO.close();
+        }
+        if (!this.server) {
+            this.status = 'stopped';
+            return;
+        }
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                this.status = 'stopped';
+                console.log(`👋 ${this.config.name} stopped`);
+                resolve();
+            });
+        });
+    }
+    getInfo() {
+        return {
+            name: this.config.name,
+            version: this.config.version,
+            port: this.config.port,
+            uptime: Date.now() - this.config.startTime.getTime(),
+            status: this.status,
+            startTime: this.config.startTime
+        };
+    }
+    addGrpcService(service, implementation, port = 50051) {
+        this.grpcServices.push({ service, implementation });
+        // 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
+                this.grpcServices.forEach(({ service, implementation }) => {
+                    this.grpcServer.addService(service, implementation);
+                });
+                this.grpcServer.bindAsync(`0.0.0.0:${port}`, grpc.ServerCredentials.createInsecure(), () => {
+                    this.grpcServer.start();
+                    console.log(`🔗 ${this.config.name} gRPC server running on port ${port}`);
+                });
+            }
+            catch (error) {
+                console.warn(`${this.config.name}: gRPC not available. Install @grpc/grpc-js to use gRPC features.`);
+            }
+        }
+    }
+    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());
+            console.log(`📡 ${this.config.name} JSON-RPC server mounted on ${path}`);
+        }
+        catch (error) {
+            console.warn(`${this.config.name}: JSON-RPC not available. Install jayson to use RPC features.`);
+        }
+    }
+    addWebhook(config) {
+        this.app.post(config.path, express.raw({ type: 'application/json' }), async (req, res) => {
+            try {
+                // Verify signature if secret provided
+                if (config.secret) {
+                    const signature = req.headers['x-hub-signature-256'] || req.headers['x-signature-256'];
+                    if (signature) {
+                        const expectedSignature = crypto
+                            .createHmac('sha256', config.secret)
+                            .update(req.body)
+                            .digest('hex');
+                        const providedSignature = Array.isArray(signature) ? signature[0] : signature;
+                        if (!providedSignature.includes(expectedSignature)) {
+                            return res.status(401).json({ error: 'Invalid signature' });
+                        }
+                    }
+                }
+                // Parse JSON payload
+                const payload = JSON.parse(req.body.toString());
+                // Call handler
+                await config.handler(payload, req.headers);
+                res.status(200).json({ success: true });
+            }
+            catch (error) {
+                console.error('Webhook error:', error);
+                res.status(500).json({ error: 'Webhook processing failed' });
+            }
+        });
+        console.log(`🪝 ${this.config.name} webhook registered at ${config.path}${config.secret ? ' (with signature verification)' : ''}`);
+    }
+    addSocketIO(config = {}) {
+        if (!this.server) {
+            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
+                ? { origin: '*', methods: ['GET', 'POST'] }
+                : config.cors || undefined;
+            // Create Socket.IO server
+            const io = new Server(this.server, {
+                cors: config.cors ? corsConfig : undefined,
+                path: config.path || '/socket.io'
+            });
+            // Store reference for cleanup
+            this.socketIO = io;
+            // Handle connections
+            io.on('connection', (socket) => {
+                const typedSocket = socket;
+                console.log(`🔌 ${this.config.name}: Socket connected [${typedSocket.id}]`);
+                // Call user-defined connection handler
+                if (config.onConnection) {
+                    config.onConnection(socket);
+                }
+                // Handle disconnection
+                typedSocket.on('disconnect', (reason) => {
+                    console.log(`🔌 ${this.config.name}: Socket disconnected [${typedSocket.id}] - ${reason}`);
+                    // Call user-defined disconnection handler
+                    if (config.onDisconnection) {
+                        config.onDisconnection(socket, reason);
+                    }
+                });
+            });
+            console.log(`🔌 ${this.config.name} Socket.IO server attached${config.path ? ` at ${config.path}` : ''}${config.cors ? ' (CORS enabled)' : ''}`);
+            return io;
+        }
+        catch (error) {
+            console.warn(`${this.config.name}: Socket.IO not available. Install socket.io to use WebSocket features.`);
+            return null;
+        }
+    }
+}
+export function createServer(name, version, config) {
+    return new ExpressServer(name, version, config);
+}

package/dist/esm/shutdown.d.ts

@@ -0,0 +1,5 @@
+import { Server } from 'http';
+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: any, port: number, shutdownConfig?: GracefulShutdownConfig, serverName?: string, serverVersion?: string): Server;

package/dist/esm/shutdown.js

@@ -0,0 +1,52 @@
+export function createGracefulShutdown(server, config = {}) {
+    const { timeout = 10000, onShutdown, serverName, serverVersion } = config;
+    const nameVersion = serverName && serverVersion ? `${serverName} v${serverVersion}` : 'Server';
+    const shutdown = async (signal) => {
+        console.log(`🛑 ${nameVersion} received ${signal}, shutting down gracefully...`);
+        const shutdownTimer = setTimeout(() => {
+            console.log(`⏰ ${nameVersion} shutdown timeout reached, forcing exit`);
+            process.exit(1);
+        }, timeout);
+        try {
+            // Run custom shutdown logic
+            if (onShutdown) {
+                await onShutdown();
+            }
+            // Close server
+            server.close(() => {
+                clearTimeout(shutdownTimer);
+                console.log(`👋 ${nameVersion} closed. Exiting now.`);
+                process.exit(0);
+            });
+        }
+        catch (error) {
+            clearTimeout(shutdownTimer);
+            console.error(`❌ ${nameVersion} error during shutdown:`, error);
+            process.exit(1);
+        }
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+export function withGracefulShutdown(config = {}) {
+    return (app, serverConfig) => {
+        // This plugin needs to be applied after server.listen()
+        // Store config for later use
+        app.__gracefulShutdownConfig = config;
+    };
+}
+export function startServerWithShutdown(app, port, shutdownConfig = {}, serverName, serverVersion) {
+    const server = app.listen(port, () => {
+        const nameVersion = serverName && serverVersion ? `${serverName} v${serverVersion}` : 'Server';
+        console.log(`🚀 ${nameVersion} running on http://localhost:${port}`);
+    });
+    // Apply graceful shutdown from stored config or provided config
+    const config = app.__gracefulShutdownConfig || shutdownConfig;
+    const enhancedConfig = {
+        ...config,
+        serverName,
+        serverVersion
+    };
+    createGracefulShutdown(server, enhancedConfig);
+    return server;
+}

package/dist/esm/types.d.ts

@@ -0,0 +1,87 @@
+import 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[];
+    allowedHeaders?: string | string[];
+    exposedHeaders?: string | string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+}
+export interface ServerConfig {
+    port?: number;
+    cors?: boolean | CorsOptions;
+    helmet?: boolean;
+    json?: boolean;
+    cookieParser?: boolean;
+    customMiddleware?: express.RequestHandler[];
+    healthCheck?: boolean | string;
+    gracefulShutdown?: boolean;
+    socketIO?: SocketIOConfig;
+    periodicHealthCheck?: PeriodicHealthCheckConfig;
+    name?: string;
+    version?: string;
+    cache?: {
+        enabled?: boolean;
+        adapter?: 'redis' | 'memcache' | 'memory';
+        options?: unknown;
+        defaultTTL?: number;
+    };
+    session?: {
+        enabled?: boolean;
+        cookieName?: string;
+        ttl?: number;
+        cookieOptions?: {
+            path?: string;
+            httpOnly?: boolean;
+            secure?: boolean;
+            sameSite?: 'lax' | 'strict' | 'none';
+        };
+    };
+}
+export interface PeriodicHealthCheckConfig {
+    enabled?: boolean;
+    interval?: number;
+    services?: HealthCheckService[];
+}
+export interface HealthCheckService {
+    name: string;
+    url: string;
+    timeout?: number;
+}
+export interface SocketIOConfig {
+    enabled?: boolean;
+    cors?: boolean | {
+        origin?: string | string[] | boolean;
+        methods?: string[];
+        credentials?: boolean;
+    };
+    onConnection?: (socket: unknown) => void;
+    onDisconnection?: (socket: unknown, reason: string) => void;
+    path?: string;
+}
+export interface HealthCheckConfig {
+    path?: string;
+    customChecks?: HealthCheck[];
+}
+export interface HealthCheck {
+    name: string;
+    check: () => Promise<boolean>;
+}
+export interface GracefulShutdownConfig {
+    timeout?: number;
+    onShutdown?: () => Promise<void>;
+    serverName?: string;
+    serverVersion?: string;
+}
+export interface SocketInstance {
+    id: string;
+    emit: (event: string, data?: unknown) => void;
+    on: (event: string, handler: (...args: unknown[]) => void) => void;
+    broadcast: {
+        emit: (event: string, data?: unknown) => void;
+    };
+    disconnect: () => void;
+}
+export type ServerPlugin = (app: express.Application, config: ServerConfig) => void;

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getEnv(key: string, defaultValue?: string): string;
+export declare function getEnvNumber(key: string, defaultValue?: number): number;
+export declare function getEnvBoolean(key: string, defaultValue?: boolean): boolean;

package/dist/esm/utils.js

@@ -0,0 +1,38 @@
+export function getEnv(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    return value; // empty string allowed
+}
+export function getEnvNumber(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Environment variable ${key} must be a valid number`);
+    }
+    return parsed;
+}
+export function getEnvBoolean(key, defaultValue) {
+    const value = process.env[key];
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`Environment variable ${key} is required`);
+        }
+        return defaultValue;
+    }
+    const normalized = value.toLowerCase();
+    if (normalized !== "true" && normalized !== "false") {
+        throw new Error(`Environment variable ${key} must be 'true' or 'false'`);
+    }
+    return normalized === "true";
+}

package/dist/types/health.d.ts

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

package/dist/types/index.d.ts

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

package/dist/types/middleware.d.ts

@@ -0,0 +1,39 @@
+import express from 'express';
+import { ServerPlugin } from './types';
+export declare function createLoggingMiddleware(format?: 'simple' | 'detailed'): express.RequestHandler;
+export declare function createErrorHandler(): express.ErrorRequestHandler;
+export declare function createRequestIdMiddleware(): express.RequestHandler;
+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[]): express.RequestHandler;
+export interface RateLimitConfig {
+    windowMs?: number;
+    maxRequests?: number;
+    message?: string;
+    keyGenerator?: (req: express.Request) => string;
+}
+export declare function createRateLimitMiddleware(config?: RateLimitConfig): express.RequestHandler;
+export interface AuthConfig {
+    tokenExtractor?: (req: express.Request) => string | null;
+    tokenValidator?: (token: string) => Promise<unknown> | unknown;
+    unauthorizedMessage?: string;
+}
+export declare function createAuthMiddleware(config: AuthConfig): express.RequestHandler;
+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[]): express.RequestHandler;
+export declare function rateLimit(config?: RateLimitConfig): express.RequestHandler;
+export declare function requireAuth(config: AuthConfig): express.RequestHandler;
+export declare function cacheResponse(ttl?: number): express.RequestHandler;
+export declare function useSession(cookieName?: string): express.RequestHandler;