nestjs-exception-handler 1.0.0 → 3.0.0

package/dist/helpers/parse-validation-errors.d.ts

@@ -0,0 +1,10 @@
+export interface ValidationError {
+    property: string;
+    constraints?: Record<string, string>;
+    children?: ValidationError[];
+}
+export interface ParsedValidationError {
+    path: string;
+    message: string;
+}
+export declare function parseValidationErrors(errors: ValidationError[]): ParsedValidationError[];

package/dist/helpers/parse-validation-errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseValidationErrors = parseValidationErrors;
+function parseValidationErrors(errors) {
+    const result = [];
+    for (const error of errors) {
+        if (error.constraints && Object.keys(error.constraints).length > 0) {
+            const messages = Object.values(error.constraints).join(", ");
+            result.push({
+                path: error.property,
+                message: messages,
+            });
+        }
+        if (error.children && error.children.length > 0) {
+            result.push(...parseValidationErrors(error.children));
+        }
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -1,96 +1,3 @@
-import { ExceptionFilter, ArgumentsHost, DynamicModule } from '@nestjs/common';
-
-interface ErrorMessage {
-    path: string;
-    message: string;
-}
-interface StandardErrorResponse {
-    success: boolean;
-    message: string;
-    errorMessages: ErrorMessage[];
-}
-
-interface ExceptionFormatter {
-    supports(exception: unknown): boolean;
-    format(exception: unknown): ErrorMessage[];
-    message(exception: unknown): string;
-}
-
-interface ExceptionHandlerConfig {
-    enableLogging?: boolean;
-    hideStackTrace?: boolean;
-}
-
-declare const DEFAULT_ERROR_MESSAGES: {
-    UNKNOWN_ERROR: string;
-    VALIDATION_ERROR: string;
-    DATABASE_ERROR: string;
-    NOT_FOUND: string;
-    UNAUTHORIZED: string;
-    FORBIDDEN: string;
-    CONFLICT: string;
-    BAD_REQUEST: string;
-};
-declare const PRISMA_ERROR_MESSAGES: Record<string, string>;
-declare const DEFAULT_PATH = "unknown";
-
-declare function isPrismaError(exception: unknown): boolean;
-
-declare class PrismaExceptionFormatter implements ExceptionFormatter {
-    supports(exception: unknown): boolean;
-    format(exception: unknown): ErrorMessage[];
-    message(exception: unknown): string;
-}
-
-declare class DtoExceptionFormatter implements ExceptionFormatter {
-    supports(exception: unknown): boolean;
-    format(exception: unknown): ErrorMessage[];
-    message(exception: unknown): string;
-    private formatValidationErrors;
-    private formatChildrenErrors;
-}
-
-declare class HttpExceptionFormatter implements ExceptionFormatter {
-    supports(exception: unknown): boolean;
-    format(exception: unknown): ErrorMessage[];
-    message(exception: unknown): string;
-}
-
-declare class UnknownExceptionFormatter implements ExceptionFormatter {
-    supports(_exception: unknown): boolean;
-    format(_exception: unknown): ErrorMessage[];
-    message(_exception: unknown): string;
-}
-
-declare class ExceptionHandlerService {
-    private formatters;
-    private defaultFormatter;
-    constructor();
-    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 exceptionHandlerService;
-    private readonly logger;
-    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;
-
-export { DEFAULT_ERROR_MESSAGES, DEFAULT_PATH, DtoExceptionFormatter, ErrorMessage, ExceptionFormatter, ExceptionHandlerConfig, ExceptionHandlerModule, ExceptionHandlerService, GlobalExceptionFilter, HttpExceptionFormatter, PRISMA_ERROR_MESSAGES, PrismaExceptionFormatter, StandardErrorResponse, UnknownExceptionFormatter, initializeFormatters, isPrismaError };
+export * from "./formatter";
+export * from "./helpers";
+export * from "./global-exception-filter";

package/dist/index.js

@@ -1,384 +1,19 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
-  return result;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  DEFAULT_ERROR_MESSAGES: () => DEFAULT_ERROR_MESSAGES,
-  DEFAULT_PATH: () => DEFAULT_PATH,
-  DtoExceptionFormatter: () => DtoExceptionFormatter,
-  ExceptionHandlerModule: () => ExceptionHandlerModule,
-  ExceptionHandlerService: () => ExceptionHandlerService,
-  GlobalExceptionFilter: () => GlobalExceptionFilter,
-  HttpExceptionFormatter: () => HttpExceptionFormatter,
-  PRISMA_ERROR_MESSAGES: () => PRISMA_ERROR_MESSAGES,
-  PrismaExceptionFormatter: () => PrismaExceptionFormatter,
-  UnknownExceptionFormatter: () => UnknownExceptionFormatter,
-  initializeFormatters: () => initializeFormatters,
-  isPrismaError: () => isPrismaError
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/constants/default-messages.ts
-var DEFAULT_ERROR_MESSAGES = {
-  UNKNOWN_ERROR: "An unexpected error occurred",
-  VALIDATION_ERROR: "Validation failed",
-  DATABASE_ERROR: "Database error",
-  NOT_FOUND: "Resource not found",
-  UNAUTHORIZED: "Unauthorized access",
-  FORBIDDEN: "Access forbidden",
-  CONFLICT: "Conflict occurred",
-  BAD_REQUEST: "Bad request"
-};
-var PRISMA_ERROR_MESSAGES = {
-  P2002: "A record with this {field} already exists.",
-  P2003: "This {field} does not exist.",
-  P2005: "Invalid value for {field}.",
-  P2006: "Invalid format for {field}.",
-  P2025: "Record not found."
-};
-var DEFAULT_PATH = "unknown";
-
-// src/utils/is-prisma-error.ts
-function isPrismaError(exception) {
-  if (!exception || typeof exception !== "object") {
-    return false;
-  }
-  const error = exception;
-  const hasErrorCode = typeof error.code === "string";
-  const hasClientVersion = typeof error.clientVersion === "string";
-  const hasMeta = typeof error.meta === "object";
-  return hasErrorCode && (hasClientVersion || hasMeta);
-}
-
-// src/formatters/prisma-exception.formatter.ts
-var PrismaExceptionFormatter = class {
-  supports(exception) {
-    return isPrismaError(exception);
-  }
-  format(exception) {
-    const error = exception;
-    const code = error.code;
-    const meta = error.meta;
-    const target = error.target;
-    const messageTemplate = PRISMA_ERROR_MESSAGES[code] || "Database operation failed";
-    let path = "unknown";
-    let message = messageTemplate;
-    if (code === "P2002" && target && target.length > 0) {
-      path = target[0];
-      message = messageTemplate.replace("{field}", path);
-    } else if (code === "P2003" && meta?.field_name) {
-      path = meta.field_name;
-      message = messageTemplate.replace("{field}", path);
-    } else if (code === "P2005" && meta?.field_name) {
-      path = meta.field_name;
-      message = messageTemplate.replace("{field}", path);
-    } else if (code === "P2006" && meta?.field_name) {
-      path = meta.field_name;
-      message = messageTemplate.replace("{field}", path);
-    } else if (code === "P2025") {
-      path = "record";
-      message = messageTemplate;
-    }
-    return [{ path, message }];
-  }
-  message(exception) {
-    const error = exception;
-    const code = error.code;
-    return PRISMA_ERROR_MESSAGES[code] || "Database error";
-  }
-};
-
-// 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 Object.entries(constraints).map(([, value]) => ({
-          path: error.property,
-          message: value
-        }));
-      }
-      return [];
-    });
-  }
-  formatChildrenErrors(children) {
-    return children.flatMap((child) => {
-      const constraints = child.constraints;
-      if (constraints) {
-        return Object.entries(constraints).map(([, value]) => ({
-          path: child.property,
-          message: value
-        }));
-      }
-      return [];
-    });
-  }
-};
-
-// src/formatters/http-exception.formatter.ts
-var import_common = require("@nestjs/common");
-var HttpExceptionFormatter = class {
-  supports(exception) {
-    return exception instanceof import_common.HttpException;
-  }
-  format(exception) {
-    const httpException = exception;
-    const response = httpException.getResponse();
-    if (typeof response === "string") {
-      return [{ path: "unknown", message: response }];
-    }
-    if (typeof response === "object" && response !== null) {
-      const responseObj = response;
-      if (responseObj.message && Array.isArray(responseObj.message)) {
-        return responseObj.message.map((msg) => ({
-          path: "unknown",
-          message: msg
-        }));
-      }
-      if (responseObj.message && typeof responseObj.message === "string") {
-        return [{ path: "unknown", message: responseObj.message }];
-      }
-      if (responseObj.error && typeof responseObj.error === "string") {
-        return [{ path: "unknown", message: responseObj.error }];
-      }
-    }
-    return [{ path: "unknown", 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/unknown-exception.formatter.ts
-var UnknownExceptionFormatter = class {
-  supports(_exception) {
-    return true;
-  }
-  format(_exception) {
-    return [
-      {
-        path: DEFAULT_PATH,
-        message: "Internal server error"
-      }
-    ];
-  }
-  message(_exception) {
-    return "Internal server error";
-  }
-};
-
-// src/services/exception-handler.service.ts
-var import_common2 = require("@nestjs/common");
-var ExceptionHandlerService = class {
-  constructor() {
-    this.formatters = [];
-    this.defaultFormatter = new UnknownExceptionFormatter();
-  }
-  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_common2.Injectable)()
-], ExceptionHandlerService);
-
-// src/filter/global-exception.filter.ts
-var import_common3 = require("@nestjs/common");
-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);
-    const status = this.getStatusCode(exception);
-    const errorResponse = {
-      success: false,
-      message,
-      errorMessages: errors
-    };
-    if (this.config.enableLogging) {
-      this.logError(request, status, errors, 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));
-  }
-};
-GlobalExceptionFilter = __decorateClass([
-  (0, import_common3.Catch)()
-], GlobalExceptionFilter);
-
-// src/module/exception-handler.module.ts
-var import_common4 = require("@nestjs/common");
-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_common4.Module)({})
-], ExceptionHandlerModule);
-function initializeFormatters(service) {
-  service.registerFormatter(new PrismaExceptionFormatter());
-  service.registerFormatter(new DtoExceptionFormatter());
-  service.registerFormatter(new HttpExceptionFormatter());
-  service.registerFormatter(new UnknownExceptionFormatter());
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_ERROR_MESSAGES,
-  DEFAULT_PATH,
-  DtoExceptionFormatter,
-  ExceptionHandlerModule,
-  ExceptionHandlerService,
-  GlobalExceptionFilter,
-  HttpExceptionFormatter,
-  PRISMA_ERROR_MESSAGES,
-  PrismaExceptionFormatter,
-  UnknownExceptionFormatter,
-  initializeFormatters,
-  isPrismaError
-});
-//# sourceMappingURL=index.js.map
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./formatter"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./global-exception-filter"), exports);

