@nest-yalc-2/errors 2.2.2 → 2.2.4

package/src/__tests__/validation-exception.filter.spec.ts

@@ -1,31 +1,31 @@
-import {
-  expect,
-  jest,
-  describe,
-  it,
-  beforeEach,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from '@jest/globals';
-import { createMock } from '@golevelup/ts-jest';
-import { LoggerService } from '@nestjs/common';
-import { ValidationExceptionFilter } from '../filters/validation-exception.filter.js';
-import { InputValidationError } from '../index.js';
-import { CrudGenError } from '@nest-yalc-2/crud-gen/crud-gen.error.js';
-
-describe('ValidationExceptionFilter', () => {
-  const logger = createMock<LoggerService>();
-  it('should received error to InputValidationError', () => {
-    const filter = new ValidationExceptionFilter(logger);
-    const result = filter.catch(new Error());
-    expect(result).toBeInstanceOf(InputValidationError);
-  });
-
-  it('should received error to CrudGenError', () => {
-    const error: CrudGenError = new CrudGenError('message', 'systemMessage');
-    const filter = new ValidationExceptionFilter(logger);
-    filter.catch(error);
-    expect(logger.error).toHaveBeenCalledWith(error.systemMessage, error.stack);
-  });
-});
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock } from '@golevelup/ts-jest';
+import { LoggerService } from '@nestjs/common';
+import { ValidationExceptionFilter } from '../filters/validation-exception.filter.js';
+import { InputValidationError } from '../index.js';
+import { CrudGenError } from '@nest-yalc-2/crud-gen/crud-gen.error.js';
+
+describe('ValidationExceptionFilter', () => {
+  const logger = createMock<LoggerService>();
+  it('should received error to InputValidationError', () => {
+    const filter = new ValidationExceptionFilter(logger);
+    const result = filter.catch(new Error());
+    expect(result).toBeInstanceOf(InputValidationError);
+  });
+
+  it('should received error to CrudGenError', () => {
+    const error: CrudGenError = new CrudGenError('message', 'systemMessage');
+    const filter = new ValidationExceptionFilter(logger);
+    filter.catch(error);
+    expect(logger.error).toHaveBeenCalledWith(error.systemMessage, error.stack);
+  });
+});

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

@@ -1,45 +1,45 @@
-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 '@node-yalc/errors/error.enum.js';
-
-import type { LoggerService } from '@nestjs/common';
-
-@common.Catch(EntityNotFoundError, ConnectionNotFoundError)
-export class DatabaseExceptionFilter implements GqlExceptionFilter {
-  constructor(private logger: 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;
-  }
-}
+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 '@node-yalc/errors/error.enum.js';
+
+import type { LoggerService } from '@nestjs/common';
+
+@common.Catch(EntityNotFoundError, ConnectionNotFoundError)
+export class DatabaseExceptionFilter implements GqlExceptionFilter {
+  constructor(private logger: 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.ts

@@ -1,144 +1,144 @@
-import { GqlExceptionFilter } from '@nestjs/graphql';
-import * as common from '@nestjs/common';
-import type { HttpServer } 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 '@node-yalc/logger/logger.enum.js';
-import { type ImprovedLoggerService } from '@node-yalc/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?: 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;
-  }
-}
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import * as common from '@nestjs/common';
+import type { HttpServer } 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 '@node-yalc/logger/logger.enum.js';
+import { type ImprovedLoggerService } from '@node-yalc/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?: 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.ts

@@ -1,6 +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';
+/* 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.ts

@@ -1,13 +1,13 @@
-import { Catch, ExceptionFilter } from '@nestjs/common';
-import type { LoggerService } from '@nestjs/common';
-import { ExceptionContextEnum } from '@node-yalc/errors/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;
-  }
-}
+import { Catch, ExceptionFilter } from '@nestjs/common';
+import type { LoggerService } from '@nestjs/common';
+import { ExceptionContextEnum } from '@node-yalc/errors/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.ts

@@ -1,26 +1,26 @@
-import { CrudGenError } from '@nest-yalc-2/crud-gen/crud-gen.error.js';
-import { UUIDValidationError } from '@nest-yalc-2/graphql/scalars/uuid-validation.error.js';
-import * as common from '@nestjs/common';
-import { GqlExceptionFilter } from '@nestjs/graphql';
-import { InputValidationError } from '../index.js';
-
-import type { LoggerService } from '@nestjs/common';
-
-@common.Catch(UUIDValidationError, CrudGenError)
-export class ValidationExceptionFilter implements GqlExceptionFilter {
-  constructor(private logger: LoggerService) {}
-
-  catch(error: Error) {
-    const newError = new InputValidationError(
-      (<CrudGenError>error).systemMessage,
-      { response: { message: error.message } },
-    );
-    newError.stack = error.stack; // we need the stack trace for dev
-    this.logger.error(
-      (<CrudGenError>error).systemMessage ?? newError.message,
-      newError.stack,
-    );
-
-    return newError;
-  }
-}
+import { CrudGenError } from '@nest-yalc-2/crud-gen/crud-gen.error.js';
+import { UUIDValidationError } from '@nest-yalc-2/graphql/scalars/uuid-validation.error.js';
+import * as common from '@nestjs/common';
+import { GqlExceptionFilter } from '@nestjs/graphql';
+import { InputValidationError } from '../index.js';
+
+import type { LoggerService } from '@nestjs/common';
+
+@common.Catch(UUIDValidationError, CrudGenError)
+export class ValidationExceptionFilter implements GqlExceptionFilter {
+  constructor(private logger: LoggerService) {}
+
+  catch(error: Error) {
+    const newError = new InputValidationError(
+      (<CrudGenError>error).systemMessage,
+      { response: { message: error.message } },
+    );
+    newError.stack = error.stack; // we need the stack trace for dev
+    this.logger.error(
+      (<CrudGenError>error).systemMessage ?? newError.message,
+      newError.stack,
+    );
+
+    return newError;
+  }
+}

package/src/index.ts

@@ -1,8 +1,8 @@
-/* istanbul ignore file */
-
-export { MissingArgumentsError } from '@nest-yalc-2/crud-gen';
-export * from '@node-yalc/errors/error.enum.js';
-export * from '@node-yalc/errors/error.class.js';
-export * from '@node-yalc/errors/default.error.js';
-export * from '@node-yalc/errors/result.error.js';
-export * from './filters/index.js';
+/* istanbul ignore file */
+
+export { MissingArgumentsError } from '@nest-yalc-2/crud-gen';
+export * from '@node-yalc/errors/error.enum.js';
+export * from '@node-yalc/errors/error.class.js';
+export * from '@node-yalc/errors/default.error.js';
+export * from '@node-yalc/errors/result.error.js';
+export * from './filters/index.js';