nestjs-exception-handler 1.0.0 → 3.0.0

package/dist/global-exception-filter.js

@@ -0,0 +1,249 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const library_1 = require("@prisma/client/runtime/library");
+const parse_http_exception_1 = require("./helpers/parse-http-exception");
+const parse_prisma_errors_1 = require("./helpers/parse-prisma-errors");
+const parse_validation_errors_1 = require("./helpers/parse-validation-errors");
+let GlobalExceptionFilter = (() => {
+    let _classDecorators = [(0, common_1.Catch)()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var GlobalExceptionFilter = _classThis = class {
+        constructor() {
+            this.logger = new common_1.Logger(GlobalExceptionFilter.name);
+        }
+        catch(exception, host) {
+            const ctx = host.switchToHttp();
+            const response = ctx.getResponse();
+            const request = ctx.getRequest();
+            const errorResponse = this.formatException(exception);
+            this.logException(exception, request);
+            const status = this.getStatus(exception);
+            response.status(status).json(errorResponse);
+        }
+        formatException(exception) {
+            if (exception instanceof common_1.HttpException) {
+                return this.formatHttpException(exception);
+            }
+            if (this.isPrismaError(exception)) {
+                return this.formatPrismaException(exception);
+            }
+            if (this.isValidationError(exception)) {
+                return this.formatValidationException(exception);
+            }
+            return this.formatGenericError(exception);
+        }
+        formatHttpException(exception) {
+            const parsed = (0, parse_http_exception_1.parseHttpException)(exception);
+            const status = exception.getStatus();
+            const response = exception.getResponse();
+            let message;
+            if (typeof response === "object" && response !== null) {
+                const res = response;
+                message = typeof res.error === "string"
+                    ? res.error
+                    : this.getDefaultMessageForStatus(status);
+            }
+            else {
+                message = exception.message || this.getDefaultMessageForStatus(status);
+            }
+            return {
+                success: false,
+                message,
+                errorMessages: parsed,
+            };
+        }
+        formatPrismaException(exception) {
+            if (exception instanceof library_1.PrismaClientKnownRequestError ||
+                exception instanceof library_1.PrismaClientValidationError ||
+                exception instanceof library_1.PrismaClientInitializationError) {
+                const parsed = (0, parse_prisma_errors_1.parsePrismaError)(exception);
+                let message;
+                if (exception instanceof library_1.PrismaClientKnownRequestError) {
+                    switch (exception.code) {
+                        case "P2002":
+                            message = "Unique constraint failed";
+                            break;
+                        case "P2025":
+                            message = "Record not found";
+                            break;
+                        default:
+                            message = "Database error occurred";
+                    }
+                }
+                else if (exception instanceof library_1.PrismaClientValidationError) {
+                    message = "Invalid data provided";
+                }
+                else {
+                    message = "Database connection failed";
+                }
+                return {
+                    success: false,
+                    message,
+                    errorMessages: parsed.length > 0 ? parsed : [{ path: "database", message }],
+                };
+            }
+            return {
+                success: false,
+                message: "Database error occurred",
+                errorMessages: [{ path: "database", message: "Database error occurred" }],
+            };
+        }
+        formatValidationException(exception) {
+            const response = exception.getResponse();
+            const messages = [];
+            if (typeof response === "object" && response !== null) {
+                const res = response;
+                if (Array.isArray(res.message)) {
+                    const validationErrors = res.message;
+                    for (const error of validationErrors) {
+                        if (typeof error === "object" && error !== null) {
+                            const errorObj = error;
+                            if (errorObj.errors && Array.isArray(errorObj.errors)) {
+                                const parsed = (0, parse_validation_errors_1.parseValidationErrors)(errorObj.errors);
+                                messages.push(...parsed);
+                            }
+                        }
+                    }
+                }
+            }
+            if (messages.length === 0) {
+                messages.push({ path: "validation", message: "Validation failed" });
+            }
+            return {
+                success: false,
+                message: "Validation failed",
+                errorMessages: messages,
+            };
+        }
+        formatGenericError(exception) {
+            if (exception instanceof Error) {
+                return {
+                    success: false,
+                    message: exception.message || "Internal server error",
+                    errorMessages: [
+                        {
+                            path: "server",
+                            message: exception.message || "Internal server error",
+                        },
+                    ],
+                };
+            }
+            return {
+                success: false,
+                message: "Internal server error",
+                errorMessages: [
+                    {
+                        path: "server",
+                        message: "Internal server error",
+                    },
+                ],
+            };
+        }
+        isPrismaError(exception) {
+            return (exception instanceof library_1.PrismaClientKnownRequestError ||
+                exception instanceof library_1.PrismaClientValidationError ||
+                exception instanceof library_1.PrismaClientInitializationError);
+        }
+        isValidationError(exception) {
+            if (!(exception instanceof common_1.HttpException))
+                return false;
+            const response = exception.getResponse();
+            if (typeof response !== "object" || response === null)
+                return false;
+            const res = response;
+            return (exception.getStatus() === common_1.HttpStatus.BAD_REQUEST &&
+                Array.isArray(res.message));
+        }
+        getStatus(exception) {
+            if (exception instanceof common_1.HttpException) {
+                return exception.getStatus();
+            }
+            if (this.isPrismaError(exception)) {
+                return common_1.HttpStatus.BAD_REQUEST;
+            }
+            if (this.isValidationError(exception)) {
+                return common_1.HttpStatus.BAD_REQUEST;
+            }
+            return common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        }
+        getDefaultMessageForStatus(status) {
+            switch (status) {
+                case common_1.HttpStatus.BAD_REQUEST:
+                    return "Bad request";
+                case common_1.HttpStatus.UNAUTHORIZED:
+                    return "Unauthorized";
+                case common_1.HttpStatus.FORBIDDEN:
+                    return "Forbidden";
+                case common_1.HttpStatus.NOT_FOUND:
+                    return "Resource not found";
+                case common_1.HttpStatus.CONFLICT:
+                    return "Conflict";
+                default:
+                    return "Internal server error";
+            }
+        }
+        logException(exception, request) {
+            const method = request.method;
+            const url = request.url;
+            const ip = request.ip || request.headers["x-forwarded-for"] || "unknown";
+            if (exception instanceof Error) {
+                this.logger.error(`${method} ${url} - ${ip} - ${exception.message}`, exception.stack);
+            }
+            else {
+                this.logger.error(`${method} ${url} - ${ip} - ${JSON.stringify(exception)}`);
+            }
+        }
+    };
+    __setFunctionName(_classThis, "GlobalExceptionFilter");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        GlobalExceptionFilter = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return GlobalExceptionFilter = _classThis;
+})();
+exports.GlobalExceptionFilter = GlobalExceptionFilter;

package/dist/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./parse-validation-errors";
+export * from "./parse-prisma-errors";
+export * from "./parse-http-exception";

package/dist/helpers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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("./parse-validation-errors"), exports);
+__exportStar(require("./parse-prisma-errors"), exports);
+__exportStar(require("./parse-http-exception"), exports);

