@atlantjs/backend 4.0.14 → 4.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlantjs/backend",
-	"version": "4.0.14",
+	"version": "4.0.15",
 	"main": "index.js",
 	"license": "UNLICENSED",
 	"publishConfig": {
@@ -38,6 +38,7 @@
 		"express": "4.19.2",
 		"helmet": "7.1.0",
 		"inversify": "6.0.2",
+		"lodash": "^4.17.21",
 		"module-alias": "2.2.3",
 		"reflect-metadata": "0.2.2",
 		"routing-controllers": "0.10.4",
@@ -49,6 +50,7 @@
 		"@types/cookie-parser": "1.4.8",
 		"@types/cors": "2.8.17",
 		"@types/express": "5.0.0",
+		"@types/lodash": "^4.17.16",
 		"@types/node": "22.13.5",
 		"copyfiles": "2.4.1",
 		"cross-env": "7.0.3",

package/setup/server/default-error-handler-middleware.d.ts

@@ -1,7 +1,7 @@
 import { ErrorRequestHandler, NextFunction, Request, Response } from "express";
 export declare class DefaultErrorHandlerMiddleware {
     static create(): ErrorRequestHandler;
-    use(error: Error, request: Request, response: Response, next: NextFunction): void;
+    use(error: Error, req: Request, res: Response, next: NextFunction): void;
     private handleError;
     private handleExceptions;
     private logUnhandledError;

package/setup/server/default-error-handler-middleware.js

@@ -1,43 +1,48 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultErrorHandlerMiddleware = void 0;
-const arch_1 = require("@atlantjs/arch");
+const lodash_1 = __importDefault(require("lodash"));
 const routing_controllers_1 = require("routing-controllers");
+const unknow_error_1 = require("./unknow.error");
+const arch_1 = require("@atlantjs/arch");
 class DefaultErrorHandlerMiddleware {
     static create() {
         const middleware = new DefaultErrorHandlerMiddleware();
-        return (error, request, response, next) => middleware.use(error, request, response, next);
+        return (error, req, res, next) => middleware.use(error, req, res, next);
     }
-    use(error, request, response, next) {
-        if (response.headersSent) {
+    use(error, req, res, next) {
+        if (res.headersSent) {
             next(error);
             return;
         }
-        this.handleError(error, response);
+        this.handleError(error, res);
     }
-    handleError(error, response) {
+    handleError(error, res) {
         if (!(error instanceof routing_controllers_1.HttpError)) {
-            this.handleExceptions(error, response);
+            this.handleExceptions(error, res);
             return;
         }
         if (error.httpCode < arch_1.HttpStatusCodes.INTERNAL_SERVER_ERROR) {
-            response.status(error.httpCode).send(error);
+            res.status(error.httpCode).send(lodash_1.default.omit(error, "httpCode"));
             return;
         }
-        response.status(error.httpCode).send({
+        res.status(error.httpCode).send({
             code: arch_1.HttpStatusCodes[error.httpCode].toLocaleLowerCase(),
             message: arch_1.HttpStatusCodes[error.httpCode],
         });
     }
-    handleExceptions(error, response) {
+    handleExceptions(error, res) {
         this.logUnhandledError(error);
-        response.status(arch_1.HttpStatusCodes.INTERNAL_SERVER_ERROR).send({
+        res.status(arch_1.HttpStatusCodes.INTERNAL_SERVER_ERROR).send(new unknow_error_1.UnknownError({
             code: "internal_error",
             message: "Internal server error",
-        });
+        }));
     }
     logUnhandledError(error) {
-        console.error("\nUnhandled request error", {
+        console.error("\n⚠️  Unhandled request error", {
             error,
         });
     }

package/setup/server/unknow.error.d.ts

@@ -0,0 +1,11 @@
+interface UnknownApplicationError {
+    code: string;
+    message: string;
+}
+export declare class UnknownError {
+    readonly unknownCode: string;
+    readonly unknownMessage: string;
+    constructor(error: UnknownApplicationError);
+    toPlain(): unknown;
+}
+export {};

package/setup/server/unknow.error.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = void 0;
+const class_transformer_1 = require("class-transformer");
+class UnknownError {
+    constructor(error) {
+        this.unknownCode = error.code;
+        this.unknownMessage = error.message;
+    }
+    toPlain() {
+        return (0, class_transformer_1.instanceToPlain)(this);
+    }
+}
+exports.UnknownError = UnknownError;
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], UnknownError.prototype, "unknownCode", void 0);
+__decorate([
+    (0, class_transformer_1.Expose)(),
+    __metadata("design:type", String)
+], UnknownError.prototype, "unknownMessage", void 0);