@naman_deep_singh/server-utils 1.3.0 → 1.4.1

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = exports.rateLimit = exports.validateFields = exports.withAuth = exports.withRateLimit = exports.withValidation = exports.withRequestId = exports.withErrorHandler = exports.withLogging = exports.createValidationMiddleware = exports.useSession = exports.createRequestIdMiddleware = exports.createRateLimitMiddleware = exports.createLoggingMiddleware = exports.createErrorHandler = exports.cacheResponse = exports.createAuthMiddleware = void 0;
+// Authentication Middleware
+var auth_middleware_1 = require("./auth.middleware");
+Object.defineProperty(exports, "createAuthMiddleware", { enumerable: true, get: function () { return auth_middleware_1.createAuthMiddleware; } });
+// Cache Middleware
+var cache_middleware_1 = require("./cache.middleware");
+Object.defineProperty(exports, "cacheResponse", { enumerable: true, get: function () { return cache_middleware_1.cacheResponse; } });
+// Error Handler Middleware
+var errorHandler_middleware_1 = require("./errorHandler.middleware");
+Object.defineProperty(exports, "createErrorHandler", { enumerable: true, get: function () { return errorHandler_middleware_1.createErrorHandler; } });
+// Logging Middleware
+var logging_middleware_1 = require("./logging.middleware");
+Object.defineProperty(exports, "createLoggingMiddleware", { enumerable: true, get: function () { return logging_middleware_1.createLoggingMiddleware; } });
+// Rate Limiter Middleware
+var rateLimiter_middleware_1 = require("./rateLimiter.middleware");
+Object.defineProperty(exports, "createRateLimitMiddleware", { enumerable: true, get: function () { return rateLimiter_middleware_1.createRateLimitMiddleware; } });
+// Request ID Middleware
+var requestId_middleware_1 = require("./requestId.middleware");
+Object.defineProperty(exports, "createRequestIdMiddleware", { enumerable: true, get: function () { return requestId_middleware_1.createRequestIdMiddleware; } });
+// Session Middleware
+var session_middleware_1 = require("./session.middleware");
+Object.defineProperty(exports, "useSession", { enumerable: true, get: function () { return session_middleware_1.useSession; } });
+// Validation Middleware
+var validation_middleware_1 = require("./validation.middleware");
+Object.defineProperty(exports, "createValidationMiddleware", { enumerable: true, get: function () { return validation_middleware_1.createValidationMiddleware; } });
+// Plugin middleware functions (for application-level middleware)
+var plugins_middleware_1 = require("./plugins.middleware");
+Object.defineProperty(exports, "withLogging", { enumerable: true, get: function () { return plugins_middleware_1.withLogging; } });
+Object.defineProperty(exports, "withErrorHandler", { enumerable: true, get: function () { return plugins_middleware_1.withErrorHandler; } });
+Object.defineProperty(exports, "withRequestId", { enumerable: true, get: function () { return plugins_middleware_1.withRequestId; } });
+Object.defineProperty(exports, "withValidation", { enumerable: true, get: function () { return plugins_middleware_1.withValidation; } });
+Object.defineProperty(exports, "withRateLimit", { enumerable: true, get: function () { return plugins_middleware_1.withRateLimit; } });
+Object.defineProperty(exports, "withAuth", { enumerable: true, get: function () { return plugins_middleware_1.withAuth; } });
+// Convenience middleware functions (for route-level middleware)
+var plugins_middleware_2 = require("./plugins.middleware");
+Object.defineProperty(exports, "validateFields", { enumerable: true, get: function () { return plugins_middleware_2.validateFields; } });
+Object.defineProperty(exports, "rateLimit", { enumerable: true, get: function () { return plugins_middleware_2.rateLimit; } });
+Object.defineProperty(exports, "requireAuth", { enumerable: true, get: function () { return plugins_middleware_2.requireAuth; } });

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

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

package/dist/cjs/middleware/logging.middleware.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggingMiddleware = createLoggingMiddleware;
+// 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();
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { RequestHandler } from 'express';
+import type { ServerPlugin } from '../types';
+import type { AuthConfig } from './auth.middleware';
+import type { RateLimitConfig } from './rateLimiter.middleware';
+import type { ValidationRule } from './validation.middleware';
+export declare function withLogging(format?: 'simple' | 'detailed'): ServerPlugin;
+export declare function withErrorHandler(): ServerPlugin;
+export declare function withRequestId(): ServerPlugin;
+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/cjs/middleware/plugins.middleware.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+const auth_middleware_1 = require("./auth.middleware");
+const errorHandler_middleware_1 = require("./errorHandler.middleware");
+const logging_middleware_1 = require("./logging.middleware");
+const rateLimiter_middleware_1 = require("./rateLimiter.middleware");
+const requestId_middleware_1 = require("./requestId.middleware");
+const validation_middleware_1 = require("./validation.middleware");
+// Plugin versions
+function withLogging(format = 'simple') {
+    return (app) => {
+        app.use((0, logging_middleware_1.createLoggingMiddleware)(format));
+    };
+}
+function withErrorHandler() {
+    return (app) => {
+        app.use((0, errorHandler_middleware_1.createErrorHandler)());
+    };
+}
+function withRequestId() {
+    return (app) => {
+        app.use((0, requestId_middleware_1.createRequestIdMiddleware)());
+    };
+}
+function withValidation(rules) {
+    return (app) => {
+        app.use((0, validation_middleware_1.createValidationMiddleware)(rules));
+    };
+}
+function withRateLimit(config = {}) {
+    return (app) => {
+        app.use((0, rateLimiter_middleware_1.createRateLimitMiddleware)(config));
+    };
+}
+function withAuth(config) {
+    return (app) => {
+        app.use((0, auth_middleware_1.createAuthMiddleware)(config));
+    };
+}
+// Convenience functions for route-specific middleware
+function validateFields(rules) {
+    return (0, validation_middleware_1.createValidationMiddleware)(rules);
+}
+function rateLimit(config = {}) {
+    return (0, rateLimiter_middleware_1.createRateLimitMiddleware)(config);
+}
+function requireAuth(config) {
+    return (0, auth_middleware_1.createAuthMiddleware)(config);
+}

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

