@naman_deep_singh/server-utils 1.2.0 → 1.4.0

package/dist/cjs/middleware.js

@@ -1,346 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLoggingMiddleware = createLoggingMiddleware;
-exports.createErrorHandler = createErrorHandler;
-exports.createRequestIdMiddleware = createRequestIdMiddleware;
-exports.createValidationMiddleware = createValidationMiddleware;
-exports.createRateLimitMiddleware = createRateLimitMiddleware;
-exports.createAuthMiddleware = createAuthMiddleware;
-exports.withLogging = withLogging;
-exports.withErrorHandler = withErrorHandler;
-exports.withRequestId = withRequestId;
-exports.withValidation = withValidation;
-exports.withRateLimit = withRateLimit;
-exports.withAuth = withAuth;
-exports.validateFields = validateFields;
-exports.rateLimit = rateLimit;
-exports.requireAuth = requireAuth;
-exports.cacheResponse = cacheResponse;
-exports.useSession = useSession;
-// Logging middleware
-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();
-    };
-}
-// Error handling middleware
-function createErrorHandler() {
-    return (err, req, res, next) => {
-        console.error('Error:', err);
-        if (res.headersSent) {
-            return next(err);
-        }
-        // Type guard for error objects
-        const errorObj = err;
-        const status = errorObj.status || errorObj.statusCode || 500;
-        const message = process.env.NODE_ENV === 'production'
-            ? 'Internal Server Error'
-            : errorObj.message || 'Unknown error';
-        res.status(status).json({
-            success: false,
-            message,
-            data: undefined,
-            error: {
-                message,
-                ...(process.env.NODE_ENV !== 'production' && { details: { stack: errorObj.stack } })
-            },
-            meta: null
-        });
-    };
-}
-// Request ID middleware
-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();
-    };
-}
-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) {
-            return res.status(400).json({
-                success: false,
-                message: 'Validation failed',
-                data: undefined,
-                error: {
-                    message: 'Validation failed',
-                    details: errors
-                },
-                meta: null
-            });
-        }
-        next();
-    };
-}
-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;
-    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();
-    };
-}
-function createAuthMiddleware(config) {
-    const { tokenExtractor = (req) => {
-        const authHeader = req.headers.authorization;
-        if (authHeader && authHeader.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        return req.cookies?.token || null;
-    }, tokenValidator = () => { throw new Error('Token validator not implemented'); }, unauthorizedMessage = 'Unauthorized access' } = config;
-    return async (req, res, next) => {
-        try {
-            const token = tokenExtractor(req);
-            if (!token) {
-                return res.status(401).json({
-                    success: false,
-                    message: unauthorizedMessage,
-                    data: undefined,
-                    error: {
-                        message: unauthorizedMessage
-                    },
-                    meta: null
-                });
-            }
-            const user = await tokenValidator(token);
-            req.user = user;
-            next();
-        }
-        catch (error) {
-            return res.status(401).json({
-                success: false,
-                message: unauthorizedMessage,
-                data: undefined,
-                error: {
-                    message: unauthorizedMessage
-                },
-                meta: null
-            });
-        }
-    };
-}
-// Plugin versions
-function withLogging(format = 'simple') {
-    return (app) => {
-        app.use(createLoggingMiddleware(format));
-    };
-}
-function withErrorHandler() {
-    return (app) => {
-        app.use(createErrorHandler());
-    };
-}
-function withRequestId() {
-    return (app) => {
-        app.use(createRequestIdMiddleware());
-    };
-}
-function withValidation(rules) {
-    return (app) => {
-        app.use(createValidationMiddleware(rules));
-    };
-}
-function withRateLimit(config = {}) {
-    return (app) => {
-        app.use(createRateLimitMiddleware(config));
-    };
-}
-function withAuth(config) {
-    return (app) => {
-        app.use(createAuthMiddleware(config));
-    };
-}
-// Convenience functions for route-specific middleware
-function validateFields(rules) {
-    return createValidationMiddleware(rules);
-}
-function rateLimit(config = {}) {
-    return createRateLimitMiddleware(config);
-}
-function requireAuth(config) {
-    return createAuthMiddleware(config);
-}
-// Cache response middleware (per-route opt-in)
-function cacheResponse(ttl) {
-    return async (req, res, next) => {
-        try {
-            if (req.method !== 'GET')
-                return next();
-            const cache = req.cache || req.app.locals.cache;
-            const defaultTTL = req.app.locals.cacheDefaultTTL;
-            if (!cache)
-                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) {
-                        cache.set(key, body, expiry).catch((err) => {
-                            console.error(`[Cache] Failed to set key "${key}" with TTL ${expiry}:`, err);
-                        });
-                    }
-                    else if (cache) {
-                        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();
-        }
-    };
-}
-// 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] || 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/shutdown.d.ts

@@ -1,5 +0,0 @@
-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/health.d.ts

@@ -1,5 +0,0 @@
-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/esm/middleware.d.ts

@@ -1,39 +0,0 @@
-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;