@nest-yalc-2/errors 1.3.4

package/src/__tests__/errors.enum.spec.ts

@@ -0,0 +1,32 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { ErrorsEnum, ExceptionContextEnum } from '../error.enum.js';
+
+describe('errors enum test', () => {
+  it('ErrorsEnum should have all the values', () => {
+    expect(Object.keys(ErrorsEnum)).toEqual(
+      expect.arrayContaining([
+        'BAD_LOGIN',
+        'UNAUTHORIZED',
+        'FORBIDDEN_RESOURCE',
+        'INVALID_VALUE',
+      ]),
+    );
+  });
+
+  it('ExceptionContextEnum have all the values', () => {
+    expect(Object.keys(ExceptionContextEnum)).toEqual([
+      'DATABASE',
+      'HTTP',
+      'SYSTEM',
+    ]);
+  });
+});

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

@@ -0,0 +1,129 @@
+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', () => {
+    const exception = new InternalServerErrorException();
+    mockArgumentsHost.getType.mockReturnValue('http');
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(loggerServiceMock.error).toHaveBeenCalledWith(
+      exception.message,
+      exception.stack,
+      expect.anything(),
+    );
+  });
+
+  it('should catch and log Http log with host type http', () => {
+    const exception = new BadRequestException();
+    mockArgumentsHost.getType.mockReturnValue('http');
+    filter.catch(exception, mockArgumentsHost as ArgumentsHost);
+    expect(loggerServiceMock.log).toHaveBeenCalledWith(
+      exception.message,
+      expect.anything(),
+    );
+  });
+
+  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__/http-status-code-to-errors.spec.ts

@@ -0,0 +1,26 @@
+import { HttpStatusCodes } from '@nest-yalc-2/utils/http.helper.js';
+import { httpStatusCodeToErrors } from '../http-status-code-to-errors.js';
+import {
+  BadRequestError,
+  GatewayTimeoutError,
+  NotFoundError,
+} from '../error.class.js';
+import { describe, expect, it } from '@jest/globals';
+
+describe('should test ', () => {
+  it('should return not found error when given code 404', () => {
+    const httpCode: HttpStatusCodes = 404;
+    const result = httpStatusCodeToErrors[httpCode];
+    expect(result).toBe(NotFoundError);
+  });
+  it('should return bad request error when given code 400', () => {
+    const httpCode: HttpStatusCodes = 400;
+    const result = httpStatusCodeToErrors[httpCode];
+    expect(result).toBe(BadRequestError);
+  });
+  it('should return gateway timeout error when given code 504', () => {
+    const httpCode: HttpStatusCodes = 504;
+    const result = httpStatusCodeToErrors[httpCode];
+    expect(result).toBe(GatewayTimeoutError);
+  });
+});

package/src/__tests__/input-validation.error.spec.ts

@@ -0,0 +1,27 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { BadRequestError, InputValidationError } from '../error.class.js';
+import { ErrorsEnum } from '../error.enum.js';
+
+describe('InputValidationError', () => {
+  it('should have internal message without the custom message', () => {
+    const customError = new InputValidationError();
+    expect(customError.internalMessage).toEqual('Invalid value');
+  });
+
+  it('should set the custom message', () => {
+    const customMessage = 'INVALID_INPUT_MESSAGE';
+    const customError = new BadRequestError(customMessage);
+    expect(customError.internalMessage).toEqual(
+      `${ErrorsEnum.BAD_REQUEST}: ${customMessage}`,
+    );
+  });
+});

package/src/__tests__/login.error.spec.ts

@@ -0,0 +1,23 @@
+import { expect, describe, it } from '@jest/globals';
+import { ErrorsEnum } from '../error.enum.js';
+import { LoginError } from '../index.js';
+
+describe('Login error', () => {
+  const error = new LoginError();
+
+  it('should be defined', () => {
+    expect(error).toBeDefined();
+  });
+
+  it('should have the correct message', () => {
+    expect(error.getInternalMessage()).toEqual(ErrorsEnum.BAD_LOGIN);
+  });
+
+  it('should set the custom message', () => {
+    const customMessage = 'Something catastrophic happened!';
+    const customError = new LoginError(customMessage);
+    expect(customError.getInternalMessage()).toEqual(
+      `${ErrorsEnum.BAD_LOGIN}: ${customMessage}`,
+    );
+  });
+});