@@ -0,0 +1,8 @@
+import type { 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/cjs/middleware/rateLimiter.middleware.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRateLimitMiddleware = createRateLimitMiddleware;
+const rateLimitStore = new Map();
+function createRateLimitMiddleware(config = {}) {
+    const { windowMs = 15 * 60 * 1000, maxRequests = 100, message = 'Too many requests, please try again later', keyGenerator = (req) => req.ip || 'unknown', } = config;
+    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/cjs/middleware/requestId.middleware.d.ts

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

package/dist/cjs/middleware/requestId.middleware.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestIdMiddleware = createRequestIdMiddleware;
+// 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();
+    };
+}

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

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

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

@@ -0,0 +1,53 @@
+"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 type { 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,67 @@
+"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/types.d.ts → cjs/types/index.d.ts}

@@ -1,4 +1,4 @@
-import express from 'express';
+import type express from 'express';
 export interface CorsOptions {
     origin?: string | string[] | boolean | RegExp | ((origin: string | undefined, callback: (err: Error | null, allow?: boolean) => void) => void);
     methods?: string | string[];

package/dist/cjs/{utils.js → utils/utils.js}

@@ -36,8 +36,8 @@ function getEnvBoolean(key, defaultValue) {
         return defaultValue;
     }
     const normalized = value.toLowerCase();
-    if (normalized !== "true" && normalized !== "false") {
+    if (normalized !== 'true' && normalized !== 'false') {
         throw new Error(`Environment variable ${key} must be 'true' or 'false'`);
     }
-    return normalized === "true";
+    return normalized === 'true';
 }

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

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

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

@@ -4,7 +4,7 @@ export function createHealthCheck(config = {}) {
         try {
             const checks = {
                 server: true,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             };
             // Run custom health checks
             for (const check of customChecks) {
@@ -15,16 +15,16 @@ export function createHealthCheck(config = {}) {
                     checks[check.name] = false;
                 }
             }
-            const isHealthy = Object.values(checks).every(status => status === true || typeof status === 'number');
+            const isHealthy = Object.values(checks).every((status) => status === true || typeof status === 'number');
             res.status(isHealthy ? 200 : 503).json({
                 status: isHealthy ? 'healthy' : 'unhealthy',
-                checks
+                checks,
             });
         }
         catch (error) {
             res.status(503).json({
                 status: 'unhealthy',
-                error: 'Health check failed'
+                error: 'Health check failed',
             });
         }
     };

package/dist/esm/{periodic-health.d.ts → core/periodic-health.d.ts}

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

package/dist/esm/{periodic-health.js → core/periodic-health.js}

@@ -9,7 +9,7 @@ export class PeriodicHealthMonitor {
             return;
         }
         const interval = this.config.interval || 30000;
-        this.config.services.forEach(service => {
+        this.config.services.forEach((service) => {
             const intervalId = setInterval(async () => {
                 await this.checkServiceHealth(service);
             }, interval);
@@ -18,7 +18,7 @@ export class PeriodicHealthMonitor {
         console.log(`📊 ${this.serviceName}: Periodic health monitoring enabled (${interval}ms interval) for ${this.config.services.length} service(s)`);
     }
     stop() {
-        this.intervals.forEach(interval => clearInterval(interval));
+        this.intervals.forEach((interval) => clearInterval(interval));
         this.intervals = [];
         console.log(`🛑 ${this.serviceName}: Periodic health monitoring stopped`);
     }
@@ -31,8 +31,8 @@ export class PeriodicHealthMonitor {
                 method: 'GET',
                 signal: controller.signal,
                 headers: {
-                    'User-Agent': `${this.serviceName}-health-monitor`
-                }
+                    'User-Agent': `${this.serviceName}-health-monitor`,
+                },
             });
             clearTimeout(timeoutId);
             if (response.ok) {

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

@@ -1,6 +1,7 @@
-import express from 'express';
-import { Server } from 'http';
-import { ServerConfig, SocketIOConfig } from './types';
+import { ICache, SessionStore } from '@naman_deep_singh/cache';
+import type { Server } from 'http';
+import type { Application } from 'express';
+import type { ServerConfig, SocketIOConfig } from '../types';
 export interface GrpcService {
     service: Record<string, unknown>;
     implementation: Record<string, (...args: unknown[]) => unknown>;
@@ -26,7 +27,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,11 +47,11 @@ 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>;
-    sessionStore?: import('@naman_deep_singh/cache').SessionStore | undefined;
+    cache?: ICache<unknown>;
+    sessionStore?: SessionStore | undefined;
     private status;
     private grpcServices;
     private grpcServer?;