package/package.json

@@ -1,72 +1,75 @@
 {
   "name": "nestjs-exception-handler",
-  "version": "1.0.0",
-  "description": "A production-grade global exception handling system for NestJS applications",
+  "version": "3.0.0",
+  "description": "A comprehensive global exception filter for NestJS that handles all common NestJS, Prisma, and Node.js exceptions with formatted error responses.",
   "main": "dist/index.js",
-  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.mjs",
+      "import": "./dist/index.js",
       "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md"
   ],
   "scripts": {
-    "build": "tsup",
-    "lint": "eslint src --ext .ts",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:cov": "jest --coverage",
-    "prepublishOnly": "npm run build"
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"No tests specified\" && exit 0"
   },
   "keywords": [
     "nestjs",
     "exception",
-    "handler",
     "filter",
     "error",
+    "handler",
     "prisma",
-    "validation"
+    "error-handler",
+    "exception-filter",
+    "global-exception-filter",
+    "nestjs-exception",
+    "nestjs-error",
+    "validation",
+    "class-validator"
   ],
-  "author": "Nurul Islam Rimon",
+  "author": "Nurul Islam Rimon <nurulislamrimon@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/nurulislamrimon/nestjs-exception-handler.git"
   },
+  "bugs": {
+    "url": "https://github.com/nurulislamrimon/nestjs-exception-handler/issues"
+  },
+  "homepage": "https://github.com/nurulislamrimon/nestjs-exception-handler#readme",
+  "engines": {
+    "node": ">=16"
+  },
   "peerDependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
-    "@prisma/client": "^5.0.0",
-    "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.0"
+    "@prisma/client": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": true
+    },
+    "@nestjs/core": {
+      "optional": true
+    },
+    "@prisma/client": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
-    "@nestjs/testing": "^10.4.22",
-    "@prisma/client": "^5.0.0",
-    "@types/express": "^4.17.17",
-    "@types/jest": "^29.5.0",
-    "@types/node": "^20.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.0.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.5",
-    "jest": "^29.5.0",
-    "prettier": "^3.0.0",
-    "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.0",
-    "ts-jest": "^29.1.0",
-    "ts-node": "^10.9.2",
-    "tsup": "^7.0.0",
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {}
+    "@prisma/client": "^6.9.0",
+    "@types/express": "^5.0.0",
+    "@types/node": "^24.0.2",
+    "typescript": "^5.8.3"
+  }
 }