package/dist/helpers/parse-http-exception.d.ts

@@ -0,0 +1,16 @@
+import { HttpException } from "@nestjs/common";
+export interface HttpErrorResponse {
+    success: boolean;
+    message: string;
+    errorMessages: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+export interface ParsedHttpError {
+    path: string;
+    message: string;
+}
+export declare function parseHttpException(exception: HttpException): ParsedHttpError[];
+export declare function isNestJsHttpException(exception: unknown): boolean;
+export declare function getExceptionType(exception: unknown): string;

package/dist/helpers/parse-http-exception.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHttpException = parseHttpException;
+exports.isNestJsHttpException = isNestJsHttpException;
+exports.getExceptionType = getExceptionType;
+const common_1 = require("@nestjs/common");
+function parseHttpException(exception) {
+    const response = exception.getResponse();
+    const status = exception.getStatus();
+    const message = exception.message;
+    if (typeof response === "string") {
+        return [
+            {
+                path: getPathForStatus(status),
+                message: response || message,
+            },
+        ];
+    }
+    if (typeof response === "object" && response !== null) {
+        const res = response;
+        if (Array.isArray(res.message)) {
+            return res.message.map((msg) => {
+                if (typeof msg === "string") {
+                    return {
+                        path: res.path || getPathForStatus(status),
+                        message: msg,
+                    };
+                }
+                if (typeof msg === "object" && msg !== null) {
+                    const msgObj = msg;
+                    return {
+                        path: msgObj.path || msgObj.property || getPathForStatus(status),
+                        message: msgObj.message || JSON.stringify(msg),
+                    };
+                }
+                return {
+                    path: getPathForStatus(status),
+                    message: String(msg),
+                };
+            });
+        }
+        if (res.message && typeof res.message === "string") {
+            return [
+                {
+                    path: res.path || getPathForStatus(status),
+                    message: res.message,
+                },
+            ];
+        }
+        if (res.error && typeof res.error === "string") {
+            return [
+                {
+                    path: getPathForStatus(status),
+                    message: res.error,
+                },
+            ];
+        }
+    }
+    return [
+        {
+            path: getPathForStatus(status),
+            message: message || "HTTP error occurred",
+        },
+    ];
+}
+function getPathForStatus(status) {
+    switch (status) {
+        case 400:
+            return "request";
+        case 401:
+            return "authentication";
+        case 403:
+            return "authorization";
+        case 404:
+            return "resource";
+        case 409:
+            return "conflict";
+        default:
+            return "request";
+    }
+}
+function isNestJsHttpException(exception) {
+    return exception instanceof common_1.HttpException;
+}
+function getExceptionType(exception) {
+    if (exception instanceof common_1.BadRequestException)
+        return "BadRequestException";
+    if (exception instanceof common_1.UnauthorizedException)
+        return "UnauthorizedException";
+    if (exception instanceof common_1.ForbiddenException)
+        return "ForbiddenException";
+    if (exception instanceof common_1.NotFoundException)
+        return "NotFoundException";
+    if (exception instanceof common_1.ConflictException)
+        return "ConflictException";
+    if (exception instanceof common_1.HttpException)
+        return "HttpException";
+    return "Unknown";
+}

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

@@ -0,0 +1,5 @@
+export interface ParsedPrismaError {
+    path: string;
+    message: string;
+}
+export declare function parsePrismaError(exception: unknown): ParsedPrismaError[];

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

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePrismaError = parsePrismaError;
+const library_1 = require("@prisma/client/runtime/library");
+function parsePrismaError(exception) {
+    if (exception instanceof library_1.PrismaClientKnownRequestError) {
+        return parseKnownRequestError(exception);
+    }
+    if (exception instanceof library_1.PrismaClientValidationError) {
+        return parseValidationError(exception);
+    }
+    if (exception instanceof library_1.PrismaClientInitializationError) {
+        return parseInitializationError(exception);
+    }
+    return [];
+}
+function parseKnownRequestError(exception) {
+    const code = exception.code;
+    const meta = exception.meta;
+    switch (code) {
+        case "P2002": {
+            const target = Array.isArray(meta === null || meta === void 0 ? void 0 : meta.target)
+                ? meta.target[0]
+                : (meta === null || meta === void 0 ? void 0 : meta.target) || "field";
+            return [
+                {
+                    path: target,
+                    message: "Unique constraint failed",
+                },
+            ];
+        }
+        case "P2025": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.model_name) || "record",
+                    message: "Record not found",
+                },
+            ];
+        }
+        case "P2003": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.field_name) || "relation",
+                    message: "Foreign key constraint failed",
+                },
+            ];
+        }
+        case "P2000": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.field_name) || "field",
+                    message: `Value too long for column ${meta === null || meta === void 0 ? void 0 : meta.field_name}`,
+                },
+            ];
+        }
+        case "P2001": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.field_name) || "record",
+                    message: "Record does not exist",
+                },
+            ];
+        }
+        case "P2004": {
+            return [
+                {
+                    path: "database",
+                    message: "A constraint failed on the database",
+                },
+            ];
+        }
+        case "P2005": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.field_name) || "field",
+                    message: `Invalid value for field ${meta === null || meta === void 0 ? void 0 : meta.field_name}`,
+                },
+            ];
+        }
+        case "P2006": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.field_name) || "field",
+                    message: `Invalid value for field ${meta === null || meta === void 0 ? void 0 : meta.field_name}`,
+                },
+            ];
+        }
+        case "P2007": {
+            return [
+                {
+                    path: "database",
+                    message: "Database error",
+                },
+            ];
+        }
+        case "P2008": {
+            return [
+                {
+                    path: "query",
+                    message: "Failed to parse query",
+                },
+            ];
+        }
+        case "P2009": {
+            return [
+                {
+                    path: "query",
+                    message: "Failed to validate query",
+                },
+            ];
+        }
+        case "P2010": {
+            return [
+                {
+                    path: "query",
+                    message: "Raw query failed",
+                },
+            ];
+        }
+        case "P2011": {
+            return [
+                {
+                    path: "database",
+                    message: "Null constraint violation",
+                },
+            ];
+        }
+        case "P2012": {
+            return [
+                {
+                    path: "database",
+                    message: "Missing a required value",
+                },
+            ];
+        }
+        case "P2013": {
+            return [
+                {
+                    path: "relation",
+                    message: "Missing the required relation",
+                },
+            ];
+        }
+        case "P2014": {
+            return [
+                {
+                    path: "relation",
+                    message: "Relation would be violated",
+                },
+            ];
+        }
+        case "P2015": {
+            return [
+                {
+                    path: "query",
+                    message: "Related record not found",
+                },
+            ];
+        }
+        case "P2016": {
+            return [
+                {
+                    path: "query",
+                    message: "Query interpretation error",
+                },
+            ];
+        }
+        case "P2017": {
+            return [
+                {
+                    path: "relation",
+                    message: "Records are not connected",
+                },
+            ];
+        }
+        case "P2018": {
+            return [
+                {
+                    path: "relation",
+                    message: "Required connected records not found",
+                },
+            ];
+        }
+        case "P2019": {
+            return [
+                {
+                    path: "input",
+                    message: "Input error",
+                },
+            ];
+        }
+        case "P2020": {
+            return [
+                {
+                    path: "value",
+                    message: "Value out of range",
+                },
+            ];
+        }
+        case "P2021": {
+            return [
+                {
+                    path: "table",
+                    message: `Table ${meta === null || meta === void 0 ? void 0 : meta.table} does not exist in the current database`,
+                },
+            ];
+        }
+        case "P2022": {
+            return [
+                {
+                    path: "column",
+                    message: `Column ${meta === null || meta === void 0 ? void 0 : meta.column} does not exist`,
+                },
+            ];
+        }
+        case "P2023": {
+            return [
+                {
+                    path: "database",
+                    message: "Database schema inconsistent",
+                },
+            ];
+        }
+        case "P2024": {
+            return [
+                {
+                    path: "database",
+                    message: "Timed out fetching a new connection from the connection pool",
+                },
+            ];
+        }
+        case "P2025": {
+            return [
+                {
+                    path: (meta === null || meta === void 0 ? void 0 : meta.model_name) || "record",
+                    message: "Record not found",
+                },
+            ];
+        }
+        case "P2026": {
+            return [
+                {
+                    path: "database",
+                    message: "Current provider does not support this feature",
+                },
+            ];
+        }
+        case "P2027": {
+            return [
+                {
+                    path: "database",
+                    message: "Multiple database errors",
+                },
+            ];
+        }
+        default: {
+            return [
+                {
+                    path: "database",
+                    message: exception.message || "Database error occurred",
+                },
+            ];
+        }
+    }
+}
+function parseValidationError(exception) {
+    const message = exception.message;
+    const match = message.match(/Argument `(\w+)` is missing/);
+    if (match) {
+        const field = match[1];
+        return [
+            {
+                path: field,
+                message: `Argument \`${field}\` is missing`,
+            },
+        ];
+    }
+    return [
+        {
+            path: "query",
+            message: message || "Invalid query",
+        },
+    ];
+}
+function parseInitializationError(_exception) {
+    return [
+        {
+            path: "database",
+            message: "Failed to connect to the database",
+        },
+    ];
+}