@nest-yalc-2/errors 1.3.4

package/src/error.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.enum.js","sourceRoot":"","sources":["error.enum.ts"],"names":[],"mappings":";;;AAAA,2CAA4C;AAE5C,IAAY,UA4BX;AA5BD,WAAY,UAAU;IAEpB,yCAA2B,CAAA;IAC3B,6CAA+B,CAAA;IAE/B,2CAA6B,CAAA;IAE7B,qCAAuB,CAAA;IAEvB,mDAAqC,CAAA;IACrC,qCAAuB,CAAA;IACvB,uDAAyC,CAAA;IACzC,qCAAuB,CAAA;IACvB,uDAAyC,CAAA;IACzC,+CAAiC,CAAA;IACjC,mCAAqB,CAAA;IACrB,2BAAa,CAAA;IACb,+DAAiD,CAAA;IACjD,2DAA6C,CAAA;IAC7C,6EAA+D,CAAA;IAC/D,qDAAuC,CAAA;IAGvC,6DAA+C,CAAA;IAC/C,iDAAmC,CAAA;IACnC,yCAA2B,CAAA;IAC3B,yDAA2C,CAAA;IAC3C,iDAAmC,CAAA;AACrC,CAAC,EA5BW,UAAU,0BAAV,UAAU,QA4BrB;AAEM,MAAM,uBAAuB,GAAG,CAAC,IAAY,EAAU,EAAE;IAC9D,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,CAAC,mBAAU,CAAC,CAAC,IAAI,CACxD,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAC9B,EAAE,CAAC,CAAC,CAAC,CAAC;IACP,MAAM,SAAS,GAAG,UAAU,CAAC,kBAA6C,CAAC,CAAC;IAC5E,OAAO,SAAS,IAAI,SAAS,CAAC;AAChC,CAAC,CAAC;AANW,QAAA,uBAAuB,2BAMlC;AAEF,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC9B,sDAA8B,CAAA;IAC9B,8CAAsB,CAAA;IACtB,kDAA0B,CAAA;AAC5B,CAAC,EAJW,oBAAoB,oCAApB,oBAAoB,QAI/B"}

package/src/error.enum.ts

@@ -0,0 +1,45 @@
+import { HttpStatus } from '@nestjs/common';
+
+export enum ErrorsEnum {
+  // 400 Client Errors
+  BAD_REQUEST = 'Bad request', // 400
+  INVALID_VALUE = 'Invalid value', // 400 (custom)
+
+  UNAUTHORIZED = 'Unauthorized', // 401
+
+  BAD_LOGIN = 'Bad login', // 401 (custom, usually used for unauthorized access with wrong credentials)
+
+  PAYMENT_REQUIRED = 'Payment required', // 402
+  FORBIDDEN = 'Forbidden', // 403
+  FORBIDDEN_RESOURCE = 'Forbidden resource', // 403 (custom)
+  NOT_FOUND = 'Not found', // 404
+  METHOD_NOT_ALLOWED = 'Method not allowed', // 405
+  NOT_ACCEPTABLE = 'Not acceptable', // 406
+  CONFLICT = 'Conflict', // 409
+  GONE = 'Gone', // 410
+  UNSUPPORTED_MEDIA_TYPE = 'Unsupported media type', // 415
+  UNPROCESSABLE_ENTITY = 'Unprocessable entity', // 422
+  UNAVAILABLE_FOR_LEGAL_REASONS = 'Unavailable for legal reasons', // 451
+  TOO_MANY_REQUESTS = 'Too many requests', // 429
+
+  // 500 Server Errors
+  INTERNAL_SERVER_ERROR = 'Internal server error', // 500
+  NOT_IMPLEMENTED = 'Not implemented', // 501
+  BAD_GATEWAY = 'Bad gateway', // 502
+  SERVICE_UNAVAILABLE = 'Service unavailable', // 503
+  GATEWAY_TIMEOUT = 'Gateway timeout', // 504
+}
+
+export const getHttpStatusNameByCode = (code: number): string => {
+  const httpStatusEnumName = Object.entries(HttpStatus).find(
+    ([, value]) => value === code,
+  )?.[0];
+  const enumValue = ErrorsEnum[httpStatusEnumName as keyof typeof ErrorsEnum];
+  return enumValue ?? 'Unknown';
+};
+
+export enum ExceptionContextEnum {
+  DATABASE = 'DatabaseException',
+  HTTP = 'HttpException',
+  SYSTEM = 'SystemException',
+}

