@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/exceptions/base-app.exception.js

@@ -1,115 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { HttpException, HttpStatus } from '@nestjs/common';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-export class BaseAppException extends HttpException {
-    constructor(options){
-        const status = options.status || HttpStatus.BAD_REQUEST;
-        super({
-            success: false,
-            message: options.message,
-            messageKey: options.messageKey || ERROR_MESSAGES.GENERIC,
-            messageVariables: options.messageVariables,
-            errors: options.errors
-        }, status), _define_property(this, "messageKey", void 0), _define_property(this, "messageVariables", void 0), _define_property(this, "errors", void 0), _define_property(this, "metadata", void 0);
-        this.messageKey = options.messageKey || ERROR_MESSAGES.GENERIC;
-        this.messageVariables = options.messageVariables;
-        this.errors = options.errors;
-        this.metadata = options.metadata;
-    }
-}
-export class NotFoundException extends BaseAppException {
-    constructor(entity, id){
-        super({
-            message: id ? `${entity} with id "${id}" not found` : `${entity} not found`,
-            messageKey: ERROR_MESSAGES.NOT_FOUND,
-            status: HttpStatus.NOT_FOUND,
-            metadata: {
-                entity,
-                id
-            }
-        });
-    }
-}
-export class ValidationException extends BaseAppException {
-    constructor(errors){
-        super({
-            message: 'Validation failed',
-            messageKey: ERROR_MESSAGES.VALIDATION,
-            status: HttpStatus.BAD_REQUEST,
-            errors
-        });
-    }
-}
-export class UnauthorizedException extends BaseAppException {
-    constructor(message = 'Unauthorized access'){
-        super({
-            message,
-            messageKey: ERROR_MESSAGES.UNAUTHORIZED,
-            status: HttpStatus.UNAUTHORIZED
-        });
-    }
-}
-export class ForbiddenException extends BaseAppException {
-    constructor(message = 'Access forbidden'){
-        super({
-            message,
-            messageKey: ERROR_MESSAGES.FORBIDDEN,
-            status: HttpStatus.FORBIDDEN
-        });
-    }
-}
-export class ConflictException extends BaseAppException {
-    constructor(entity, field){
-        super({
-            message: field ? `${entity} with this ${field} already exists` : `${entity} already exists`,
-            messageKey: ERROR_MESSAGES.CONFLICT,
-            messageVariables: {
-                entity,
-                ...field !== undefined && {
-                    field
-                }
-            },
-            status: HttpStatus.CONFLICT,
-            metadata: {
-                entity,
-                field
-            }
-        });
-    }
-}
-export class InternalServerException extends BaseAppException {
-    constructor(message = 'Internal server error'){
-        super({
-            message,
-            messageKey: ERROR_MESSAGES.INTERNAL,
-            status: HttpStatus.INTERNAL_SERVER_ERROR
-        });
-    }
-}
-export class ServiceUnavailableException extends BaseAppException {
-    constructor(service){
-        super({
-            message: `${service} is temporarily unavailable`,
-            messageKey: ERROR_MESSAGES.SERVICE_UNAVAILABLE,
-            messageVariables: {
-                service
-            },
-            status: HttpStatus.SERVICE_UNAVAILABLE,
-            metadata: {
-                service
-            }
-        });
-    }
-}

package/fesm/exceptions/base-app.exception.spec.js

