@naman_deep_singh/server-utils 1.0.8 → 1.2.0

package/dist/esm/middleware.js

@@ -0,0 +1,327 @@
+// 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();
+    };
+}
+// 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
+        });
+    };
+}
+// 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();
+    };
+}
+export function createValidationMiddleware(rules) {
+    return (req, res, next) => {
+        const errors = [];
+        for (const rule of rules) {
+            const value = req.body[rule.field];
+            if (rule.required && (value === undefined || value === null || value === '')) {
+                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();
+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();
+    };
+}
+export 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
+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);
+}
+// 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)
+                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)
+export 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/esm/periodic-health.d.ts

@@ -0,0 +1,11 @@
+import { PeriodicHealthCheckConfig } from './types';
+export declare class PeriodicHealthMonitor {
+    private intervals;
+    private config;
+    private serviceName;
+    constructor(config: PeriodicHealthCheckConfig, serviceName: string);
+    start(): void;
+    stop(): void;
+    private checkServiceHealth;
+    getHealthStatus(): Promise<Record<string, boolean>>;
+}

package/dist/esm/periodic-health.js

@@ -0,0 +1,64 @@
+export class PeriodicHealthMonitor {
+    constructor(config, serviceName) {
+        this.intervals = [];
+        this.config = config;
+        this.serviceName = serviceName;
+    }
+    start() {
+        if (!this.config.enabled || !this.config.services?.length) {
+            return;
+        }
+        const interval = this.config.interval || 30000;
+        this.config.services.forEach(service => {
+            const intervalId = setInterval(async () => {
+                await this.checkServiceHealth(service);
+            }, interval);
+            this.intervals.push(intervalId);
+        });
+        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 = [];
+        console.log(`🛑 ${this.serviceName}: Periodic health monitoring stopped`);
+    }
+    async checkServiceHealth(service) {
+        try {
+            const controller = new AbortController();
+            const timeout = service.timeout || 5000;
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            const response = await fetch(service.url, {
+                method: 'GET',
+                signal: controller.signal,
+                headers: {
+                    'User-Agent': `${this.serviceName}-health-monitor`
+                }
+            });
+            clearTimeout(timeoutId);
+            if (response.ok) {
+                console.log(`🟢 ${service.name} is healthy`);
+                return true;
+            }
+            else {
+                console.log(`🔴 ${service.name} returned ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.log(`🔴 ${service.name} health check failed: ${errorMessage}`);
+            return false;
+        }
+    }
+    // Get current health status of all services
+    async getHealthStatus() {
+        if (!this.config.services?.length) {
+            return {};
+        }
+        const results = {};
+        await Promise.all(this.config.services.map(async (service) => {
+            results[service.name] = await this.checkServiceHealth(service);
+        }));
+        return results;
+    }
+}

package/dist/esm/server.d.ts

@@ -0,0 +1,70 @@
+import express from 'express';
+import { Server } from 'http';
+import { ServerConfig, SocketIOConfig } from './types';
+export interface GrpcService {
+    service: Record<string, unknown>;
+    implementation: Record<string, (...args: unknown[]) => unknown>;
+}
+export interface RpcMethod {
+    [key: string]: (params: unknown[], callback: (error: Error | null, result?: unknown) => void) => void;
+}
+export interface WebhookConfig {
+    path: string;
+    secret?: string;
+    handler: (payload: Record<string, unknown>, headers: Record<string, string | string[]>) => void | Promise<void>;
+}
+export interface GrpcServerInstance {
+    start(): void;
+    forceShutdown(): void;
+    addService(service: unknown, implementation: unknown): void;
+    bindAsync(address: string, credentials: unknown, callback: () => void): void;
+}
+export interface ServerInstanceConfig extends Required<Omit<ServerConfig, 'socketIO' | 'name' | 'version'>> {
+    name: string;
+    version: string;
+    startTime: Date;
+    socketIO?: SocketIOConfig;
+}
+export interface ServerInstance {
+    app: express.Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+    port: number;
+    uptime: number;
+    status: 'starting' | 'running' | 'stopping' | 'stopped';
+    startTime: Date;
+}
+export declare class ExpressServer implements ServerInstance {
+    app: express.Application;
+    server?: Server;
+    config: ServerInstanceConfig;
+    private status;
+    private grpcServices;
+    private grpcServer?;
+    private rpcMethods;
+    private socketIO?;
+    private healthMonitor?;
+    constructor(name?: string, version?: string, config?: ServerConfig);
+    private setupMiddleware;
+    private setupCacheAndSession;
+    private setupPeriodicHealthMonitoring;
+    start(): Promise<ServerInstance>;
+    stop(): Promise<void>;
+    getInfo(): ServerInfo;
+    addGrpcService(service: Record<string, unknown>, implementation: Record<string, (...args: unknown[]) => unknown>, port?: number): void;
+    addRpcMethods(methods: RpcMethod, path?: string): void;
+    addWebhook(config: WebhookConfig): void;
+    addSocketIO(config?: SocketIOConfig): unknown;
+}
+export declare function createServer(name?: string, version?: string, config?: ServerConfig): ServerInstance;