ts-packages 2.0.0 → 3.0.0

package/packages/server-utils/dist/cjs/middleware/cache.middleware.js

@@ -50,8 +50,8 @@ function cacheResponse(ttl) {
             };
             next();
         }
-        catch (err) {
-            console.error('[Cache] Unexpected error in cacheResponse middleware:', err);
+        catch (error) {
+            console.error('[Cache] Unexpected error in cacheResponse middleware:', error);
             next();
         }
     };

package/packages/server-utils/dist/cjs/middleware/errorHandler.middleware.d.ts

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

package/packages/server-utils/dist/cjs/middleware/errorHandler.middleware.js

@@ -1,29 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorHandler = createErrorHandler;
-// Error handling middleware
+const errors_utils_1 = require("@naman_deep_singh/errors-utils");
 function createErrorHandler() {
-    return (err, _req, res, next) => {
-        console.error('Error:', err);
+    return (error, _req, res, next) => {
         if (res.headersSent) {
-            return next(err);
+            return next(error);
         }
-        // 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({
+        // Use responder if available
+        const responder = res.responder?.() ?? null;
+        // Known application error
+        if (error instanceof errors_utils_1.AppError) {
+            if (responder) {
+                return responder
+                    .status(error.statusCode)
+                    .error(error.code, error.details);
+            }
+            // Fallback (if responder middleware is not mounted)
+            return res.status(error.statusCode).json({
+                success: false,
+                message: error.code,
+                error: {
+                    message: error.code,
+                    details: error.details,
+                },
+                data: undefined,
+                meta: null,
+            });
+        }
+        // Unknown / unhandled error
+        console.error('Unhandled error:', error);
+        const status = 500;
+        const message = 'Internal Server Error';
+        if (responder) {
+            return responder.status(status).error(message);
+        }
+        // Final fallback
+        return res.status(status).json({
             success: false,
             message,
+            error: { message },
             data: undefined,
-            error: {
-                message,
-                ...(process.env.NODE_ENV !== 'production' && {
-                    details: { stack: errorObj.stack },
-                }),
-            },
             meta: null,
         });
     };

package/packages/server-utils/dist/cjs/middleware/session.middleware.js

@@ -29,24 +29,24 @@ function useSession(cookieName) {
                 try {
                     return await store.get(sid);
                 }
-                catch (err) {
-                    console.error(`[Session] Failed to get session "${sid}":`, err);
-                    throw err;
+                catch (error) {
+                    console.error(`[Session] Failed to get session "${sid}":`, error);
+                    throw error;
                 }
             };
             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;
+                catch (error) {
+                    console.error(`[Session] Failed to create session "${id}":`, error);
+                    throw error;
                 }
             };
             next();
         }
-        catch (err) {
-            console.error('[Session] Unexpected error in useSession middleware:', err);
+        catch (error) {
+            console.error('[Session] Unexpected error in useSession middleware:', error);
             next();
         }
     };

package/packages/server-utils/dist/cjs/middleware/validation.middleware.js

@@ -57,8 +57,8 @@ function createValidationMiddleware(rules) {
         }
         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,
+            const validationError = new errors_utils_1.ValidationError({
+                fieldErrors: errors,
             });
             return next(validationError);
         }

package/packages/server-utils/dist/esm/core/server.js

@@ -139,8 +139,8 @@ export class ExpressServer {
                     });
                     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);
+                catch (error) {
+                    console.error(`❌ [${serverName}] Failed to initialize cache (fallback to memory if enabled):`, error instanceof Error ? error.message : error);
                     // Cache initialization error is critical but we continue to allow graceful fallback
                 }
             }
@@ -178,14 +178,14 @@ export class ExpressServer {
                         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 (error) {
+                        console.error(`❌ [${serverName}] Session middleware not available:`, error instanceof Error ? error.message : error);
                     }
                 }
             }
         }