@@ -1,153 +0,0 @@
-import { HttpStatus } from '@nestjs/common';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-import { BaseAppException, ConflictException, ForbiddenException, InternalServerException, NotFoundException, ServiceUnavailableException, UnauthorizedException, ValidationException } from './base-app.exception';
-describe('BaseAppException', ()=>{
-    it('should default status to BAD_REQUEST when not provided', ()=>{
-        const exception = new BaseAppException({
-            message: 'oops'
-        });
-        expect(exception.getStatus()).toBe(HttpStatus.BAD_REQUEST);
-    });
-    it('should default messageKey to ERROR_MESSAGES.GENERIC when not provided', ()=>{
-        const exception = new BaseAppException({
-            message: 'oops'
-        });
-        expect(exception.messageKey).toBe(ERROR_MESSAGES.GENERIC);
-    });
-    it('should use the provided status, messageKey, messageVariables, errors, and metadata', ()=>{
-        const errors = [
-            {
-                field: 'name',
-                message: 'required'
-            }
-        ];
-        const exception = new BaseAppException({
-            message: 'Invalid',
-            messageKey: 'custom.key',
-            messageVariables: {
-                foo: 'bar'
-            },
-            status: HttpStatus.UNPROCESSABLE_ENTITY,
-            errors,
-            metadata: {
-                extra: true
-            }
-        });
-        expect(exception.getStatus()).toBe(HttpStatus.UNPROCESSABLE_ENTITY);
-        expect(exception.messageKey).toBe('custom.key');
-        expect(exception.messageVariables).toEqual({
-            foo: 'bar'
-        });
-        expect(exception.errors).toEqual(errors);
-        expect(exception.metadata).toEqual({
-            extra: true
-        });
-    });
-    it('should build an HttpException response body with success:false', ()=>{
-        const exception = new BaseAppException({
-            message: 'oops',
-            messageKey: 'k'
-        });
-        expect(exception.getResponse()).toEqual({
-            success: false,
-            message: 'oops',
-            messageKey: 'k',
-            messageVariables: undefined,
-            errors: undefined
-        });
-    });
-    describe('NotFoundException', ()=>{
-        it('should build a message with id when id is provided', ()=>{
-            const exception = new NotFoundException('User', 'uuid-1');
-            expect(exception.getStatus()).toBe(HttpStatus.NOT_FOUND);
-            expect(exception.message).toBe('User with id "uuid-1" not found');
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.NOT_FOUND);
-            expect(exception.metadata).toEqual({
-                entity: 'User',
-                id: 'uuid-1'
-            });
-        });
-        it('should build a message without id when id is omitted', ()=>{
-            const exception = new NotFoundException('User');
-            expect(exception.message).toBe('User not found');
-        });
-    });
-    describe('ValidationException', ()=>{
-        it('should carry the validation errors and BAD_REQUEST status', ()=>{
-            const errors = [
-                {
-                    field: 'email',
-                    message: 'invalid format'
-                }
-            ];
-            const exception = new ValidationException(errors);
-            expect(exception.getStatus()).toBe(HttpStatus.BAD_REQUEST);
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.VALIDATION);
-            expect(exception.errors).toEqual(errors);
-        });
-    });
-    describe('UnauthorizedException', ()=>{
-        it('should use the default message when none is provided', ()=>{
-            const exception = new UnauthorizedException();
-            expect(exception.getStatus()).toBe(HttpStatus.UNAUTHORIZED);
-            expect(exception.message).toBe('Unauthorized access');
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.UNAUTHORIZED);
-        });
-        it('should use a custom message when provided', ()=>{
-            const exception = new UnauthorizedException('Custom message');
-            expect(exception.message).toBe('Custom message');
-        });
-    });
-    describe('ForbiddenException', ()=>{
-        it('should default to "Access forbidden"', ()=>{
-            const exception = new ForbiddenException();
-            expect(exception.getStatus()).toBe(HttpStatus.FORBIDDEN);
-            expect(exception.message).toBe('Access forbidden');
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.FORBIDDEN);
-        });
-    });
-    describe('ConflictException', ()=>{
-        it('should include the field in the message and metadata when provided', ()=>{
-            const exception = new ConflictException('User', 'email');
-            expect(exception.getStatus()).toBe(HttpStatus.CONFLICT);
-            expect(exception.message).toBe('User with this email already exists');
-            expect(exception.messageVariables).toEqual({
-                entity: 'User',
-                field: 'email'
-            });
-            expect(exception.metadata).toEqual({
-                entity: 'User',
-                field: 'email'
-            });
-        });
-        it('should omit the field when not provided', ()=>{
-            const exception = new ConflictException('User');
-            expect(exception.message).toBe('User already exists');
-            expect(exception.messageVariables).toEqual({
-                entity: 'User'
-            });
-        });
-    });
-    describe('InternalServerException', ()=>{
-        it('should default to "Internal server error"', ()=>{
-            const exception = new InternalServerException();
-            expect(exception.getStatus()).toBe(HttpStatus.INTERNAL_SERVER_ERROR);
-            expect(exception.message).toBe('Internal server error');
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.INTERNAL);
-        });
-    });
-    describe('ServiceUnavailableException', ()=>{
-        it('should build a message including the service name', ()=>{
-            const exception = new ServiceUnavailableException('Email');
-            expect(exception.getStatus()).toBe(HttpStatus.SERVICE_UNAVAILABLE);
-            expect(exception.message).toBe('Email is temporarily unavailable');
-            expect(exception.messageKey).toBe(ERROR_MESSAGES.SERVICE_UNAVAILABLE);
-            expect(exception.messageVariables).toEqual({
-                service: 'Email'
-            });
-            expect(exception.metadata).toEqual({
-                service: 'Email'
-            });
-        });
-    });
-});

