nestjs-exception-handler 4.1.0 → 4.3.0

package/dist/index.d.ts

@@ -1,15 +1,14 @@
+import { HttpException, ExceptionFilter, ArgumentsHost, DynamicModule } from '@nestjs/common';
 import { PrismaClientKnownRequestError, PrismaClientValidationError, PrismaClientRustPanicError, PrismaClientInitializationError } from '@prisma/client/runtime/library';
-import { HttpException, ExceptionFilter, ArgumentsHost } from '@nestjs/common';
 
-interface IErrorMessage {
+interface ErrorMessage {
     path: string;
-    message: string;
+    message: string[];
 }
-type ErrorMessage = IErrorMessage;
-interface StandardErrorResponse {
+interface ErrorResponse {
     success: boolean;
     message: string;
-    errorMessages: IErrorMessage[];
+    errorMessages: ErrorMessage[];
 }
 
 interface ExceptionFormatter {
@@ -23,9 +22,17 @@ interface ExceptionHandlerConfig {
     hideStackTrace?: boolean;
 }
 
+declare class ValidationErrorFormatter {
+    formatValidationErrors(exception: HttpException): ErrorMessage[];
+    private formatNestedValidationErrors;
+}
+
 type PrismaError = PrismaClientKnownRequestError | PrismaClientValidationError | PrismaClientRustPanicError | PrismaClientInitializationError | unknown;
-declare class PrismaExceptionFormatter {
-    formatError(exception: PrismaError): IErrorMessage[];
+declare class PrismaExceptionFormatter implements ExceptionFormatter {
+    supports(exception: unknown): boolean;
+    format(exception: unknown): ErrorMessage[];
+    message(_exception: unknown): string;
+    formatError(exception: PrismaError): ErrorMessage[];
     private formatPrismaError;
     private formatQueryError;
     private formatInitializationError;
@@ -33,24 +40,44 @@ declare class PrismaExceptionFormatter {
 }
 
 declare class DtoValidationFormatter {
-    formatDtoValidationException(exception: HttpException): IErrorMessage[];
+    formatDtoValidationException(exception: HttpException): ErrorMessage[];
 }
 
-declare class OtherExceptionFormatter {
-    formatOtherError(exception: unknown): IErrorMessage[];
+declare class ExceptionHandlerService {
+    private formatters;
+    private defaultFormatter;
+    constructor();
+    private registerFormatters;
+    registerFormatter(formatter: ExceptionFormatter): void;
+    getFormatter(exception: unknown): ExceptionFormatter;
+    formatException(exception: unknown): {
+        errors: ErrorMessage[];
+        message: string;
+    };
+    formatErrors(exception: unknown): ErrorMessage[];
+    getErrorMessage(exception: unknown): string;
+    getAllFormatters(): ExceptionFormatter[];
 }
 
 declare class GlobalExceptionFilter implements ExceptionFilter {
-    private readonly prismaExceptionFormatter;
-    private readonly dtoValidationFormatter;
-    private readonly otherValidationFormatter;
-    constructor(prismaExceptionFormatter: PrismaExceptionFormatter, dtoValidationFormatter: DtoValidationFormatter, otherValidationFormatter: OtherExceptionFormatter);
+    private exceptionHandlerService;
     private readonly logger;
-    private getErrorMessage;
+    private config;
+    constructor(exceptionHandlerService: ExceptionHandlerService, config?: ExceptionHandlerConfig);
     catch(exception: unknown, host: ArgumentsHost): void;
+    private getStatusCode;
+    private logError;
 }
 
 declare class ExceptionHandlerModule {
+    static forRoot(config?: ExceptionHandlerConfig): DynamicModule;
+    static forFeature(config?: ExceptionHandlerConfig): DynamicModule;
+}
+declare function initializeFormatters(service: ExceptionHandlerService): void;
+
+declare class HttpErrorFormatter {
+    formatHttpException(exception: HttpException): ErrorMessage[];
+    getMessage(exception: HttpException): string;
 }
 
-export { DtoValidationFormatter, ErrorMessage, ExceptionFormatter, ExceptionHandlerConfig, ExceptionHandlerModule, GlobalExceptionFilter, IErrorMessage, OtherExceptionFormatter, PrismaExceptionFormatter, StandardErrorResponse };
+export { DtoValidationFormatter, ErrorMessage, ErrorResponse, ExceptionFormatter, ExceptionHandlerConfig, ExceptionHandlerModule, ExceptionHandlerService, GlobalExceptionFilter, HttpErrorFormatter, PrismaExceptionFormatter, ValidationErrorFormatter, initializeFormatters };

package/dist/index.js

@@ -31,16 +31,62 @@ var src_exports = {};
 __export(src_exports, {
   DtoValidationFormatter: () => DtoValidationFormatter,
   ExceptionHandlerModule: () => ExceptionHandlerModule,
+  ExceptionHandlerService: () => ExceptionHandlerService,
   GlobalExceptionFilter: () => GlobalExceptionFilter,
-  OtherExceptionFormatter: () => OtherExceptionFormatter,
-  PrismaExceptionFormatter: () => PrismaExceptionFormatter
+  HttpErrorFormatter: () => HttpErrorFormatter,
+  PrismaExceptionFormatter: () => PrismaExceptionFormatter,
+  ValidationErrorFormatter: () => ValidationErrorFormatter,
+  initializeFormatters: () => initializeFormatters
 });
 module.exports = __toCommonJS(src_exports);
 
+// 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
 var import_common = require("@nestjs/common");
 var import_library = require("@prisma/client/runtime/library");
 var PrismaExceptionFormatter = class {
+  supports(exception) {
+    return exception instanceof import_library.PrismaClientKnownRequestError || exception instanceof import_library.PrismaClientValidationError || exception instanceof import_library.PrismaClientRustPanicError || exception instanceof import_library.PrismaClientInitializationError;
+  }
+  format(exception) {
+    return this.formatError(exception);
+  }
+  message(_exception) {
+    return "Database error";
+  }
   formatError(exception) {
     if (exception instanceof import_library.PrismaClientKnownRequestError) {
       return this.formatPrismaError(exception);
@@ -63,7 +109,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: field,
-            message: `A record with this ${field} already exists.`
+            message: [`A record with this ${field} already exists.`]
           }
         ];
       }
@@ -72,7 +118,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The referenced ${fieldName || "record"} does not exist.`
+            message: [`The referenced ${fieldName || "record"} does not exist.`]
           }
         ];
       }
@@ -81,7 +127,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The value for ${fieldName || "field"} is invalid.`
+            message: [`The value for ${fieldName || "field"} is invalid.`]
           }
         ];
       }
@@ -90,7 +136,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: fieldName || "field",
-            message: `The ${fieldName || "field"} field is required.`
+            message: [`The ${fieldName || "field"} field is required.`]
           }
         ];
       }