-        catch (err) {
-            console.error(`❌ [${serverName}] Error during cache/session setup:`, err instanceof Error ? err.message : err);
+        catch (error) {
+            console.error(`❌ [${serverName}] Error during cache/session setup:`, error instanceof Error ? error.message : error);
         }
     }
     setupPeriodicHealthMonitoring() {

package/packages/server-utils/dist/esm/middleware/auth.middleware.d.ts

@@ -1,7 +1,6 @@
-import type { Request, RequestHandler } from 'node_modules/@types/express';
+import type { Request, RequestHandler } from 'express';
 export interface AuthConfig {
     secret: string;
-    unauthorizedMessage?: string;
     tokenExtractor?: (req: Request) => string | null;
 }
 export declare function createAuthMiddleware(config: AuthConfig): RequestHandler;

package/packages/server-utils/dist/esm/middleware/auth.middleware.js

@@ -1,7 +1,7 @@
-import { UnauthorizedError } from '@naman_deep_singh/errors-utils';
+import { TokenExpiredError, TokenMalformedError, UnauthorizedError, } from '@naman_deep_singh/errors-utils';
 import { extractToken, safeVerifyToken } from '@naman_deep_singh/security';
 export function createAuthMiddleware(config) {
-    const { secret, unauthorizedMessage = 'Unauthorized access', tokenExtractor = (req) => extractToken({
+    const { secret, tokenExtractor = (req) => extractToken({
         header: req.headers.authorization || undefined,
         cookies: req.cookies,
         query: req.query,
@@ -9,30 +9,33 @@ export function createAuthMiddleware(config) {
     }), } = config;
     return async (req, _res, next) => {
         try {
-            // Extract token from request
+            // 1️⃣ Extract token
             const token = tokenExtractor(req);
             if (!token) {
-                const error = new UnauthorizedError(unauthorizedMessage, {
+                // No cause → client mistake
+                return next(new TokenMalformedError({
                     reason: 'No token provided',
-                });
-                return next(error);
+                }));
             }
-            // Use safe verify token from security package
+            // 2️⃣ Verify token
             const result = safeVerifyToken(token, secret);
             if (!result.valid) {
-                const error = new UnauthorizedError(unauthorizedMessage, {
-                    reason: 'Invalid or expired token',
-                    originalError: result.error?.message,
-                });
-                return next(error);
+                // Token expired
+                if (result.error?.name === 'TokenExpiredError') {
+                    return next(new TokenExpiredError({ reason: 'Token expired' }, result.error));
+                }
+                // Token invalid / malformed
+                return next(new TokenMalformedError({
+                    reason: 'Invalid token',
+                }, result.error));
             }
-            // Attach the verified payload as user
+            // 3️⃣ Attach payload
             req.user = result.payload;
             next();
         }
         catch (error) {
-            const unauthorizedError = new UnauthorizedError(unauthorizedMessage, error instanceof Error ? { originalError: error.message } : error);
-            return next(unauthorizedError);
+            // Unexpected error → always pass cause
+            return next(new UnauthorizedError({ reason: 'Authentication failed' }, error instanceof Error ? error : undefined));
         }
     };
 }

package/packages/server-utils/dist/esm/middleware/cache.middleware.js

@@ -47,8 +47,8 @@ export function cacheResponse(ttl) {
             };
             next();
         }
-        catch (err) {
-            console.error('[Cache] Unexpected error in cacheResponse middleware:', err);
+        catch (error) {
+            console.error('[Cache] Unexpected error in cacheResponse middleware:', error);
             next();
         }
     };

package/packages/server-utils/dist/esm/middleware/errorHandler.middleware.d.ts

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

package/packages/server-utils/dist/esm/middleware/errorHandler.middleware.js

@@ -1,26 +1,43 @@
-// Error handling middleware
+import { AppError } from '@naman_deep_singh/errors-utils';
 export function createErrorHandler() {
-    return (err, _req, res, next) => {
-        console.error('Error:', err);
+    return (error, _req, res, next) => {
         if (res.headersSent) {
-            return next(err);
+            return next(error);
         }
-        // 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({
+        // Use responder if available
+        const responder = res.responder?.() ?? null;
+        // Known application error
+        if (error instanceof AppError) {
+            if (responder) {
+                return responder
+                    .status(error.statusCode)
+                    .error(error.code, error.details);
+            }
+            // Fallback (if responder middleware is not mounted)
+            return res.status(error.statusCode).json({
+                success: false,
+                message: error.code,
+                error: {
+                    message: error.code,
+                    details: error.details,
+                },
+                data: undefined,
+                meta: null,
+            });
+        }
+        // Unknown / unhandled error
+        console.error('Unhandled error:', error);
+        const status = 500;
+        const message = 'Internal Server Error';
+        if (responder) {
+            return responder.status(status).error(message);
+        }
+        // Final fallback
+        return res.status(status).json({
             success: false,
             message,
+            error: { message },
             data: undefined,
-            error: {
-                message,
-                ...(process.env.NODE_ENV !== 'production' && {
-                    details: { stack: errorObj.stack },
-                }),
-            },
             meta: null,
         });
     };

package/packages/server-utils/dist/esm/middleware/session.middleware.js

@@ -26,24 +26,24 @@ export function useSession(cookieName) {
                 try {
                     return await store.get(sid);
                 }
-                catch (err) {
-                    console.error(`[Session] Failed to get session "${sid}":`, err);
-                    throw err;
+                catch (error) {
+                    console.error(`[Session] Failed to get session "${sid}":`, error);
+                    throw error;
                 }
             };
             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;
+                catch (error) {
+                    console.error(`[Session] Failed to create session "${id}":`, error);
+                    throw error;
                 }
             };
             next();
         }
-        catch (err) {
-            console.error('[Session] Unexpected error in useSession middleware:', err);
+        catch (error) {
+            console.error('[Session] Unexpected error in useSession middleware:', error);
             next();
         }
     };

package/packages/server-utils/dist/esm/middleware/validation.middleware.js

@@ -54,8 +54,8 @@ export function createValidationMiddleware(rules) {
         }
         if (errors.length > 0) {
             // Use ValidationError from errors-utils and let error middleware handle response
-            const validationError = new ValidationError('Validation failed', {
-                validationErrors: errors,
+            const validationError = new ValidationError({
+                fieldErrors: errors,
             });
             return next(validationError);
         }

package/packages/server-utils/dist/types/middleware/auth.middleware.d.ts

@@ -1,7 +1,6 @@
-import type { Request, RequestHandler } from 'node_modules/@types/express';
+import type { Request, RequestHandler } from 'express';
 export interface AuthConfig {
     secret: string;
-    unauthorizedMessage?: string;
     tokenExtractor?: (req: Request) => string | null;
 }
 export declare function createAuthMiddleware(config: AuthConfig): RequestHandler;

package/packages/server-utils/dist/types/middleware/errorHandler.middleware.d.ts

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

package/packages/server-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naman_deep_singh/server-utils",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "description": "Extensible server utilities for Express.js microservices with TypeScript",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -34,9 +34,9 @@
   "license": "ISC",
   "packageManager": "pnpm@10.20.0",
   "dependencies": {
-    "@naman_deep_singh/cache": "^1.3.1",
-    "@naman_deep_singh/errors-utils": "^1.1.1",
-    "@naman_deep_singh/security": "^1.3.2",
+    "@naman_deep_singh/cache": "^1.4.0",
+    "@naman_deep_singh/errors-utils": "^1.4.2",
+    "@naman_deep_singh/security": "^1.5.1",
     "@types/express": "^5.0.5",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

package/packages/server-utils/src/core/server.ts

@@ -262,10 +262,10 @@ export class ExpressServer implements ServerInstance {
 					console.log(
 						`✅ [${serverName}] Cache initialized successfully (adapter: ${cacheConfig.adapter || 'memory'})`,
 					)
-				} catch (err) {
+				} catch (error) {
 					console.error(
 						`❌ [${serverName}] Failed to initialize cache (fallback to memory if enabled):`,
-						err instanceof Error ? err.message : err,
+						error instanceof Error ? error.message : error,
 					)
 					// Cache initialization error is critical but we continue to allow graceful fallback
 				}
@@ -316,18 +316,18 @@ export class ExpressServer implements ServerInstance {
 						console.log(
 							`✅ [${serverName}] Session middleware enabled (cookie: ${cookieName}, TTL: ${ttl}s)`,
 						)
-					} catch (err) {
+					} catch (error) {
 						console.error(
 							`❌ [${serverName}] Session middleware not available:`,
-							err instanceof Error ? err.message : err,
+							error instanceof Error ? error.message : error,
 						)
 					}
 				}
 			}
-		} catch (err) {
+		} catch (error) {
 			console.error(
 				`❌ [${serverName}] Error during cache/session setup:`,
-				err instanceof Error ? err.message : err,
+				error instanceof Error ? error.message : error,
 			)
 		}
 	}

package/packages/server-utils/src/middleware/auth.middleware.ts

@@ -1,25 +1,20 @@
-import { UnauthorizedError } from '@naman_deep_singh/errors-utils'
+import {
+	TokenExpiredError,
+	TokenMalformedError,
+	UnauthorizedError,
+} from '@naman_deep_singh/errors-utils'
 import { extractToken, safeVerifyToken } from '@naman_deep_singh/security'
 
-import type {
-	NextFunction,
-	Request,
-	RequestHandler,
-	Response,
-} from 'node_modules/@types/express'
+import type { NextFunction, Request, RequestHandler, Response } from 'express'
 
-// Authentication middleware helper
 export interface AuthConfig {
 	secret: string
-	unauthorizedMessage?: string
 	tokenExtractor?: (req: Request) => string | null
 }
 
 export function createAuthMiddleware(config: AuthConfig): RequestHandler {
 	const {
 		secret,
-		unauthorizedMessage = 'Unauthorized access',
-
 		tokenExtractor = (req) =>
 			extractToken({
 				header: req.headers.authorization || undefined,
@@ -31,36 +26,54 @@ export function createAuthMiddleware(config: AuthConfig): RequestHandler {
 
 	return async (req: Request, _res: Response, next: NextFunction) => {
 		try {
-			// Extract token from request
+			// 1️⃣ Extract token
 			const token = tokenExtractor(req)
 
 			if (!token) {
-				const error = new UnauthorizedError(unauthorizedMessage, {
-					reason: 'No token provided',
-				})
-				return next(error)
+				// No cause → client mistake
+				return next(
+					new TokenMalformedError({
+						reason: 'No token provided',
+					}),
+				)
 			}
 
-			// Use safe verify token from security package
+			// 2️⃣ Verify token
 			const result = safeVerifyToken(token, secret)
 
 			if (!result.valid) {
-				const error = new UnauthorizedError(unauthorizedMessage, {
-					reason: 'Invalid or expired token',
-					originalError: result.error?.message,
-				})
-				return next(error)
+				// Token expired
+				if (result.error?.name === 'TokenExpiredError') {
+					return next(
+						new TokenExpiredError(
+							{ reason: 'Token expired' },
+							result.error, // ✅ cause
+						),
+					)
+				}
+
+				// Token invalid / malformed
+				return next(
+					new TokenMalformedError(
+						{
+							reason: 'Invalid token',
+						},
+						result.error, // ✅ cause
+					),
+				)
 			}
 
-			// Attach the verified payload as user
+			// 3️⃣ Attach payload
 			req.user = result.payload
 			next()
 		} catch (error) {
-			const unauthorizedError = new UnauthorizedError(
-				unauthorizedMessage,
-				error instanceof Error ? { originalError: error.message } : error,
+			// Unexpected error → always pass cause
+			return next(
+				new UnauthorizedError(
+					{ reason: 'Authentication failed' },
+					error instanceof Error ? error : undefined,
+				),
 			)
-			return next(unauthorizedError)
 		}
 	}
 }

package/packages/server-utils/src/middleware/cache.middleware.ts

@@ -57,10 +57,10 @@ export function cacheResponse(ttl?: number): RequestHandler {
 			}
 
 			next()
-		} catch (err) {
+		} catch (error) {
 			console.error(
 				'[Cache] Unexpected error in cacheResponse middleware:',
-				err,
+				error,
 			)
 			next()
 		}

package/packages/server-utils/src/middleware/errorHandler.middleware.ts

@@ -3,41 +3,56 @@ import type {
 	NextFunction,
 	Request,
 	Response,
-} from 'node_modules/@types/express'
+} from 'express'
 
-// Error handling middleware
-export function createErrorHandler(): ErrorRequestHandler {
-	return (err: unknown, _req: Request, res: Response, next: NextFunction) => {
-		console.error('Error:', err)
+import { AppError } from '@naman_deep_singh/errors-utils'
 
+export function createErrorHandler(): ErrorRequestHandler {
+	return (error: unknown, _req: Request, res: Response, next: NextFunction) => {
 		if (res.headersSent) {
-			return next(err)
+			return next(error)
 		}
 
-		// Type guard for error objects
-		const errorObj = err as {
-			status?: number
-			statusCode?: number
-			message?: string
-			stack?: string
+		// Use responder if available
+		const responder = (res as any).responder?.() ?? null
+
+		// Known application error
+		if (error instanceof AppError) {
+			if (responder) {
+				return responder
+					.status(error.statusCode)
+					.error(error.code, error.details)
+			}
+
+			// Fallback (if responder middleware is not mounted)
+			return res.status(error.statusCode).json({
+				success: false,
+				message: error.code,
+				error: {
+					message: error.code,
+					details: error.details,
+				},
+				data: undefined,
+				meta: null,
+			})
 		}
 
-		const status = errorObj.status || errorObj.statusCode || 500
-		const message =
-			process.env.NODE_ENV === 'production'
-				? 'Internal Server Error'
-				: errorObj.message || 'Unknown error'
+		// Unknown / unhandled error
+		console.error('Unhandled error:', error)
+
+		const status = 500
+		const message = 'Internal Server Error'
+
+		if (responder) {
+			return responder.status(status).error(message)
+		}
 
-		res.status(status).json({
+		// Final fallback
+		return res.status(status).json({
 			success: false,
 			message,
+			error: { message },
 			data: undefined,
-			error: {
-				message,
-				...(process.env.NODE_ENV !== 'production' && {
-					details: { stack: errorObj.stack },
-				}),
-			},
 			meta: null,
 		})
 	}