package/src/error.helper.d.ts

@@ -0,0 +1,2 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+export declare function getStatusCodeFromError(error: ClassType<any> | any): any;

package/src/error.helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStatusCodeFromError = getStatusCodeFromError;
+const class_helper_js_1 = require("@nest-yalc-2/utils/class.helper.js");
+const http_helper_js_1 = require("@nest-yalc-2/utils/http.helper.js");
+const default_error_js_1 = require("./default.error.js");
+function getStatusCodeFromError(error) {
+    if (!(0, class_helper_js_1.isClass)(error)) {
+        if (error.getStatus) {
+            return error.getStatus();
+        }
+        return null;
+    }
+    if ((0, default_error_js_1.isDefaultErrorMixinClass)(error)) {
+        return error.defaultStatusCode;
+    }
+    const errorName = error.name;
+    return http_helper_js_1.httpExceptionStatusCodes[errorName] || null;
+}
+//# sourceMappingURL=error.helper.js.map

package/src/error.helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.helper.js","sourceRoot":"","sources":["error.helper.ts"],"names":[],"mappings":";;AASA,wDAwBC;AAhCD,wEAA6D;AAC7D,sEAA6E;AAC7E,yDAA8D;AAM9D,SAAgB,sBAAsB,CAAC,KAA2B;IAIhE,IAAI,CAAC,IAAA,yBAAO,EAAC,KAAK,CAAC,EAAE,CAAC;QACpB,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,SAAS,EAAE,CAAC;QAC3B,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAKD,IAAI,IAAA,2CAAwB,EAAC,KAAK,CAAC,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC,iBAAiB,CAAC;IACjC,CAAC;IAKD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;IAC7B,OAAO,yCAAwB,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;AACrD,CAAC"}

package/src/error.helper.ts