@@ -98,7 +144,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: "record",
-            message: "The requested record does not exist."
+            message: ["The requested record does not exist."]
           }
         ];
       }
@@ -106,7 +152,7 @@ var PrismaExceptionFormatter = class {
         return [
           {
             path: "database",
-            message: "Database operation failed."
+            message: ["Database operation failed."]
           }
         ];
     }
@@ -119,7 +165,7 @@ var PrismaExceptionFormatter = class {
     return [
       {
         path: "database",
-        message
+        message: [message]
       }
     ];
   }
@@ -127,7 +173,7 @@ var PrismaExceptionFormatter = class {
     return [
       {
         path: "database",
-        message: `Database initialization error: ${exception.message}`
+        message: [`Database initialization error: ${exception.message}`]
       }
     ];
   }
@@ -135,7 +181,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."]
       }
     ];
   }
@@ -156,14 +202,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"]
       }
     ];
   }
@@ -172,102 +226,350 @@ DtoValidationFormatter = __decorateClass([
   (0, import_common2.Injectable)()
 ], DtoValidationFormatter);
 
-// src/formatters/other-exception.formatter.ts
+// src/filter/global-exception.filter.ts
 var import_common3 = require("@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)
+var GlobalExceptionFilter = class {
+  constructor(exceptionHandlerService, config) {
+    this.exceptionHandlerService = exceptionHandlerService;
+    this.logger = new import_common3.Logger(GlobalExceptionFilter.name);
+    this.config = config || { enableLogging: true, hideStackTrace: false };
+  }
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse();
+    const request = ctx.getRequest();
+    const { errors, message } = this.exceptionHandlerService.formatException(exception);
+    let status = this.getStatusCode(exception);
+    let finalErrors = errors;
+    let finalMessage = message;
+    if (exception instanceof import_common3.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 = import_common3.HttpStatus.NOT_FOUND;
+          finalMessage = "Route Not Found";
+          finalErrors = [
+            {
+              path: "route",
+              message: [msg]
+            }
+          ];
         }
-      ];
-    }
-    const message = exception && typeof exception === "object" && "message" in exception ? String(exception.message) : "An unexpected error occurred";
-    return [
-      {
-        path: "unknown",
-        message
       }
-    ];
+    }
+    const errorResponse = {
+      success: false,
+      message: finalMessage,
+      errorMessages: finalErrors
+    };
+    if (this.config.enableLogging) {
+      this.logError(request, status, finalErrors, exception);
+    }
+    response.status(status).json(errorResponse);
+  }
+  getStatusCode(exception) {
+    if (exception instanceof import_common3.HttpException) {
+      return exception.getStatus();
+    }
+    return import_common3.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));
   }
 };
