nestjs-exception-handler 4.1.0 → 4.3.0

package/dist/index.mjs

@@ -10,6 +10,40 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 
+// src/formatters/validation-error.formatter.ts
+var ValidationErrorFormatter = class {
+  formatValidationErrors(exception) {
+    const response = exception.getResponse();
+    if (typeof response === "object" && response !== null) {
+      const responseObj = response;
+      if (Array.isArray(responseObj.message)) {
+        const messages = responseObj.message;
+        if (messages.length > 0 && typeof messages[0] === "object" && "property" in messages[0]) {
+          return this.formatNestedValidationErrors(messages);
+        }
+        return [
+          {
+            path: "http_error",
+            message: messages
+          }
+        ];
+      }
+    }
+    return [
+      {
+        path: "http_error",
+        message: ["Validation failed"]
+      }
+    ];
+  }
+  formatNestedValidationErrors(errors) {
+    return errors.map((error) => ({
+      path: error.property,
+      message: error.constraints ? Object.values(error.constraints) : ["Validation error"]
+    }));
+  }
+};
+
 // src/formatters/prisma-exception.formatter.ts
 import { Injectable } from "@nestjs/common";
 import {
@@ -19,6 +53,15 @@ import {
   PrismaClientInitializationError
 } from "@prisma/client/runtime/library";
 var PrismaExceptionFormatter = class {
+  supports(exception) {
+    return exception instanceof PrismaClientKnownRequestError || exception instanceof PrismaClientValidationError || exception instanceof PrismaClientRustPanicError || exception instanceof PrismaClientInitializationError;
+  }
+  format(exception) {
+    return this.formatError(exception);
+  }
+  message(_exception) {
+    return "Database error";
+  }
   formatError(exception) {
     if (exception instanceof PrismaClientKnownRequestError) {
       return this.formatPrismaError(exception);
@@ -41,7 +84,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: field,
-            message: `A record with this ${field} already exists.`
+            message: [`A record with this ${field} already exists.`]
           }
         ];
       }
@@ -50,7 +93,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The referenced ${fieldName || "record"} does not exist.`
+            message: [`The referenced ${fieldName || "record"} does not exist.`]
           }
         ];
       }
@@ -59,7 +102,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The value for ${fieldName || "field"} is invalid.`
+            message: [`The value for ${fieldName || "field"} is invalid.`]
           }
         ];
       }