package/fesm/exceptions/permission.exception.js

@@ -1,35 +0,0 @@
-import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-export class PermissionSystemUnavailableException extends InternalServerErrorException {
-    constructor(){
-        super({
-            success: false,
-            message: 'Permission system temporarily unavailable',
-            messageKey: ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE
-        });
-    }
-}
-export class InsufficientPermissionsException extends ForbiddenException {
-    constructor(missingPermissions, operator = 'AND'){
-        const messageKey = operator === 'OR' ? ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR : ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS;
-        super({
-            success: false,
-            message: 'Insufficient permissions',
-            messageKey,
-            messageVariables: {
-                permissions: missingPermissions.join(', ')
-            },
-            missingPermissions,
-            operator
-        });
-    }
-}
-export class NoPermissionsFoundException extends ForbiddenException {
-    constructor(){
-        super({
-            success: false,
-            message: 'No permissions found',
-            messageKey: ERROR_MESSAGES.NO_PERMISSIONS_FOUND
-        });
-    }
-}

package/fesm/exceptions/permission.exception.spec.js

@@ -1,78 +0,0 @@
-import { ForbiddenException, InternalServerErrorException } from '@nestjs/common';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-import { InsufficientPermissionsException, NoPermissionsFoundException, PermissionSystemUnavailableException } from './permission.exception';
-describe('permission exceptions', ()=>{
-    describe('PermissionSystemUnavailableException', ()=>{
-        it('should be an InternalServerErrorException with the expected response body', ()=>{
-            const exception = new PermissionSystemUnavailableException();
-            expect(exception).toBeInstanceOf(InternalServerErrorException);
-            expect(exception.getResponse()).toMatchObject({
-                success: false,
-                message: 'Permission system temporarily unavailable',
-                messageKey: ERROR_MESSAGES.PERMISSION_SYSTEM_UNAVAILABLE
-            });
-        });
-    });
-    describe('InsufficientPermissionsException', ()=>{
-        it('should default to AND operator and matching messageKey', ()=>{
-            const exception = new InsufficientPermissionsException([
-                'user.create',
-                'user.update'
-            ]);
-            expect(exception).toBeInstanceOf(ForbiddenException);
-            expect(exception.getResponse()).toMatchObject({
-                success: false,
-                message: 'Insufficient permissions',
-                messageKey: ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS,
-                messageVariables: {
-                    permissions: 'user.create, user.update'
-                },
-                missingPermissions: [
-                    'user.create',
-                    'user.update'
-                ],
-                operator: 'AND'
-            });
-        });
-        it('should use the OR messageKey when operator is OR', ()=>{
-            const exception = new InsufficientPermissionsException([
-                'admin',
-                'manager'
-            ], 'OR');
-            expect(exception.getResponse()).toMatchObject({
-                messageKey: ERROR_MESSAGES.INSUFFICIENT_PERMISSIONS_OR,
-                operator: 'OR'
-            });
-        });
-        it('should join a single missing permission without a separator', ()=>{
-            const exception = new InsufficientPermissionsException([
-                'user.create'
-            ]);
-            expect(exception.getResponse()).toMatchObject({
-                messageVariables: {
-                    permissions: 'user.create'
-                }
-            });
-        });
-        it('should handle an empty missing-permissions list', ()=>{
-            const exception = new InsufficientPermissionsException([]);
-            expect(exception.getResponse()).toMatchObject({
-                messageVariables: {
-                    permissions: ''
-                },
-                missingPermissions: []
-            });
-        });
-    });
-    describe('NoPermissionsFoundException', ()=>{
-        it('should be a ForbiddenException with the expected response body', ()=>{
-            const exception = new NoPermissionsFoundException();
-            expect(exception).toBeInstanceOf(ForbiddenException);
-            expect(exception.getResponse()).toMatchObject({
-                success: false,
-                message: 'No permissions found',
-                messageKey: ERROR_MESSAGES.NO_PERMISSIONS_FOUND
-            });
-        });
-    });
-});

