@flusys/nestjs-shared 5.3.1 → 5.4.0

package/cjs/constants/message-keys.js

@@ -33,6 +33,8 @@ const ERROR_MESSAGES = {
     UNAUTHORIZED: 'error.unauthorized',
     FORBIDDEN: 'error.forbidden',
     CONFLICT: 'error.conflict',
+    DB_FOREIGN_KEY: 'error.db.foreign.key',
+    DB_NOT_NULL: 'error.db.not.null',
     INTERNAL: 'error.internal',
     SERVICE_UNAVAILABLE: 'error.service.unavailable',
     UNKNOWN: 'error.unknown',

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

@@ -111,6 +111,12 @@ let ConflictException = class ConflictException extends BaseAppException {
         super({
             message: field ? `${entity} with this ${field} already exists` : `${entity} already exists`,
             messageKey: _messagekeys.ERROR_MESSAGES.CONFLICT,
+            messageVariables: {
+                entity,
+                ...field !== undefined && {
+                    field
+                }
+            },
             status: _common.HttpStatus.CONFLICT,
             metadata: {
                 entity,

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

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "GlobalExceptionFilter", {
     }
 });
 const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
 const _messagekeys = require("../constants/message-keys");
 const _baseappexception = require("../exceptions/base-app.exception");
 const _loggermiddleware = require("../middlewares/logger.middleware");
@@ -36,19 +37,14 @@ let GlobalExceptionFilter = class GlobalExceptionFilter {
         const ctx = host.switchToHttp();
         const request = ctx.getRequest();
         const response = ctx.getResponse();
-        const startTime = request._startTime || Date.now();
-        const responseTime = Date.now() - startTime;
+        const responseTime = Date.now() - (request._startTime || Date.now());
         const requestId = (0, _loggermiddleware.getRequestId)() || request.headers['x-request-id'] || 'no-request-id';
-        const userId = (0, _loggermiddleware.getUserId)();
-        const tenantId = (0, _loggermiddleware.getTenantId)();
-        const companyId = (0, _loggermiddleware.getCompanyId)();
-        const errorResponse = this.buildErrorResponse(exception, requestId, responseTime);
-        const statusCode = this.getStatusCode(exception);
+        const { statusCode, errorResponse } = this.resolveException(exception, requestId, responseTime);
         const logContext = {
             requestId,
-            userId,
-            tenantId,
-            companyId,
+            userId: (0, _loggermiddleware.getUserId)(),
+            tenantId: (0, _loggermiddleware.getTenantId)(),
+            companyId: (0, _loggermiddleware.getCompanyId)(),
             method: request.method,
             url: request.originalUrl,
             path: request.path,
@@ -56,67 +52,84 @@ let GlobalExceptionFilter = class GlobalExceptionFilter {
             duration: `${responseTime}ms`,
             messageKey: errorResponse.messageKey
         };
-        const logMessage = this.buildLogMessage(request, statusCode, responseTime, errorResponse);
+        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, this.getStack(exception), logContext);
+            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);
     }
-    buildErrorResponse(exception, requestId, responseTime) {
-        const timestamp = new Date().toISOString();
+    resolveException(exception, requestId, responseTime) {
+        const meta = {
+            requestId,
+            timestamp: new Date().toISOString(),
+            responseTime
+        };
         if (exception instanceof _baseappexception.BaseAppException) {
             return {
-                success: false,
-                message: exception.message,
-                messageKey: exception.messageKey,
-                messageVariables: exception.messageVariables,
-                errors: exception.errors,
-                _meta: {
-                    requestId,
-                    timestamp,
-                    responseTime
+                statusCode: exception.getStatus(),
+                errorResponse: {
+                    success: false,
+                    message: exception.message,
+                    messageKey: exception.messageKey,
+                    messageVariables: exception.messageVariables,
+                    errors: exception.errors,
+                    _meta: meta
                 }
             };
         }
         if (exception instanceof _common.HttpException) {
-            const response = exception.getResponse();
-            const { message, messageKey, messageVariables, errors } = this.extractHttpExceptionDetails(response);
+            const resolved = this.resolveHttpException(exception);
             return {
-                success: false,
-                message,
-                messageKey,
-                messageVariables,
-                errors,
-                _meta: {
-                    requestId,
-                    timestamp,
-                    responseTime
+                statusCode: resolved.statusCode,
+                errorResponse: {
+                    success: false,
+                    message: resolved.message,
+                    messageKey: resolved.messageKey,
+                    messageVariables: resolved.messageVariables,
+                    errors: resolved.errors,
+                    _meta: meta
                 }
             };
         }
+        if (exception instanceof _typeorm.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 {
-            success: false,
-            message: 'Internal server error',
-            messageKey: _messagekeys.ERROR_MESSAGES.INTERNAL,
-            _meta: {
-                requestId,
-                timestamp,
-                responseTime
+            statusCode: _common.HttpStatus.INTERNAL_SERVER_ERROR,
+            errorResponse: {
+                success: false,
+                message: 'Internal server error',
+                messageKey: _messagekeys.ERROR_MESSAGES.INTERNAL,
+                _meta: meta
             }
         };
     }
-    extractHttpExceptionDetails(response) {
+    resolveHttpException(exception) {
+        const statusCode = exception.getStatus();
+        const response = exception.getResponse();
         if (typeof response === 'string') {
             return {
+                statusCode,
                 message: response,
                 messageKey: _messagekeys.ERROR_MESSAGES.HTTP
             };
         }
         if (typeof response === 'object' && response !== null) {
             const obj = response;
-            // Handle class-validator validation errors
             if (Array.isArray(obj.message)) {
                 const errors = obj.message.map((msg)=>{
                     const [field, ...rest] = msg.split(' ');
@@ -126,12 +139,14 @@ let GlobalExceptionFilter = class GlobalExceptionFilter {
                     };
                 });
                 return {
+                    statusCode,
                     message: 'Validation failed',
                     messageKey: _messagekeys.ERROR_MESSAGES.VALIDATION,
                     errors
                 };
             }
             return {
+                statusCode,
                 message: String(obj.message || 'Unknown error'),
                 messageKey: String(obj.messageKey || _messagekeys.ERROR_MESSAGES.HTTP),
                 messageVariables: obj.messageVariables,
@@ -139,24 +154,48 @@ let GlobalExceptionFilter = class GlobalExceptionFilter {
             };
         }
         return {
+            statusCode,
             message: 'Unknown error',
             messageKey: _messagekeys.ERROR_MESSAGES.UNKNOWN
         };
     }
-    getStatusCode(exception) {
-        if (exception instanceof _common.HttpException) {
-            return exception.getStatus();
+    resolveQueryFailedError(exception) {
+        const dbError = exception;
+        const code = dbError.driverError?.code ?? dbError.code;
+        const number = dbError.driverError?.number ?? dbError.number;
+        const detail = dbError.driverError?.detail ?? dbError.detail ?? '';
+        const table = dbError.driverError?.table ?? dbError.table ?? 'record';
+        const column = dbError.driverError?.column ?? dbError.column;
+        const field = detail.match(/Key \(([^)]+)\)/)?.[1] ?? column;
+        if (code === '23505' || number === 2627) {
+            return new _baseappexception.ConflictException(this.toHumanReadable(table), field ? this.toHumanReadable(field) : undefined);
         }
-        return _common.HttpStatus.INTERNAL_SERVER_ERROR;
-    }
-    getStack(exception) {
-        if (exception instanceof Error) {
-            return exception.stack;
+        if (code === '23503' || number === 547) {
+            const humanField = field ? this.toHumanReadable(field) : undefined;
+            return new _baseappexception.BaseAppException({
+                message: humanField ? `Invalid reference for '${humanField}'` : 'Invalid reference',
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_FOREIGN_KEY,
+                messageVariables: humanField ? {
+                    field: humanField
+                } : undefined,
+                status: _common.HttpStatus.BAD_REQUEST
+            });
+        }
+        if (code === '23502' || number === 515) {
+            const humanField = this.toHumanReadable(column ?? 'field');
+            return new _baseappexception.BaseAppException({
+                message: `Required field '${humanField}' cannot be null`,
+                messageKey: _messagekeys.ERROR_MESSAGES.DB_NOT_NULL,
+                messageVariables: {
+                    field: humanField
+                },
+                status: _common.HttpStatus.BAD_REQUEST
+            });
         }
-        return undefined;
+        return null;
     }
-    buildLogMessage(request, statusCode, responseTime, errorResponse) {
-        return `Exception caught "HTTP/1.1" "${request.method}" "${request.originalUrl}" - ${statusCode} "${errorResponse.messageKey}" ${responseTime}ms | ${errorResponse.message}`;
+    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 _common.Logger('ExceptionFilter'));

package/constants/message-keys.d.ts

@@ -10,6 +10,8 @@ export declare const ERROR_MESSAGES: {
     readonly UNAUTHORIZED: "error.unauthorized";
     readonly FORBIDDEN: "error.forbidden";
     readonly CONFLICT: "error.conflict";
+    readonly DB_FOREIGN_KEY: "error.db.foreign.key";
+    readonly DB_NOT_NULL: "error.db.not.null";
     readonly INTERNAL: "error.internal";
     readonly SERVICE_UNAVAILABLE: "error.service.unavailable";
     readonly UNKNOWN: "error.unknown";

package/fesm/constants/message-keys.js

@@ -13,6 +13,8 @@ export const ERROR_MESSAGES = {
     UNAUTHORIZED: 'error.unauthorized',
     FORBIDDEN: 'error.forbidden',
     CONFLICT: 'error.conflict',
+    DB_FOREIGN_KEY: 'error.db.foreign.key',
+    DB_NOT_NULL: 'error.db.not.null',
     INTERNAL: 'error.internal',
     SERVICE_UNAVAILABLE: 'error.service.unavailable',
     UNKNOWN: 'error.unknown',

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

@@ -75,6 +75,12 @@ export class ConflictException extends BaseAppException {
         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,

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

@@ -18,27 +18,23 @@ function _ts_decorate(decorators, target, key, desc) {
     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 } from '../exceptions/base-app.exception';
-import { getRequestId, getUserId, getTenantId, getCompanyId } from '../middlewares/logger.middleware';
+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 startTime = request._startTime || Date.now();
-        const responseTime = Date.now() - startTime;
+        const responseTime = Date.now() - (request._startTime || Date.now());
         const requestId = getRequestId() || request.headers['x-request-id'] || 'no-request-id';
-        const userId = getUserId();
-        const tenantId = getTenantId();
-        const companyId = getCompanyId();
-        const errorResponse = this.buildErrorResponse(exception, requestId, responseTime);
-        const statusCode = this.getStatusCode(exception);
+        const { statusCode, errorResponse } = this.resolveException(exception, requestId, responseTime);
         const logContext = {
             requestId,
-            userId,
-            tenantId,
-            companyId,
+            userId: getUserId(),
+            tenantId: getTenantId(),
+            companyId: getCompanyId(),
             method: request.method,
             url: request.originalUrl,
             path: request.path,
@@ -46,67 +42,84 @@ export class GlobalExceptionFilter {
             duration: `${responseTime}ms`,
             messageKey: errorResponse.messageKey
         };
-        const logMessage = this.buildLogMessage(request, statusCode, responseTime, errorResponse);
+        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, this.getStack(exception), logContext);
+            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);
     }
-    buildErrorResponse(exception, requestId, responseTime) {
-        const timestamp = new Date().toISOString();
+    resolveException(exception, requestId, responseTime) {
+        const meta = {
+            requestId,
+            timestamp: new Date().toISOString(),
+            responseTime
+        };
         if (exception instanceof BaseAppException) {
             return {
-                success: false,
-                message: exception.message,
-                messageKey: exception.messageKey,
-                messageVariables: exception.messageVariables,
-                errors: exception.errors,
-                _meta: {
-                    requestId,
-                    timestamp,
-                    responseTime
+                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 response = exception.getResponse();
-            const { message, messageKey, messageVariables, errors } = this.extractHttpExceptionDetails(response);
+            const resolved = this.resolveHttpException(exception);
             return {
-                success: false,
-                message,
-                messageKey,
-                messageVariables,
-                errors,
-                _meta: {
-                    requestId,
-                    timestamp,
-                    responseTime
+                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 {
-            success: false,
-            message: 'Internal server error',
-            messageKey: ERROR_MESSAGES.INTERNAL,
-            _meta: {
-                requestId,
-                timestamp,
-                responseTime
+            statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
+            errorResponse: {
+                success: false,
+                message: 'Internal server error',
+                messageKey: ERROR_MESSAGES.INTERNAL,
+                _meta: meta
             }
         };
     }
-    extractHttpExceptionDetails(response) {
+    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;
-            // Handle class-validator validation errors
             if (Array.isArray(obj.message)) {
                 const errors = obj.message.map((msg)=>{
                     const [field, ...rest] = msg.split(' ');
@@ -116,12 +129,14 @@ export class GlobalExceptionFilter {
                     };
                 });
                 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,
@@ -129,24 +144,48 @@ export class GlobalExceptionFilter {
             };
         }
         return {
+            statusCode,
             message: 'Unknown error',
             messageKey: ERROR_MESSAGES.UNKNOWN
         };
     }
-    getStatusCode(exception) {
-        if (exception instanceof HttpException) {
-            return exception.getStatus();
+    resolveQueryFailedError(exception) {
+        const dbError = exception;
+        const code = dbError.driverError?.code ?? dbError.code;
+        const number = dbError.driverError?.number ?? dbError.number;
+        const detail = dbError.driverError?.detail ?? dbError.detail ?? '';
+        const table = dbError.driverError?.table ?? dbError.table ?? 'record';
+        const column = dbError.driverError?.column ?? dbError.column;
+        const field = detail.match(/Key \(([^)]+)\)/)?.[1] ?? column;
+        if (code === '23505' || number === 2627) {
+            return new ConflictException(this.toHumanReadable(table), field ? this.toHumanReadable(field) : undefined);
         }
-        return HttpStatus.INTERNAL_SERVER_ERROR;
-    }
-    getStack(exception) {
-        if (exception instanceof Error) {
-            return exception.stack;
+        if (code === '23503' || number === 547) {
+            const humanField = field ? this.toHumanReadable(field) : 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
+            });
+        }
+        if (code === '23502' || number === 515) {
+            const humanField = this.toHumanReadable(column ?? 'field');
+            return new BaseAppException({
+                message: `Required field '${humanField}' cannot be null`,
+                messageKey: ERROR_MESSAGES.DB_NOT_NULL,
+                messageVariables: {
+                    field: humanField
+                },
+                status: HttpStatus.BAD_REQUEST
+            });
         }
-        return undefined;
+        return null;
     }
-    buildLogMessage(request, statusCode, responseTime, errorResponse) {
-        return `Exception caught "HTTP/1.1" "${request.method}" "${request.originalUrl}" - ${statusCode} "${errorResponse.messageKey}" ${responseTime}ms | ${errorResponse.message}`;
+    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'));

package/filters/global-exception.filter.d.ts

@@ -2,9 +2,8 @@ import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
 export declare class GlobalExceptionFilter implements ExceptionFilter {
     private readonly logger;
     catch(exception: unknown, host: ArgumentsHost): void;
-    private buildErrorResponse;
-    private extractHttpExceptionDetails;
-    private getStatusCode;
-    private getStack;
-    private buildLogMessage;
+    private resolveException;
+    private resolveHttpException;
+    private resolveQueryFailedError;
+    private toHumanReadable;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "5.3.1",
+  "version": "5.4.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -112,6 +112,6 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "5.3.1"
+    "@flusys/nestjs-core": "5.4.0"
   }
 }