package/src/__tests__/result.error.spec.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from '@jest/globals';
+import { tryCatch, tryCatchAsync } from '../result.error.js';
+import { DefaultError } from '../default.error.js';
+
+describe('ResultError', () => {
+  it('should handle sync success', () => {
+    const result = tryCatch(() => 'success');
+    if (result.isErr()) {
+      expect(true).toBe(false);
+      return;
+    }
+    expect(result.isOk()).toBe(true);
+    expect(result.value).toBe('success');
+  });
+
+  it('should handle sync error', () => {
+    const result = tryCatch(() => {
+      throw new Error('error');
+    });
+    if (result.isOk()) {
+      expect(true).toBe(false);
+      return;
+    }
+    expect(result.error).toBeInstanceOf(DefaultError);
+  });
+
+  it('should handle async success', async () => {
+    const result = await tryCatchAsync(async () => 'success');
+    if (result.isErr()) {
+      expect(true).toBe(false);
+      return;
+    }
+    expect(result.isOk()).toBe(true);
+    expect(result.value).toBe('success');
+  });
+
+  it('should handle async error', async () => {
+    const result = await tryCatchAsync(async () => {
+      throw new Error('error');
+    });
+    if (result.isOk()) {
+      expect(true).toBe(false);
+      return;
+    }
+    expect(result.error).toBeInstanceOf(DefaultError);
+  });
+});

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

@@ -0,0 +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 '../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,
+    );
+  });
+});

package/src/__tests__/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../tsconfig.test.json"
+}

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

@@ -0,0 +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);
+  });
+});

package/src/__tests__/verification.error.spec.ts

@@ -0,0 +1,28 @@
+import { expect, describe, it } from '@jest/globals';
+import {
+  getHttpStatusDescription,
+  HttpStatusCodes,
+} from '@nest-yalc-2/utils/http.helper.js';
+import { HttpException } from '@nestjs/common';
+import { AdditionalVerificationNeededError } from '../index.js';
+
+describe('Verification error', () => {
+  const error = new AdditionalVerificationNeededError();
+
+  it('should be defined', () => {
+    expect(error).toBeDefined();
+  });
+
+  it('should have the correct message and code', () => {
+    expect(error.description).toEqual(
+      getHttpStatusDescription(HttpStatusCodes.UnavailableForLegalReasons),
+    );
+    expect(error.getStatus()).toEqual(
+      HttpStatusCodes.UnavailableForLegalReasons,
+    );
+  });
+
+  it('should be an instance of HttpException', () => {
+    expect(error).toBeInstanceOf(HttpException);
+  });
+});

package/src/default.error.d.ts