-OtherExceptionFormatter = __decorateClass([
-  (0, import_common3.Injectable)()
-], OtherExceptionFormatter);
+GlobalExceptionFilter = __decorateClass([
+  (0, import_common3.Catch)()
+], GlobalExceptionFilter);
 
-// src/exception-filter/global-exception.filter.ts
+// src/module/exception-handler.module.ts
+var import_common6 = require("@nestjs/common");
+
+// src/services/exception-handler.service.ts
+var import_common5 = require("@nestjs/common");
+
+// src/formatters/http-exception.formatter.ts
 var import_common4 = require("@nestjs/common");
-var import_library2 = require("@prisma/client/runtime/library");
-var GlobalExceptionFilter = class {
-  constructor(prismaExceptionFormatter, dtoValidationFormatter, otherValidationFormatter) {
-    this.prismaExceptionFormatter = prismaExceptionFormatter;
-    this.dtoValidationFormatter = dtoValidationFormatter;
-    this.otherValidationFormatter = otherValidationFormatter;
-    this.logger = new import_common4.Logger(GlobalExceptionFilter.name);
+var HttpExceptionFormatter = class {
+  supports(exception) {
+    return exception instanceof import_common4.HttpException;
   }
-  getErrorMessage(exception) {
-    if (exception instanceof import_library2.PrismaClientKnownRequestError || exception instanceof import_library2.PrismaClientValidationError || exception instanceof import_library2.PrismaClientRustPanicError || exception instanceof import_library2.PrismaClientUnknownRequestError || exception instanceof import_library2.PrismaClientInitializationError) {
-      return "Database error";
+  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] }];
+      }
     }
-    if (exception instanceof import_common4.HttpException) {
-      return exception.message || "HTTP 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 "Internal server error";
+    return "An error occurred";
   }
-  catch(exception, host) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    const request = ctx.getRequest();
-    const status = exception instanceof import_common4.HttpException ? exception.getStatus() : import_common4.HttpStatus.INTERNAL_SERVER_ERROR;
-    let errorMessages = [{ path: "unknown", message: "Internal server error" }];
-    if (exception instanceof import_library2.PrismaClientKnownRequestError || exception instanceof import_library2.PrismaClientValidationError || exception instanceof import_library2.PrismaClientRustPanicError || exception instanceof import_library2.PrismaClientUnknownRequestError || exception instanceof import_library2.PrismaClientInitializationError) {
-      errorMessages = this.prismaExceptionFormatter.formatError(exception);
-    } else if (exception instanceof import_common4.HttpException) {
-      errorMessages = this.dtoValidationFormatter.formatDtoValidationException(
-        exception
-      );
-    } else {
-      errorMessages = this.otherValidationFormatter.formatOtherError(exception);
+};
+
+// src/formatters/dto-exception.formatter.ts
+var DtoExceptionFormatter = class {
+  supports(exception) {
+    if (!exception || typeof exception !== "object") {
+      return false;
     }
-    this.logger.error(
-      `${request.method} ${request.url}`,
-      JSON.stringify(errorMessages),
-      "ExceptionFilter"
-    );
-    response.status(status).json({
-      success: false,
-      message: this.getErrorMessage(exception),
-      errorMessages
+    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 [];
     });
   }
 };
-GlobalExceptionFilter = __decorateClass([
-  (0, import_common4.Catch)()
-], GlobalExceptionFilter);
 
-// src/exception-handler.module.ts
-var import_common5 = require("@nestjs/common");
+// 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([
+  (0, import_common5.Injectable)()
+], 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([
-  (0, import_common5.Module)({
-    providers: [
-      GlobalExceptionFilter,
-      PrismaExceptionFormatter,
-      DtoValidationFormatter,
-      OtherExceptionFormatter
-    ],
-    exports: [GlobalExceptionFilter]
-  })
+  (0, import_common6.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";
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DtoValidationFormatter,
   ExceptionHandlerModule,
+  ExceptionHandlerService,
   GlobalExceptionFilter,
-  OtherExceptionFormatter,
-  PrismaExceptionFormatter
+  HttpErrorFormatter,
+  PrismaExceptionFormatter,
+  ValidationErrorFormatter,
+  initializeFormatters
 });
 //# sourceMappingURL=index.js.map