@@ -68,7 +111,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The ${fieldName || "field"} field is required.`
+            message: [`The ${fieldName || "field"} field is required.`]
           }
         ];
       }
@@ -76,7 +119,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: "record",
-            message: "The requested record does not exist."
+            message: ["The requested record does not exist."]
           }
         ];
       }
@@ -84,7 +127,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: "database",
-            message: "Database operation failed."
+            message: ["Database operation failed."]
           }
         ];
     }
@@ -97,7 +140,7 @@ var PrismaExceptionFormatter = class {
     return [
       {
         path: "database",
-        message
+        message: [message]
       }
     ];
   }
@@ -105,7 +148,7 @@ var PrismaExceptionFormatter = class {
     return [
       {
         path: "database",
-        message: `Database initialization error: ${exception.message}`
+        message: [`Database initialization error: ${exception.message}`]
       }
     ];
   }
@@ -113,7 +156,7 @@ var PrismaExceptionFormatter = class {
     return [
       {
         path: "unknown",
-        message: exception instanceof Error ? exception.message : "An unexpected database error occurred."
+        message: exception instanceof Error ? [exception.message] : ["An unexpected database error occurred."]
       }
     ];
   }
@@ -134,14 +177,22 @@ var DtoValidationFormatter = class {
         const validationErrors = messages;
         return validationErrors.map((error) => ({
           path: error.property,
-          message: error.constraints ? Object.values(error.constraints).join(", ") : "Validation error"
+          message: error.constraints ? Object.values(error.constraints) : ["Validation error"]
         }));
       }
+      if (typeof firstMessage === "string") {
+        return [
+          {
+            path: "http_error",
+            message: messages
+          }
+        ];
+      }
     }
     return [
       {
         path: "http_error",
-        message: typeof responseBody === "object" && responseBody !== null && "message" in responseBody ? String(responseBody.message) : "An HTTP error occurred"
+        message: typeof responseBody === "object" && responseBody !== null && "message" in responseBody ? [responseBody.message] : ["An HTTP error occurred"]
       }
     ];
   }
@@ -150,112 +201,355 @@ DtoValidationFormatter = __decorateClass([
   Injectable2()
 ], DtoValidationFormatter);
 
-// src/formatters/other-exception.formatter.ts
-import { Injectable as Injectable3 } from "@nestjs/common";
-var OtherExceptionFormatter = class {
-  formatOtherError(exception) {
-    if (exception && typeof exception === "object" && "path" in exception && "message" in exception) {
-      return [
-        {
-          path: String(exception.path),
-          message: String(exception.message)
-        }
-      ];
-    }
-    const message = exception && typeof exception === "object" && "message" in exception ? String(exception.message) : "An unexpected error occurred";
-    return [
-      {
-        path: "unknown",
-        message
-      }
-    ];
-  }
-};
-OtherExceptionFormatter = __decorateClass([
-  Injectable3()
-], OtherExceptionFormatter);
-
-// src/exception-filter/global-exception.filter.ts
+// src/filter/global-exception.filter.ts
 import {
   Catch,
   HttpException,
   HttpStatus,
-  Logger
+  Logger,
+  NotFoundException
 } from "@nestjs/common";
-import {
-  PrismaClientKnownRequestError as PrismaClientKnownRequestError2,
-  PrismaClientValidationError as PrismaClientValidationError2,
-  PrismaClientRustPanicError as PrismaClientRustPanicError2,
-  PrismaClientUnknownRequestError,
-  PrismaClientInitializationError as PrismaClientInitializationError2
-} from "@prisma/client/runtime/library";
 var GlobalExceptionFilter = class {
-  constructor(prismaExceptionFormatter, dtoValidationFormatter, otherValidationFormatter) {
-    this.prismaExceptionFormatter = prismaExceptionFormatter;
-    this.dtoValidationFormatter = dtoValidationFormatter;
-    this.otherValidationFormatter = otherValidationFormatter;
+  constructor(exceptionHandlerService, config) {
+    this.exceptionHandlerService = exceptionHandlerService;
     this.logger = new Logger(GlobalExceptionFilter.name);
-  }
-  getErrorMessage(exception) {
-    if (exception instanceof PrismaClientKnownRequestError2 || exception instanceof PrismaClientValidationError2 || exception instanceof PrismaClientRustPanicError2 || exception instanceof PrismaClientUnknownRequestError || exception instanceof PrismaClientInitializationError2) {
-      return "Database error";
-    }
-    if (exception instanceof HttpException) {
-      return exception.message || "HTTP error";
-    }
-    return "Internal server error";
+    this.config = config || { enableLogging: true, hideStackTrace: false };
   }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     const response = ctx.getResponse();
     const request = ctx.getRequest();
-    const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR;
-    let errorMessages = [{ path: "unknown", message: "Internal server error" }];
-    if (exception instanceof PrismaClientKnownRequestError2 || exception instanceof PrismaClientValidationError2 || exception instanceof PrismaClientRustPanicError2 || exception instanceof PrismaClientUnknownRequestError || exception instanceof PrismaClientInitializationError2) {
-      errorMessages = this.prismaExceptionFormatter.formatError(exception);
-    } else if (exception instanceof HttpException) {
-      errorMessages = this.dtoValidationFormatter.formatDtoValidationException(
-        exception
-      );
-    } else {
-      errorMessages = this.otherValidationFormatter.formatOtherError(exception);
+    const { errors, message } = this.exceptionHandlerService.formatException(exception);
+    let status = this.getStatusCode(exception);
+    let finalErrors = errors;
+    let finalMessage = message;
+    if (exception instanceof NotFoundException) {
+      const exceptionResponse = exception.getResponse();
+      if (typeof exceptionResponse === "object" && exceptionResponse !== null && "message" in exceptionResponse) {
+        const msg = exceptionResponse.message;
+        if (typeof msg === "string" && msg.includes("Cannot")) {
+          status = HttpStatus.NOT_FOUND;
+          finalMessage = "Route Not Found";
+          finalErrors = [
+            {
+              path: "route",
+              message: [msg]
+            }
+          ];
+        }
+      }
     }
-    this.logger.error(
-      `${request.method} ${request.url}`,
-      JSON.stringify(errorMessages),
-      "ExceptionFilter"
-    );
-    response.status(status).json({
+    const errorResponse = {
       success: false,
-      message: this.getErrorMessage(exception),
-      errorMessages
-    });
+      message: finalMessage,
+      errorMessages: finalErrors
+    };
+    if (this.config.enableLogging) {
+      this.logError(request, status, finalErrors, exception);
+    }
+    response.status(status).json(errorResponse);
+  }
+  getStatusCode(exception) {
+    if (exception instanceof HttpException) {
+      return exception.getStatus();
+    }
+    return HttpStatus.INTERNAL_SERVER_ERROR;
+  }
+  logError(request, status, errorMessages, exception) {
+    const method = request.method;
+    const url = request.url;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logData = {
+      timestamp,
+      method,
+      url,
+      status,
+      errorMessages,
+      stack: this.config.hideStackTrace ? void 0 : exception?.stack
+    };
+    this.logger.error(`${method} ${url} - ${status}`, JSON.stringify(logData));
   }
 };
 GlobalExceptionFilter = __decorateClass([
   Catch()
 ], GlobalExceptionFilter);
 
-// src/exception-handler.module.ts
+// src/module/exception-handler.module.ts
 import { Module } from "@nestjs/common";
+
+// src/services/exception-handler.service.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+
+// src/formatters/http-exception.formatter.ts
+import { HttpException as HttpException2 } from "@nestjs/common";
+var HttpExceptionFormatter = class {
+  supports(exception) {
+    return exception instanceof HttpException2;
+  }
+  format(exception) {
+    const httpException = exception;
+    const response = httpException.getResponse();
+    if (typeof response === "string") {
+      return [{ path: "http_error", message: [response] }];
+    }
+    if (typeof response === "object" && response !== null) {
+      const responseObj = response;
+      if (responseObj.message && Array.isArray(responseObj.message)) {
+        return [
+          {
+            path: "http_error",
+            message: responseObj.message
+          }
+        ];
+      }
+      if (responseObj.message && typeof responseObj.message === "string") {
+        return [{ path: "http_error", message: [responseObj.message] }];
+      }
+      if (responseObj.error && typeof responseObj.error === "string") {
+        return [{ path: "http_error", message: [responseObj.error] }];
+      }
+    }
+    return [{ path: "http_error", message: ["An error occurred"] }];
+  }
+  message(exception) {
+    const httpException = exception;
+    const response = httpException.getResponse();
+    if (typeof response === "string") {
+      return response;
+    }
+    if (typeof response === "object" && response !== null) {
+      const responseObj = response;
+      if (responseObj.message && typeof responseObj.message === "string") {
+        return responseObj.message;
+      }
+      if (responseObj.error && typeof responseObj.error === "string") {
+        return responseObj.error;
+      }
+    }
+    return "An error occurred";
+  }
+};
+
+// src/formatters/dto-exception.formatter.ts
+var DtoExceptionFormatter = class {
+  supports(exception) {
+    if (!exception || typeof exception !== "object") {
+      return false;
+    }
+    const error = exception;
+    return Array.isArray(error.validationErrors) || Array.isArray(error.children) && error.constraints !== void 0;
+  }
+  format(exception) {
+    const error = exception;
+    const validationErrors = error.validationErrors;
+    const children = error.children;
+    if (validationErrors) {
+      return this.formatValidationErrors(validationErrors);
+    }
+    if (children) {
+      return this.formatChildrenErrors(children);
+    }
+    return [{ path: "unknown", message: ["Validation failed"] }];
+  }
+  message(exception) {
+    const error = exception;
+    const validationErrors = error.validationErrors;
+    const children = error.children;
+    if (validationErrors && validationErrors.length > 0) {
+      const firstError = validationErrors[0];
+      const constraints = firstError.constraints;
+      if (constraints) {
+        return Object.values(constraints)[0];
+      }
+    }
+    if (children && children.length > 0) {
+      return "Validation failed for nested fields";
+    }
+    return "Validation failed";
+  }
+  formatValidationErrors(errors) {
+    return errors.flatMap((error) => {
+      const constraints = error.constraints;
+      if (constraints) {
+        return [
+          {
+            path: error.property,
+            message: Object.values(constraints)
+          }
+        ];
+      }
+      return [];
+    });
+  }
+  formatChildrenErrors(children) {
+    return children.flatMap((child) => {
+      const constraints = child.constraints;
+      if (constraints) {
+        return [
+          {
+            path: child.property,
+            message: Object.values(constraints)
+          }
+        ];
+      }
+      return [];
+    });
+  }
+};
+
+// src/constants/default-messages.ts
+var DEFAULT_PATH = "unknown";
+
+// src/formatters/unknown-exception.formatter.ts
+var UnknownExceptionFormatter = class {
+  supports(_exception) {
+    return true;
+  }
+  format(_exception) {
+    return [
+      {
+        path: DEFAULT_PATH,
+        message: ["Something went wrong"]
+      }
+    ];
+  }
+  message(_exception) {
+    return "Internal Server Error";
+  }
+};
+
+// src/services/exception-handler.service.ts
+var ExceptionHandlerService = class {
+  constructor() {
+    this.formatters = [];
+    this.defaultFormatter = new UnknownExceptionFormatter();
+    this.registerFormatters();
+  }
+  registerFormatters() {
+    this.formatters = [
+      new PrismaExceptionFormatter(),
+      new HttpExceptionFormatter(),
+      new DtoExceptionFormatter()
+    ];
+  }
+  registerFormatter(formatter) {
+    this.formatters.push(formatter);
+  }
+  getFormatter(exception) {
+    for (const formatter of this.formatters) {
+      if (formatter.supports(exception)) {
+        return formatter;
+      }
+    }
+    return this.defaultFormatter;
+  }
+  formatException(exception) {
+    const formatter = this.getFormatter(exception);
+    const errors = formatter.format(exception);
+    const message = formatter.message(exception);
+    return { errors, message };
+  }
+  formatErrors(exception) {
+    const formatter = this.getFormatter(exception);
+    return formatter.format(exception);
+  }
+  getErrorMessage(exception) {
+    const formatter = this.getFormatter(exception);
+    return formatter.message(exception);
+  }
+  getAllFormatters() {
+    return [...this.formatters];
+  }
+};
+ExceptionHandlerService = __decorateClass([
+  Injectable3()
+], ExceptionHandlerService);
+
+// src/module/exception-handler.module.ts
 var ExceptionHandlerModule = class {
+  static forRoot(config) {
+    const providers = [
+      ExceptionHandlerService,
+      {
+        provide: GlobalExceptionFilter,
+        useFactory: (service) => {
+          return new GlobalExceptionFilter(service, config);
+        },
+        inject: [ExceptionHandlerService]
+      }
+    ];
+    return {
+      module: ExceptionHandlerModule,
+      providers,
+      exports: [ExceptionHandlerService, GlobalExceptionFilter],
+      global: true
+    };
+  }
+  static forFeature(config) {
+    return this.forRoot(config);
+  }
 };
 ExceptionHandlerModule = __decorateClass([
-  Module({
-    providers: [
-      GlobalExceptionFilter,
-      PrismaExceptionFormatter,
-      DtoValidationFormatter,
-      OtherExceptionFormatter
-    ],
-    exports: [GlobalExceptionFilter]
-  })
+  Module({})
 ], ExceptionHandlerModule);
+function initializeFormatters(service) {
+  service.registerFormatter(new PrismaExceptionFormatter());
+  service.registerFormatter(new DtoExceptionFormatter());
+  service.registerFormatter(new HttpExceptionFormatter());
+  service.registerFormatter(new UnknownExceptionFormatter());
+}
+
+// src/utils/http-error.formatter.ts
+var HttpErrorFormatter = class {
+  formatHttpException(exception) {
+    const response = exception.getResponse();
+    if (typeof response === "string") {
+      return [{ path: "http_error", message: [response] }];
+    }
+    if (typeof response === "object" && response !== null) {
+      const responseObj = response;
+      if (Array.isArray(responseObj.message)) {
+        return [
+          {
+            path: "http_error",
+            message: responseObj.message
+          }
+        ];
+      }
+      if (typeof responseObj.message === "string") {
+        return [{ path: "http_error", message: [responseObj.message] }];
+      }
+      if (responseObj.error && typeof responseObj.error === "string") {
+        return [{ path: "http_error", message: [responseObj.error] }];
+      }
+    }
+    return [{ path: "http_error", message: ["An error occurred"] }];
+  }
+  getMessage(exception) {
+    const response = exception.getResponse();
+    if (typeof response === "string") {
+      return response;
+    }
+    if (typeof response === "object" && response !== null) {
+      const responseObj = response;
+      if (typeof responseObj.message === "string") {
+        return responseObj.message;
+      }
+      if (responseObj.error && typeof responseObj.error === "string") {
+        return responseObj.error;
+      }
+    }
+    return "An error occurred";
+  }
+};
 export {
   DtoValidationFormatter,
   ExceptionHandlerModule,
+  ExceptionHandlerService,
   GlobalExceptionFilter,
-  OtherExceptionFormatter,
-  PrismaExceptionFormatter
+  HttpErrorFormatter,
+  PrismaExceptionFormatter,
+  ValidationErrorFormatter,
+  initializeFormatters
 };
 //# sourceMappingURL=index.mjs.map