@@ -0,0 +1,34 @@
+import { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { isClass } from '@nest-yalc-2/utils/class.helper.js';
+import { httpExceptionStatusCodes } from '@nest-yalc-2/utils/http.helper.js';
+import { isDefaultErrorMixinClass } from './default.error.js';
+
+/**
+ * Function to convert all HttpException based errors classes to their corresponding status code
+ * using a predefined list of status codes
+ */
+export function getStatusCodeFromError(error: ClassType<any> | any) {
+  /**
+   * If it's not a class, check if it has a getStatus method
+   */
+  if (!isClass(error)) {
+    if (error.getStatus) {
+      return error.getStatus();
+    }
+
+    return null;
+  }
+
+  /**
+   * Check Default error classes
+   */
+  if (isDefaultErrorMixinClass(error)) {
+    return error.defaultStatusCode;
+  }
+
+  /**
+   * Check HttpException classes
+   */
+  const errorName = error.name;
+  return httpExceptionStatusCodes[errorName] || null;
+}

package/src/filters/database-exception.filter.d.ts

@@ -0,0 +1,7 @@
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import * as common from '@nestjs/common';
+export declare class DatabaseExceptionFilter implements GqlExceptionFilter {
+    private logger;
+    constructor(logger: common.LoggerService);
+    catch(error: Error, host: common.ArgumentsHost): Error;
+}

package/src/filters/database-exception.filter.js

@@ -0,0 +1,74 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseExceptionFilter = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const common = __importStar(require("@nestjs/common"));
+const typeorm_1 = require("typeorm");
+const error_enum_js_1 = require("../error.enum.js");
+let DatabaseExceptionFilter = class DatabaseExceptionFilter {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    catch(error, host) {
+        const gqlHost = graphql_1.GqlArgumentsHost.create(host);
+        gqlHost.getType();
+        switch (true) {
+            case error instanceof typeorm_1.EntityNotFoundError:
+                this.logger.error(error, error_enum_js_1.ExceptionContextEnum.DATABASE);
+                error = new common.InternalServerErrorException(error);
+                break;
+            default:
+                this.logger.error(error, error.stack, error_enum_js_1.ExceptionContextEnum.DATABASE);
+                break;
+        }
+        return error;
+    }
+};
+exports.DatabaseExceptionFilter = DatabaseExceptionFilter;
+exports.DatabaseExceptionFilter = DatabaseExceptionFilter = __decorate([
+    common.Catch(typeorm_1.EntityNotFoundError, typeorm_1.ConnectionNotFoundError),
+    __metadata("design:paramtypes", [Object])
+], DatabaseExceptionFilter);
+//# sourceMappingURL=database-exception.filter.js.map

package/src/filters/database-exception.filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-exception.filter.js","sourceRoot":"","sources":["database-exception.filter.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6CAAuE;AACvE,uDAAyC;AAEzC,qCAAuE;AACvE,oDAAwD;AAGjD,IAAM,uBAAuB,GAA7B,MAAM,uBAAuB;IAClC,YAAoB,MAA4B;QAA5B,WAAM,GAAN,MAAM,CAAsB;IAAG,CAAC;IAEpD,KAAK,CAAC,KAAY,EAAE,IAA0B;QAC5C,MAAM,OAAO,GAAG,0BAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9C,OAAO,CAAC,OAAO,EAAE,CAAC;QAWlB,QAAQ,IAAI,EAAE,CAAC;YAIb,KAAK,KAAK,YAAY,6BAAmB;gBACvC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,oCAAoB,CAAC,QAAQ,CAAC,CAAC;gBACxD,KAAK,GAAG,IAAI,MAAM,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC;gBAEvD,MAAM;YAER;gBACE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,oCAAoB,CAAC,QAAQ,CAAC,CAAC;gBAErE,MAAM;QACV,CAAC;QAGD,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAA;AAnCY,0DAAuB;kCAAvB,uBAAuB;IADnC,MAAM,CAAC,KAAK,CAAC,6BAAmB,EAAE,iCAAuB,CAAC;;GAC9C,uBAAuB,CAmCnC"}

package/src/filters/database-exception.filter.ts

@@ -0,0 +1,43 @@
+import { GqlExceptionFilter, GqlArgumentsHost } from '@nestjs/graphql';
+import * as common from '@nestjs/common';
+// We can import more errors from the typeorm/error folder if necessary, nothing is exported though, so use explicit paths.
+import { EntityNotFoundError, ConnectionNotFoundError } from 'typeorm';
+import { ExceptionContextEnum } from '../error.enum.js';
+
+@common.Catch(EntityNotFoundError, ConnectionNotFoundError)
+export class DatabaseExceptionFilter implements GqlExceptionFilter {
+  constructor(private logger: common.LoggerService) {}
+
+  catch(error: Error, host: common.ArgumentsHost) {
+    const gqlHost = GqlArgumentsHost.create(host);
+    gqlHost.getType();
+
+    // Normally transactions are for performance monitoring,
+    // Op and Name reflect which operation and function we are running
+    // Could not get issue tracking working without, using exception filter as op.
+    // const transaction = Sentry.startTransaction({
+    //   op: 'DatabaseExceptionFilter', // operation (encode)
+    //   name: 'Caught Error', // name (parseAvatarImage)
+    // });
+
+    // TODO: Validate when monitoring is in place if we need an eventEmitter here instead of log
+    switch (true) {
+      // Re-throw a new 500 HTTP-friendly error
+      // Add more TypeORM errors here, because there's no base Error class
+      // @url: https://github.com/typeorm/typeorm/issues/3479
+      case error instanceof EntityNotFoundError:
+        this.logger.error(error, ExceptionContextEnum.DATABASE);
+        error = new common.InternalServerErrorException(error);
+        // Sentry.captureException(error);
+        break;
+      // Log critically any other error, because those are not expected normally
+      default:
+        this.logger.error(error, error.stack, ExceptionContextEnum.DATABASE);
+        // Sentry.captureException(error);
+        break;
+    }
+    // transaction.finish();
+
+    return error;
+  }
+}

package/src/filters/http-exception.filter.d.ts

@@ -0,0 +1,16 @@
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import * as common from '@nestjs/common';
+import { DefaultErrorMixin, MissingArgumentsError } from '@nest-yalc-2/errors';
+import { FastifyReply as FResponse } from 'fastify';
+import { GqlError } from '@nest-yalc-2/graphql/plugins/gql.error.js';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { type ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+type HttpErrorType = common.HttpException | MissingArgumentsError | GqlError | DefaultErrorMixin;
+export declare class HttpExceptionFilter extends BaseExceptionFilter implements GqlExceptionFilter, common.ExceptionFilter {
+    protected logger: ImprovedLoggerService;
+    constructor(logger: ImprovedLoggerService, applicationRef?: common.HttpServer);
+    catch(error: Error | HttpErrorType, host: common.ArgumentsHost, { sendResponse }?: {
+        sendResponse: boolean;
+    }): Error | import("@nest-yalc-2/errors").IAbstractDefaultError | FResponse<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("node:http").IncomingMessage, import("node:http").ServerResponse<import("node:http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
+}
+export {};

package/src/filters/http-exception.filter.js

@@ -0,0 +1,145 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpExceptionFilter = void 0;
+const common = __importStar(require("@nestjs/common"));
+const errors_1 = require("@nest-yalc-2/errors");
+const entity_error_js_1 = require("@nest-yalc-2/crud-gen/entity.error.js");
+const gql_error_js_1 = require("@nest-yalc-2/graphql/plugins/gql.error.js");
+const core_1 = require("@nestjs/core");
+const event_helper_js_1 = require("../../../event-manager/src/event.helper.js");
+const logger_enum_js_1 = require("@nest-yalc-2/logger/logger.enum.js");
+let HttpExceptionFilter = class HttpExceptionFilter extends core_1.BaseExceptionFilter {
+    constructor(logger, applicationRef) {
+        super(applicationRef);
+        this.logger = logger;
+    }
+    catch(error, host, { sendResponse } = { sendResponse: true }) {
+        try {
+            const isHttpError = this.isHttpError(error) || error instanceof common.HttpException;
+            switch (true) {
+                case error instanceof errors_1.MissingArgumentsError:
+                    this.logger.log(error.message, {
+                        stack: error.stack,
+                    });
+                    break;
+                case (0, errors_1.isDefaultErrorMixin)(error):
+                    break;
+                case (0, entity_error_js_1.isEntityError)(error):
+                    {
+                        const entityError = error;
+                        this.logger.error(entityError.originalError?.message
+                            ? entityError.originalError.message
+                            : error, entityError.originalError?.stack, {
+                            stack: entityError.originalError?.stack,
+                            data: {
+                                response: entityError.getResponse(),
+                                name: entityError.name,
+                                cause: (0, errors_1.formatCause)(entityError.cause),
+                            },
+                        });
+                    }
+                    break;
+                case isHttpError:
+                    {
+                        const httpError = error;
+                        const logLevel = (0, event_helper_js_1.getLogLevelByStatus)(httpError.getStatus());
+                        if (logLevel === logger_enum_js_1.LogLevelEnum.ERROR) {
+                            this.logger[logLevel](error.message, error.stack, {
+                                stack: httpError.stack,
+                                data: {
+                                    response: httpError.getResponse(),
+                                    name: error.name,
+                                    cause: (0, errors_1.formatCause)(error.cause),
+                                },
+                            });
+                        }
+                        else {
+                            this.logger[logLevel](error.message, {
+                                stack: error.stack,
+                                data: {
+                                    response: httpError.getResponse(),
+                                    name: error.name,
+                                    cause: (0, errors_1.formatCause)(error.cause),
+                                },
+                            });
+                        }
+                    }
+                    break;
+                case error instanceof gql_error_js_1.GqlError:
+                    this.logger.error(error.systemMessage ?? error.message);
+                    break;
+                default:
+                    this.logger.error(error.message, error.stack, {
+                        stack: error.stack,
+                        data: {
+                            cause: (0, errors_1.formatCause)(error.cause),
+                            name: error.name,
+                        },
+                    });
+                    break;
+            }
+            if (host.getType() === 'http') {
+                if (sendResponse) {
+                    const ctx = host.switchToHttp();
+                    const response = ctx.getResponse();
+                    let status = common.HttpStatus.INTERNAL_SERVER_ERROR;
+                    if (isHttpError)
+                        status = error.getStatus();
+                    return response.status(status).send(error.message);
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return error;
+    }
+};
+exports.HttpExceptionFilter = HttpExceptionFilter;
+exports.HttpExceptionFilter = HttpExceptionFilter = __decorate([
+    common.Catch(common.HttpException, errors_1.MissingArgumentsError, gql_error_js_1.GqlError, errors_1.DefaultErrorMixin),
+    __metadata("design:paramtypes", [Object, Object])
+], HttpExceptionFilter);
+//# sourceMappingURL=http-exception.filter.js.map

package/src/filters/http-exception.filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-exception.filter.js","sourceRoot":"","sources":["http-exception.filter.ts"],"names":[],"mappings":"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"}

package/src/filters/http-exception.filter.ts

@@ -0,0 +1,143 @@
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import * as common from '@nestjs/common';
+import {
+  DefaultErrorMixin,
+  MissingArgumentsError,
+  isDefaultErrorMixin,
+  formatCause,
+} from '@nest-yalc-2/errors';
+import {
+  EntityError,
+  isEntityError,
+} from '@nest-yalc-2/crud-gen/entity.error.js';
+import { FastifyReply as FResponse } from 'fastify';
+import { GqlError } from '@nest-yalc-2/graphql/plugins/gql.error.js';
+import { BaseExceptionFilter } from '@nestjs/core';
+import { getLogLevelByStatus } from '../../../event-manager/src/event.helper.js';
+import { LogLevelEnum } from '@nest-yalc-2/logger/logger.enum.js';
+import { type ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+
+type HttpErrorType =
+  common.HttpException | MissingArgumentsError | GqlError | DefaultErrorMixin;
+@common.Catch(
+  common.HttpException,
+  MissingArgumentsError,
+  GqlError,
+  DefaultErrorMixin,
+)
+export class HttpExceptionFilter
+  extends BaseExceptionFilter
+  implements GqlExceptionFilter, common.ExceptionFilter
+{
+  constructor(
+    protected logger: ImprovedLoggerService,
+    applicationRef?: common.HttpServer,
+  ) {
+    super(applicationRef);
+  }
+
+  catch(
+    error: Error | HttpErrorType,
+    host: common.ArgumentsHost,
+    { sendResponse }: { sendResponse: boolean } = { sendResponse: true },
+  ) {
+    try {
+      const isHttpError =
+        this.isHttpError(error) || error instanceof common.HttpException;
+      // TODO: Validate when monitoring is in place if we need an eventEmitter here instead of log
+      switch (true) {
+        // Base logging for normal operation execution errors
+        case error instanceof MissingArgumentsError:
+          this.logger.log(error.message, {
+            stack: error.stack,
+          });
+          break;
+
+        case isDefaultErrorMixin(error):
+          // no need to log, DefaultErrorMixin already logs
+          break;
+
+        /**
+         * Log original error message (for now only if is an EntityError)
+         * @todo refactor with the default error mixin
+         */
+        case isEntityError(error):
+          {
+            const entityError = error as EntityError;
+            this.logger.error(
+              entityError.originalError?.message
+                ? entityError.originalError.message
+                : error,
+              entityError.originalError?.stack,
+              {
+                stack: entityError.originalError?.stack,
+                data: {
+                  response: entityError.getResponse(),
+                  name: entityError.name,
+                  cause: formatCause(entityError.cause),
+                },
+              },
+            );
+          }
+          break;
+
+        case isHttpError:
+          {
+            const httpError = error as common.HttpException;
+            const logLevel = getLogLevelByStatus(httpError.getStatus());
+
+            if (logLevel === LogLevelEnum.ERROR) {
+              this.logger[logLevel](error.message, error.stack, {
+                stack: httpError.stack,
+                data: {
+                  response: httpError.getResponse(),
+                  name: error.name,
+                  cause: formatCause(error.cause),
+                },
+              });
+            } else {
+              this.logger[logLevel](error.message, {
+                stack: error.stack,
+                data: {
+                  response: httpError.getResponse(),
+                  name: error.name,
+                  cause: formatCause(error.cause),
+                },
+              });
+            }
+          }
+          break;
+
+        case error instanceof GqlError:
+          this.logger.error((<GqlError>error).systemMessage ?? error.message);
+          break;
+
+        // Log critically any other error, as those are not expected
+        default:
+          this.logger.error(error.message, error.stack, {
+            stack: error.stack,
+            data: {
+              cause: formatCause(error.cause),
+              name: error.name,
+            },
+          });
+          break;
+      }
+
+      if (host.getType() === 'http') {
+        if (sendResponse) {
+          const ctx = host.switchToHttp();
+          const response = ctx.getResponse<FResponse>();
+          let status = common.HttpStatus.INTERNAL_SERVER_ERROR;
+          if (isHttpError) status = (error as common.HttpException).getStatus();
+          return response.status(status).send(error.message);
+        }
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e); // if there's an error with the logger itself
+    }
+
+    return error;
+  }
+}

package/src/filters/index.d.ts

@@ -0,0 +1 @@
+export { SystemExceptionFilter } from './system-exception.filter.js';

package/src/filters/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemExceptionFilter = void 0;
+var system_exception_filter_js_1 = require("./system-exception.filter.js");
+Object.defineProperty(exports, "SystemExceptionFilter", { enumerable: true, get: function () { return system_exception_filter_js_1.SystemExceptionFilter; } });
+//# sourceMappingURL=index.js.map

package/src/filters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAKA,2EAAqE;AAA5D,mIAAA,qBAAqB,OAAA"}

package/src/filters/index.ts

@@ -0,0 +1,6 @@
+/* istanbul ignore file */
+
+// export { HttpExceptionFilter } from './http-exception.filter.js';
+// export { DatabaseExceptionFilter } from './database-exception.filter.js';
+// export { ValidationExceptionFilter } from './validation-exception.filter.js';
+export { SystemExceptionFilter } from './system-exception.filter.js';

package/src/filters/system-exception.filter.d.ts

@@ -0,0 +1,7 @@
+import { ExceptionFilter } from '@nestjs/common';
+import type { LoggerService } from '@nestjs/common';
+export declare class SystemExceptionFilter implements ExceptionFilter {
+    private logger;
+    constructor(logger: LoggerService);
+    catch(error: Error): Error;
+}

package/src/filters/system-exception.filter.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const error_enum_js_1 = require("../error.enum.js");
+let SystemExceptionFilter = class SystemExceptionFilter {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    catch(error) {
+        this.logger.error(error, error.stack, error_enum_js_1.ExceptionContextEnum.SYSTEM);
+        return error;
+    }
+};
+exports.SystemExceptionFilter = SystemExceptionFilter;
+exports.SystemExceptionFilter = SystemExceptionFilter = __decorate([
+    (0, common_1.Catch)(TypeError, SyntaxError, RangeError, EvalError, ReferenceError),
+    __metadata("design:paramtypes", [Object])
+], SystemExceptionFilter);
+//# sourceMappingURL=system-exception.filter.js.map

package/src/filters/system-exception.filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-exception.filter.js","sourceRoot":"","sources":["system-exception.filter.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAAwD;AAExD,oDAAwD;AAGjD,IAAM,qBAAqB,GAA3B,MAAM,qBAAqB;IAChC,YAAoB,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAE7C,KAAK,CAAC,KAAY;QAChB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,oCAAoB,CAAC,MAAM,CAAC,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;CACF,CAAA;AAPY,sDAAqB;gCAArB,qBAAqB;IADjC,IAAA,cAAK,EAAC,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,CAAC;;GACxD,qBAAqB,CAOjC"}

package/src/filters/system-exception.filter.ts

@@ -0,0 +1,13 @@
+import { Catch, ExceptionFilter } from '@nestjs/common';
+import type { LoggerService } from '@nestjs/common';
+import { ExceptionContextEnum } from '../error.enum.js';
+
+@Catch(TypeError, SyntaxError, RangeError, EvalError, ReferenceError)
+export class SystemExceptionFilter implements ExceptionFilter {
+  constructor(private logger: LoggerService) {}
+
+  catch(error: Error) {
+    this.logger.error(error, error.stack, ExceptionContextEnum.SYSTEM);
+    return error;
+  }
+}

package/src/filters/validation-exception.filter.d.ts

@@ -0,0 +1,8 @@
+import * as common from '@nestjs/common';
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import { InputValidationError } from '../index.js';
+export declare class ValidationExceptionFilter implements GqlExceptionFilter {
+    private logger;
+    constructor(logger: common.LoggerService);
+    catch(error: Error): InputValidationError;
+}