package/fesm/filters/global-exception.filter.js

@@ -1,269 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(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;
-}
-import { Catch, HttpException, HttpStatus, Logger } from '@nestjs/common';
-import { QueryFailedError } from 'typeorm';
-import { ERROR_MESSAGES } from '../constants/message-keys';
-import { BaseAppException, ConflictException } from '../exceptions/base-app.exception';
-import { getCompanyId, getRequestId, getTenantId, getUserId } from '../middlewares/logger.middleware';
-export class GlobalExceptionFilter {
-    catch(exception, host) {
-        const ctx = host.switchToHttp();
-        const request = ctx.getRequest();
-        const response = ctx.getResponse();
-        const responseTime = Date.now() - (request._startTime || Date.now());
-        const requestId = getRequestId() || request.headers['x-request-id'] || 'no-request-id';
-        const { statusCode, errorResponse } = this.resolveException(exception, requestId, responseTime);
-        const logContext = {
-            requestId,
-            userId: getUserId(),
-            tenantId: getTenantId(),
-            companyId: getCompanyId(),
-            method: request.method,
-            url: request.originalUrl,
-            path: request.path,
-            statusCode,
-            duration: `${responseTime}ms`,
-            messageKey: errorResponse.messageKey
-        };
-        const logMessage = `Exception caught "HTTP/1.1" "${request.method}" "${request.originalUrl}" - ${statusCode} "${errorResponse.messageKey}" ${responseTime}ms | ${errorResponse.message}`;
-        if (statusCode >= 500) {
-            this.logger.error(logMessage, exception instanceof Error ? exception.stack : undefined, logContext);
-        } else if (statusCode >= 400) {
-            this.logger.warn(logMessage, logContext);
-        }
-        response.status(statusCode).json(errorResponse);
-    }
-    resolveException(exception, requestId, responseTime) {
-        const meta = {
-            requestId,
-            timestamp: new Date().toISOString(),
-            responseTime
-        };
-        if (exception instanceof BaseAppException) {
-            return {
-                statusCode: exception.getStatus(),
-                errorResponse: {
-                    success: false,
-                    message: exception.message,
-                    messageKey: exception.messageKey,
-                    messageVariables: exception.messageVariables,
-                    errors: exception.errors,
-                    _meta: meta
-                }
-            };
-        }
-        if (exception instanceof HttpException) {
-            const resolved = this.resolveHttpException(exception);
-            return {
-                statusCode: resolved.statusCode,
-                errorResponse: {
-                    success: false,
-                    message: resolved.message,
-                    messageKey: resolved.messageKey,
-                    messageVariables: resolved.messageVariables,
-                    errors: resolved.errors,
-                    _meta: meta
-                }
-            };
-        }
-        if (exception instanceof QueryFailedError) {
-            const resolved = this.resolveQueryFailedError(exception);
-            if (resolved) {
-                return {
-                    statusCode: resolved.getStatus(),
-                    errorResponse: {
-                        success: false,
-                        message: resolved.message,
-                        messageKey: resolved.messageKey,
-                        messageVariables: resolved.messageVariables,
-                        _meta: meta
-                    }
-                };
-            }
-        }
-        return {
-            statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
-            errorResponse: {
-                success: false,
-                message: 'Internal server error',
-                messageKey: ERROR_MESSAGES.INTERNAL,
-                _meta: meta
-            }
-        };
-    }
-    resolveHttpException(exception) {
-        const statusCode = exception.getStatus();
-        const response = exception.getResponse();
-        if (typeof response === 'string') {
-            return {
-                statusCode,
-                message: response,
-                messageKey: ERROR_MESSAGES.HTTP
-            };
-        }
-        if (typeof response === 'object' && response !== null) {
-            const obj = response;
-            if (Array.isArray(obj.message)) {
-                const errors = obj.message.map((msg)=>{
-                    const [field, ...rest] = msg.split(' ');
-                    return {
-                        field: field || 'unknown',
-                        message: rest.join(' ') || msg
-                    };
-                });
-                return {
-                    statusCode,
-                    message: 'Validation failed',
-                    messageKey: ERROR_MESSAGES.VALIDATION,
-                    errors
-                };
-            }
-            return {
-                statusCode,
-                message: String(obj.message || 'Unknown error'),
-                messageKey: String(obj.messageKey || ERROR_MESSAGES.HTTP),
-                messageVariables: obj.messageVariables,
-                errors: obj.errors
-            };
-        }
-        return {
-            statusCode,
-            message: 'Unknown error',
-            messageKey: ERROR_MESSAGES.UNKNOWN
-        };
-    }
-    resolveQueryFailedError(exception) {
-        const dbError = exception;
-        const code = dbError.driverError?.code ?? dbError.code;
-        const number = dbError.driverError?.number ?? dbError.number;
-        const errno = dbError.driverError?.errno ?? dbError.errno;
-        const sqlMessage = dbError.driverError?.sqlMessage ?? '';
-        const detail = dbError.driverError?.detail ?? dbError.detail ?? '';
-        const table = dbError.driverError?.table ?? dbError.table ?? '';
-        const column = dbError.driverError?.column ?? dbError.column;
-        const pgField = detail.match(/Key \(([^)]+)\)/)?.[1] ?? column;
-        // DUPLICATE / UNIQUE VIOLATION
-        // PG: 23505 | MSSQL: 2627 (constraint), 2601 (index) | MySQL: ER_DUP_ENTRY / errno 1062
-        if (code === '23505' || number === 2627 || number === 2601 || code === 'ER_DUP_ENTRY' || errno === 1062) {
-            const mysqlTable = sqlMessage.match(/for key '([^'.]+)\./)?.[1];
-            const mysqlIndex = sqlMessage.match(/for key '(?:[^.]+\.)?([^']+)'/)?.[1];
-            const resolvedTable = table || mysqlTable || 'record';
-            const resolvedField = pgField ? this.toHumanReadable(pgField) : mysqlIndex ? this.toHumanReadable(mysqlIndex) : undefined;
-            return new ConflictException(this.toHumanReadable(resolvedTable), resolvedField);
-        }
-        // FOREIGN KEY VIOLATION
-        // PG: 23503 | MSSQL: 547 | MySQL: ER_NO_REFERENCED_ROW_2/1452 (insert), ER_ROW_IS_REFERENCED_2/1451 (delete)
-        if (code === '23503' || number === 547 || code === 'ER_NO_REFERENCED_ROW_2' || code === 'ER_ROW_IS_REFERENCED_2' || errno === 1452 || errno === 1451) {
-            const mysqlColumn = sqlMessage.match(/FOREIGN KEY \(`([^`]+)`\)/)?.[1];
-            const raw = pgField ?? mysqlColumn;
-            const humanField = raw ? this.toHumanReadable(raw) : undefined;
-            return new BaseAppException({
-                message: humanField ? `Invalid reference for '${humanField}'` : 'Invalid reference',
-                messageKey: ERROR_MESSAGES.DB_FOREIGN_KEY,
-                messageVariables: humanField ? {
-                    field: humanField
-                } : undefined,
-                status: HttpStatus.BAD_REQUEST
-            });
-        }
-        // NOT NULL VIOLATION
-        // PG: 23502 | MSSQL: 515 | MySQL: ER_BAD_NULL_ERROR / errno 1048
-        if (code === '23502' || number === 515 || code === 'ER_BAD_NULL_ERROR' || errno === 1048) {
-            const mysqlColumn = sqlMessage.match(/Column '([^']+)' cannot be null/)?.[1];
-            const humanField = this.toHumanReadable(column ?? mysqlColumn ?? 'field');
-            return new BaseAppException({
-                message: `Required field '${humanField}' cannot be null`,
-                messageKey: ERROR_MESSAGES.DB_NOT_NULL,
-                messageVariables: {
-                    field: humanField
-                },
-                status: HttpStatus.BAD_REQUEST
-            });
-        }
-        // INVALID INPUT SYNTAX — PostgreSQL only (MySQL silently coerces types)
-        if (code === '22P02') {
-            const typeMatch = exception.message.match(/invalid input syntax for(?:\s+type)?\s+(\w+)/i);
-            const type = typeMatch?.[1] ?? 'value';
-            const humanField = column ? this.toHumanReadable(column) : undefined;
-            return new BaseAppException({
-                message: humanField ? `Invalid ${type} value for '${humanField}'` : `Invalid ${type} value`,
-                messageKey: ERROR_MESSAGES.DB_INVALID_INPUT,
-                messageVariables: {
-                    type,
-                    ...humanField !== undefined && {
-                        field: humanField
-                    }
-                },
-                status: HttpStatus.BAD_REQUEST
-            });
-        }
-        // VALUE TOO LONG
-        // PG: 22001 | MySQL: ER_DATA_TOO_LONG / errno 1406
-        if (code === '22001' || code === 'ER_DATA_TOO_LONG' || errno === 1406) {
-            const mysqlColumn = sqlMessage.match(/Data too long for column '([^']+)'/)?.[1];
-            const resolvedColumn = column ?? mysqlColumn;
-            const humanField = resolvedColumn ? this.toHumanReadable(resolvedColumn) : undefined;
-            return new BaseAppException({
-                message: humanField ? `Value too long for '${humanField}'` : 'Value exceeds maximum length',
-                messageKey: ERROR_MESSAGES.DB_VALUE_TOO_LONG,
-                messageVariables: humanField !== undefined ? {
-                    field: humanField
-                } : undefined,
-                status: HttpStatus.BAD_REQUEST
-            });
-        }
-        // CHECK CONSTRAINT VIOLATION
-        // PG: 23514 | MySQL 8.0+: ER_CHECK_CONSTRAINT_VIOLATED / errno 3819
-        if (code === '23514' || code === 'ER_CHECK_CONSTRAINT_VIOLATED' || errno === 3819) {
-            const constraint = dbError.driverError?.constraint ?? dbError.constraint;
-            const humanTable = this.toHumanReadable(table || 'record');
-            return new BaseAppException({
-                message: `${humanTable} violates a validation rule`,
-                messageKey: ERROR_MESSAGES.DB_CHECK_CONSTRAINT,
-                messageVariables: {
-                    entity: humanTable,
-                    ...constraint !== undefined && {
-                        constraint
-                    }
-                },
-                status: HttpStatus.BAD_REQUEST
-            });
-        }
-        // DEADLOCK
-        // PG: 40P01 | MSSQL: 1205 | MySQL: ER_LOCK_DEADLOCK / errno 1213
-        if (code === '40P01' || number === 1205 || code === 'ER_LOCK_DEADLOCK' || errno === 1213) {
-            return new BaseAppException({
-                message: 'The request could not be completed due to a conflict, please try again',
-                messageKey: ERROR_MESSAGES.DB_DEADLOCK,
-                status: HttpStatus.SERVICE_UNAVAILABLE
-            });
-        }
-        return null;
-    }
-    toHumanReadable(dbName) {
-        return dbName.split(', ').map((part)=>part.split('_').map((word)=>word.toLowerCase() === 'id' ? 'ID' : word.charAt(0).toUpperCase() + word.slice(1)).join(' ')).join(', ');
-    }
-    constructor(){
-        _define_property(this, "logger", new Logger('ExceptionFilter'));
-    }
-}
-GlobalExceptionFilter = _ts_decorate([
-    Catch()
-], GlobalExceptionFilter);