@@ -0,0 +1,93 @@
+import type { ImprovedLoggerService } from '@nest-yalc-2/logger/logger-abstract.service.js';
+import { ClassType, Mixin } from '@nest-yalc-2/types/globals.d.js';
+import { HttpException, HttpExceptionOptions, HttpStatus, LogLevel } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+export declare const ON_DEFAULT_ERROR_EVENT = "onDefaultError";
+export interface ISharedErrorProperties {
+    data?: any;
+    config?: any;
+    internalMessage?: string;
+    description?: string;
+    eventName?: string;
+}
+export interface IHttpExceptionArguments {
+    response?: Partial<IBetterResponseInterface>;
+    errorCode?: HttpStatus | number;
+}
+export interface IHttpExceptionParentArguments extends Omit<IHttpExceptionArguments, 'errorCode'> {
+}
+export interface IErrorPayload extends ISharedErrorProperties {
+    response?: Partial<IBetterResponseInterface>;
+    cause?: IFormattedCause;
+    errorName?: string;
+}
+export interface IErrorEventPayload extends IErrorPayload {
+    message?: string;
+    stack?: string;
+}
+export interface ILogErrorPayload extends Omit<IErrorEventPayload, keyof IHttpExceptionArguments> {
+    [key: string]: any;
+}
+type loggerOptionType = {
+    instance?: ImprovedLoggerService;
+    level?: LogLevel;
+} | false;
+export interface IAbstractDefaultError extends Omit<HttpException, 'cause' | 'message'>, Omit<IErrorEventPayload, 'response'> {
+    logger?: loggerOptionType;
+    eventEmitter?: EventEmitter2;
+    getResponse(): IBetterResponseInterface;
+    getInternalMessage(): string | undefined;
+    getDescription(): string | undefined;
+    getEventPayload(): IErrorEventPayload;
+    setErrorInfo(options: IAbstractDefaultErrorOptions & {
+        response?: Partial<IBetterResponseInterface>;
+    }): void;
+    mergeErrorInfo(info: IAbstractDefaultErrorOptions & {
+        response?: Partial<IBetterResponseInterface>;
+        cause?: Error;
+    }): void;
+}
+export interface IAbstractDefaultErrorConstructor<TErrorClass extends ClassType<HttpException> = ClassType<HttpException>> {
+    new (options: IAbstractDefaultErrorOptions, ...args: ConstructorParameters<TErrorClass>): IAbstractDefaultError;
+}
+export interface IAbstractDefaultErrorOptions extends ISharedErrorProperties {
+    masks?: string[];
+    logger?: loggerOptionType | boolean;
+    eventEmitter?: EventEmitter2 | boolean;
+    eventName?: string;
+    stack?: string;
+}
+export interface IDefaultErrorBaseOptions extends Omit<IAbstractDefaultErrorOptions, 'internalMessage'>, HttpExceptionOptions, IHttpExceptionParentArguments {
+}
+export interface IDefaultErrorOptions extends Omit<IAbstractDefaultErrorOptions, 'internalMessage'>, HttpExceptionOptions, IHttpExceptionArguments {
+}
+export interface IBetterResponseInterface {
+    error?: string;
+    statusCode: number;
+    statusCodeDescription: string;
+    message: string;
+    [key: string]: any;
+}
+export declare const newDefaultError: <T extends ClassType<HttpException> = typeof HttpException>(base: T, options: IAbstractDefaultErrorOptions, ...args: ConstructorParameters<T>) => IAbstractDefaultError;
+interface IFormattedCause {
+    message?: string;
+    stack?: string;
+    parentCause?: IFormattedCause;
+    [key: string]: any;
+}
+export declare function formatCause(error?: any): IFormattedCause | undefined;
+export declare const DefaultErrorMixin: <T extends ClassType<HttpException> = ClassType<HttpException>>(base?: T) => IAbstractDefaultErrorConstructor<T>;
+export type DefaultErrorMixin = Mixin<typeof DefaultErrorMixin>;
+export interface IDefaultErrorBaseConstructor<T extends ClassType<HttpException> = ClassType<HttpException>> {
+    new (internalMessage?: string, options?: Omit<IAbstractDefaultErrorOptions, 'internalMessage'>, ...args: ConstructorParameters<T>): IAbstractDefaultError;
+}
+export declare function DefaultErrorBase<T extends ClassType<HttpException> = ClassType<HttpException>>(base?: T): IDefaultErrorBaseConstructor<T>;
+declare const DefaultError_base: IDefaultErrorBaseConstructor<typeof HttpException>;
+export declare class DefaultError extends DefaultError_base {
+    static defaultStatusCode: HttpStatus;
+    constructor(internalMessage?: string, options?: IDefaultErrorOptions);
+}
+export declare const errorToDefaultError: (error: Error | HttpException | DefaultError, options?: IDefaultErrorOptions) => DefaultError;
+export declare function isDefaultErrorMixin(error: any): error is IAbstractDefaultError;
+export declare function isDefaultErrorMixinClass(error: any): error is typeof DefaultError;
+export {};