@naman_deep_singh/server-utils 1.2.0 → 1.4.0

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;

package/dist/esm/middleware/session.middleware.js

@@ -0,0 +1,47 @@
+// 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];
+            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/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/esm/middleware/validation.middleware.js

@@ -0,0 +1,63 @@
+import { ValidationError } from "@naman_deep_singh/errors-utils";
+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) {
+            // Use ValidationError from errors-utils and let error middleware handle response
+            const validationError = new ValidationError('Validation failed', {
+                validationErrors: errors
+            });
+            return next(validationError);
+        }
+        next();
+    };
+}

package/dist/types/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/types/{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/{cjs → types/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,9 +46,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;
     private status;
     private grpcServices;
     private grpcServer?;

package/dist/types/core/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: import('express').Application, port: number, shutdownConfig?: GracefulShutdownConfig, serverName?: string, serverVersion?: string): Server;

package/dist/types/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/types/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/types/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/types/middleware/errorHandler.middleware.d.ts

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

package/dist/types/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/types/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/types/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/types/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/types/middleware/requestId.middleware.d.ts

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

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

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

package/dist/types/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/server-utils",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Extensible server utilities for Express.js microservices with TypeScript",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -28,6 +28,8 @@
   "license": "ISC",
   "dependencies": {
     "@naman_deep_singh/cache": "^1.2.0",
+    "@naman_deep_singh/errors-utils": "^1.0.1",
+    "@naman_deep_singh/security": "^1.2.0",
     "@types/express": "^5.0.5",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

package/dist/cjs/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/cjs/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;