@nest-yalc-2/errors 2.2.1 → 2.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-yalc-2/errors",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "type": "module",
   "description": "",
   "main": "./src/index.js",
@@ -16,17 +16,25 @@
     "src"
   ],
   "dependencies": {
-    "@nest-yalc-2/crud-gen": "^2.2.1",
-    "@nest-yalc-2/event-manager": "^2.2.1",
-    "@nest-yalc-2/logger": "^2.2.1",
-    "@nest-yalc-2/utils": "^2.2.1",
-    "axios": "^1.15.0",
+    "@nest-yalc-2/crud-gen": "^2.2.3",
+    "@nest-yalc-2/event-manager": "^2.2.3",
+    "@nest-yalc-2/logger": "^2.2.3",
+    "@nest-yalc-2/utils": "^2.2.3",
+    "axios": "^1.20.0",
     "neverthrow": "^8.2.0",
-    "tslib": "^2.6.3"
+    "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@nestjs/common": "^11.1.19"
+    "@nestjs/common": "^12.0.0"
   },
+  "keywords": [
+    "nestjs",
+    "nestjs-yalc",
+    "yalc",
+    "errors",
+    "framework",
+    "utility"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Nek97/nestjs-yalc.git"

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

@@ -1,71 +1,71 @@
-import {
-  expect,
-  jest,
-  describe,
-  it,
-  beforeEach,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from '@jest/globals';
-import { createMock } from '@golevelup/ts-jest';
-import {
-  ArgumentsHost,
-  InternalServerErrorException,
-  LoggerService,
-} from '@nestjs/common';
-import { EntityTarget } from 'typeorm';
-import { ConnectionNotFoundError, EntityNotFoundError } from 'typeorm';
-import { ExceptionContextEnum } from '@node-yalc/errors/error.enum.js';
-import { DatabaseExceptionFilter } from '../filters/database-exception.filter.js';
-
-import { GqlArgumentsHost } from '@nestjs/graphql';
-
-jest.mock('@nestjs/graphql');
-
-describe('Database exceptions filter', () => {
-  let filter: DatabaseExceptionFilter;
-  const loggerServiceMock = createMock<LoggerService>();
-
-  beforeEach(() => {
-    filter = new DatabaseExceptionFilter(loggerServiceMock);
-    GqlArgumentsHost.create = jest.fn().mockReturnValue({
-      getType: jest.fn(),
-    } as any) as any;
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('should be defined', () => {
-    expect(filter).toBeDefined();
-  });
-
-  it('should catch and log EntityNotFound errors', () => {
-    const mockArgumentsHost = createMock<ArgumentsHost>();
-
-    const mockedEntityTarget: EntityTarget<null> = 'emptyString';
-    const error = new EntityNotFoundError(mockedEntityTarget, []);
-
-    const returnedError = filter.catch(error, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      error,
-      ExceptionContextEnum.DATABASE,
-    );
-    expect(returnedError).toBeInstanceOf(InternalServerErrorException);
-  });
-
-  it('should catch and log ConnectionNotFoundError errors', () => {
-    const mockArgumentsHost = createMock<ArgumentsHost>();
-
-    const error = new ConnectionNotFoundError('test connection');
-
-    filter.catch(error, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      error,
-      error.stack,
-      ExceptionContextEnum.DATABASE,
-    );
-  });
-});
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock } from '@golevelup/ts-jest';
+import {
+  ArgumentsHost,
+  InternalServerErrorException,
+  LoggerService,
+} from '@nestjs/common';
+import { EntityTarget } from 'typeorm';
+import { ConnectionNotFoundError, EntityNotFoundError } from 'typeorm';
+import { ExceptionContextEnum } from '@node-yalc/errors/error.enum.js';
+import { DatabaseExceptionFilter } from '../filters/database-exception.filter.js';
+
+import { GqlArgumentsHost } from '@nestjs/graphql';
+
+jest.mock('@nestjs/graphql');
+
+describe('Database exceptions filter', () => {
+  let filter: DatabaseExceptionFilter;
+  const loggerServiceMock = createMock<LoggerService>();
+
+  beforeEach(() => {
+    filter = new DatabaseExceptionFilter(loggerServiceMock);
+    GqlArgumentsHost.create = jest.fn().mockReturnValue({
+      getType: jest.fn(),
+    } as any) as any;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(filter).toBeDefined();
+  });
+
+  it('should catch and log EntityNotFound errors', () => {
+    const mockArgumentsHost = createMock<ArgumentsHost>();
+
+    const mockedEntityTarget: EntityTarget<null> = 'emptyString';
+    const error = new EntityNotFoundError(mockedEntityTarget, []);
+
+    const returnedError = filter.catch(error, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      error,
+      ExceptionContextEnum.DATABASE,
+    );
+    expect(returnedError).toBeInstanceOf(InternalServerErrorException);
+  });
+
+  it('should catch and log ConnectionNotFoundError errors', () => {
+    const mockArgumentsHost = createMock<ArgumentsHost>();
+
+    const error = new ConnectionNotFoundError('test connection');
+
+    filter.catch(error, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      error,
+      error.stack,
+      ExceptionContextEnum.DATABASE,
+    );
+  });
+});

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

@@ -1,182 +1,182 @@
-import { expect, jest, describe, it, beforeEach } from '@jest/globals';
-
-import { DeepMocked, createMock } from '@golevelup/ts-jest';
-import { CreateEntityError } from '@nest-yalc-2/crud-gen/entity.error.js';
-import { MissingArgumentsError } from '@nest-yalc-2/crud-gen/missing-arguments.error.js';
-import {
-  ArgumentsHost,
-  BadRequestException,
-  InternalServerErrorException,
-  LoggerService,
-} from '@nestjs/common';
-import { HttpExceptionFilter } from '../filters/http-exception.filter.js';
-import { GqlError } from '@nest-yalc-2/graphql/plugins/gql.error.js';
-import { DefaultError } from '../index.js';
-import { GqlArgumentsHost } from '@nestjs/graphql';
-describe('Http exceptions filter', () => {
-  let filter: HttpExceptionFilter;
-  let loggerServiceMock: DeepMocked<LoggerService>;
-  let mockArgumentsHost: DeepMocked<ArgumentsHost>;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    loggerServiceMock = createMock<LoggerService>();
-    mockArgumentsHost = createMock<ArgumentsHost>();
-    filter = new HttpExceptionFilter(loggerServiceMock);
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  it('should be defined', () => {
-    expect(filter).toBeDefined();
-  });
-
-  it('should catch and log Application errors', () => {
-    const error = new MissingArgumentsError();
-
-    filter.catch(error, mockArgumentsHost);
-    expect(loggerServiceMock.log).toHaveBeenCalledWith(
-      error.message,
-      expect.anything(),
-    );
-  });
-
-  it('should catch Default error', () => {
-    const exception = new DefaultError('test');
-
-    filter.catch(exception, mockArgumentsHost);
-  });
-
-  it('should catch and log System Error error', () => {
-    const exception = new Error('test');
-
-    filter.catch(exception, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      exception.message,
-      exception.stack,
-      expect.anything(),
-    );
-  });
-
-  it('should catch and log Entity error', () => {
-    const exception = new CreateEntityError();
-
-    filter.catch(exception, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      exception,
-      undefined,
-      expect.anything(),
-    );
-  });
-
-  it('should catch EntityError and log the original message', () => {
-    const fixedError = new Error('message');
-    const exception = new CreateEntityError(fixedError);
-
-    filter.catch(exception, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      fixedError.message,
-      expect.anything(),
-      expect.objectContaining({
-        data: expect.objectContaining({
-          name: 'CreateEntityError',
-        }),
-      }),
-    );
-  });
-
-  it('should catch and log GqlError error', () => {
-    const exception: GqlError = new GqlError('message', 'systemMessage');
-    filter.catch(exception, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(exception.systemMessage);
-
-    exception.systemMessage = undefined;
-    filter.catch(exception, mockArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(exception.message);
-  });
-
-  it('should catch and log Http error with host type http and send response', () => {
-    const exception = new InternalServerErrorException();
-    mockArgumentsHost.getType.mockReturnValue('http');
-    const mockResponse = {
-      status: jest.fn().mockReturnThis(),
-      send: jest.fn(),
-    };
-    mockArgumentsHost.switchToHttp.mockReturnValue({
-      getResponse: () => mockResponse,
-      getRequest: jest.fn(),
-      getNext: jest.fn(),
-    } as any);
-    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      exception.message,
-      exception.stack,
-      expect.anything(),
-    );
-    expect(mockResponse.status).toHaveBeenCalledWith(500);
-    expect(mockResponse.send).toHaveBeenCalledWith(exception.message);
-  });
-
-  it('should catch and log Non-Http error with host type http and send response', () => {
-    const exception = new Error('test');
-    mockArgumentsHost.getType.mockReturnValue('http');
-    const mockResponse = {
-      status: jest.fn().mockReturnThis(),
-      send: jest.fn(),
-    };
-    mockArgumentsHost.switchToHttp.mockReturnValue({
-      getResponse: () => mockResponse,
-      getRequest: jest.fn(),
-      getNext: jest.fn(),
-    } as any);
-    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
-    expect(mockResponse.status).toHaveBeenCalledWith(500);
-  });
-
-  it('should not send response if sendResponse is false', () => {
-    const exception = new InternalServerErrorException();
-    mockArgumentsHost.getType.mockReturnValue('http');
-    const mockResponse = {
-      status: jest.fn().mockReturnThis(),
-      send: jest.fn(),
-    };
-    mockArgumentsHost.switchToHttp.mockReturnValue({
-      getResponse: () => mockResponse,
-      getRequest: jest.fn(),
-      getNext: jest.fn(),
-    } as any);
-    filter.catch(exception, mockArgumentsHost as ArgumentsHost, { sendResponse: false });
-    expect(mockResponse.status).not.toHaveBeenCalled();
-  });
-
-  it('should catch and log Http log with host type http', () => {
-    const exception = new BadRequestException();
-    mockArgumentsHost.getType.mockReturnValue('http');
-    const mockResponse = {
-      status: jest.fn().mockReturnThis(),
-      send: jest.fn(),
-    };
-    mockArgumentsHost.switchToHttp.mockReturnValue({
-      getResponse: () => mockResponse,
-      getRequest: jest.fn(),
-      getNext: jest.fn(),
-    } as any);
-    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
-    expect(loggerServiceMock.log).toHaveBeenCalledWith(
-      exception.message,
-      expect.anything(),
-    );
-    expect(mockResponse.status).toHaveBeenCalledWith(400);
-  });
-
-  it('should catch an error with the logger itself', () => {
-    const exception = new InternalServerErrorException();
-    loggerServiceMock.error = null;
-    mockArgumentsHost.getType.mockReturnValue('http');
-    console.error = jest.fn();
-    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
-    expect(console.error).toHaveBeenCalled();
-  });
-});
+import { expect, jest, describe, it, beforeEach } from '@jest/globals';
+
+import { DeepMocked, createMock } from '@golevelup/ts-jest';
+import { CreateEntityError } from '@nest-yalc-2/crud-gen/entity.error.js';
+import { MissingArgumentsError } from '@nest-yalc-2/crud-gen/missing-arguments.error.js';
+import {
+  ArgumentsHost,
+  BadRequestException,
+  InternalServerErrorException,
+  LoggerService,
+} from '@nestjs/common';
+import { HttpExceptionFilter } from '../filters/http-exception.filter.js';
+import { GqlError } from '@nest-yalc-2/graphql/plugins/gql.error.js';
+import { DefaultError } from '../index.js';
+import { GqlArgumentsHost } from '@nestjs/graphql';
+describe('Http exceptions filter', () => {
+  let filter: HttpExceptionFilter;
+  let loggerServiceMock: DeepMocked<LoggerService>;
+  let mockArgumentsHost: DeepMocked<ArgumentsHost>;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    loggerServiceMock = createMock<LoggerService>();
+    mockArgumentsHost = createMock<ArgumentsHost>();
+    filter = new HttpExceptionFilter(loggerServiceMock);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(filter).toBeDefined();
+  });
+
+  it('should catch and log Application errors', () => {
+    const error = new MissingArgumentsError();
+
+    filter.catch(error, mockArgumentsHost);
+    expect(loggerServiceMock.log).toHaveBeenCalledWith(
+      error.message,
+      expect.anything(),
+    );
+  });
+
+  it('should catch Default error', () => {
+    const exception = new DefaultError('test');
+
+    filter.catch(exception, mockArgumentsHost);
+  });
+
+  it('should catch and log System Error error', () => {
+    const exception = new Error('test');
+
+    filter.catch(exception, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      exception.message,
+      exception.stack,
+      expect.anything(),
+    );
+  });
+
+  it('should catch and log Entity error', () => {
+    const exception = new CreateEntityError();
+
+    filter.catch(exception, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      exception,
+      undefined,
+      expect.anything(),
+    );
+  });
+
+  it('should catch EntityError and log the original message', () => {
+    const fixedError = new Error('message');
+    const exception = new CreateEntityError(fixedError);
+
+    filter.catch(exception, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      fixedError.message,
+      expect.anything(),
+      expect.objectContaining({
+        data: expect.objectContaining({
+          name: 'CreateEntityError',
+        }),
+      }),
+    );
+  });
+
+  it('should catch and log GqlError error', () => {
+    const exception: GqlError = new GqlError('message', 'systemMessage');
+    filter.catch(exception, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(exception.systemMessage);
+
+    exception.systemMessage = undefined;
+    filter.catch(exception, mockArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(exception.message);
+  });
+
+  it('should catch and log Http error with host type http and send response', () => {
+    const exception = new InternalServerErrorException();
+    mockArgumentsHost.getType.mockReturnValue('http');
+    const mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    mockArgumentsHost.switchToHttp.mockReturnValue({
+      getResponse: () => mockResponse,
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    } as any);
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      exception.message,
+      exception.stack,
+      expect.anything(),
+    );
+    expect(mockResponse.status).toHaveBeenCalledWith(500);
+    expect(mockResponse.send).toHaveBeenCalledWith(exception.message);
+  });
+
+  it('should catch and log Non-Http error with host type http and send response', () => {
+    const exception = new Error('test');
+    mockArgumentsHost.getType.mockReturnValue('http');
+    const mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    mockArgumentsHost.switchToHttp.mockReturnValue({
+      getResponse: () => mockResponse,
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    } as any);
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(mockResponse.status).toHaveBeenCalledWith(500);
+  });
+
+  it('should not send response if sendResponse is false', () => {
+    const exception = new InternalServerErrorException();
+    mockArgumentsHost.getType.mockReturnValue('http');
+    const mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    mockArgumentsHost.switchToHttp.mockReturnValue({
+      getResponse: () => mockResponse,
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    } as any);
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost, { sendResponse: false });
+    expect(mockResponse.status).not.toHaveBeenCalled();
+  });
+
+  it('should catch and log Http log with host type http', () => {
+    const exception = new BadRequestException();
+    mockArgumentsHost.getType.mockReturnValue('http');
+    const mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      send: jest.fn(),
+    };
+    mockArgumentsHost.switchToHttp.mockReturnValue({
+      getResponse: () => mockResponse,
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    } as any);
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(loggerServiceMock.log).toHaveBeenCalledWith(
+      exception.message,
+      expect.anything(),
+    );
+    expect(mockResponse.status).toHaveBeenCalledWith(400);
+  });
+
+  it('should catch an error with the logger itself', () => {
+    const exception = new InternalServerErrorException();
+    loggerServiceMock.error = null;
+    mockArgumentsHost.getType.mockReturnValue('http');
+    console.error = jest.fn();
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(console.error).toHaveBeenCalled();
+  });
+});

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

@@ -1,39 +1,39 @@
-import {
-  expect,
-  jest,
-  describe,
-  it,
-  beforeEach,
-  beforeAll,
-  afterAll,
-  afterEach,
-} from '@jest/globals';
-import { createMock } from '@golevelup/ts-jest';
-import { LoggerService, UnprocessableEntityException } from '@nestjs/common';
-
-import { ExceptionContextEnum } from '@node-yalc/errors/error.enum.js';
-import { SystemExceptionFilter } from '../filters/system-exception.filter.js';
-
-describe('System exceptions filter', () => {
-  let filter: SystemExceptionFilter;
-  const loggerServiceMock = createMock<LoggerService>();
-
-  beforeAll(() => {
-    filter = new SystemExceptionFilter(loggerServiceMock);
-  });
-
-  it('should be defined', () => {
-    expect(filter).toBeDefined();
-  });
-
-  it('should catch and log UnprocessableEntity error', () => {
-    const exception = new UnprocessableEntityException();
-
-    filter.catch(exception);
-    expect(loggerServiceMock.error).toHaveBeenCalledWith(
-      exception,
-      exception.stack,
-      ExceptionContextEnum.SYSTEM,
-    );
-  });
-});
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock } from '@golevelup/ts-jest';
+import { LoggerService, UnprocessableEntityException } from '@nestjs/common';
+
+import { ExceptionContextEnum } from '@node-yalc/errors/error.enum.js';
+import { SystemExceptionFilter } from '../filters/system-exception.filter.js';
+
+describe('System exceptions filter', () => {
+  let filter: SystemExceptionFilter;
+  const loggerServiceMock = createMock<LoggerService>();
+
+  beforeAll(() => {
+    filter = new SystemExceptionFilter(loggerServiceMock);
+  });
+
+  it('should be defined', () => {
+    expect(filter).toBeDefined();
+  });
+
+  it('should catch and log UnprocessableEntity error', () => {
+    const exception = new UnprocessableEntityException();
+
+    filter.catch(exception);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      exception,
+      exception.stack,
+      ExceptionContextEnum.SYSTEM,
+    );
+  });
+});