@atlantjs/backend 6.0.15 → 6.0.17

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

@@ -1,8 +1,14 @@
-import _ from "lodash";
-import { HttpError } from "routing-controllers";
-import { HttpStatusCodes } from "@atlantjs/arch";
-import { UnknownError } from "./unknow.error";
-export class DefaultErrorHandlerMiddleware {
+"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 lodash_1 = __importDefault(require("lodash"));
+const routing_controllers_1 = require("routing-controllers");
+const arch_1 = require("@atlantjs/arch");
+const unknow_error_1 = require("./unknow.error");
+class DefaultErrorHandlerMiddleware {
     static create() {
         const middleware = new DefaultErrorHandlerMiddleware();
         return (error, req, res, next) => middleware.use(error, req, res, next);
@@ -15,22 +21,22 @@ export class DefaultErrorHandlerMiddleware {
         this.handleError(error, res);
     }
     handleError(error, res) {
-        if (!(error instanceof HttpError)) {
+        if (!(error instanceof routing_controllers_1.HttpError)) {
             this.handleExceptions(error, res);
             return;
         }
-        if (error.httpCode < HttpStatusCodes.INTERNAL_SERVER_ERROR) {
-            res.status(error.httpCode).send(_.omit(error, "httpCode", "stack"));
+        if (error.httpCode < arch_1.HttpStatusCodes.INTERNAL_SERVER_ERROR) {
+            res.status(error.httpCode).send(lodash_1.default.omit(error, "httpCode", "stack"));
             return;
         }
         res.status(error.httpCode).send({
-            code: HttpStatusCodes[error.httpCode].toLocaleLowerCase(),
-            message: HttpStatusCodes[error.httpCode],
+            code: arch_1.HttpStatusCodes[error.httpCode].toLocaleLowerCase(),
+            message: arch_1.HttpStatusCodes[error.httpCode],
         });
     }
     handleExceptions(error, res) {
         this.logUnhandledError(error);
-        res.status(HttpStatusCodes.INTERNAL_SERVER_ERROR).send(new UnknownError({
+        res.status(arch_1.HttpStatusCodes.INTERNAL_SERVER_ERROR).send(new unknow_error_1.UnknownError({
             code: "internal_error",
             message: "Internal server error",
         }));
@@ -41,3 +47,4 @@ export class DefaultErrorHandlerMiddleware {
         });
     }
 }
+exports.DefaultErrorHandlerMiddleware = DefaultErrorHandlerMiddleware;

package/setup/server/server.js

@@ -1,12 +1,18 @@
-import { NodeEnvs, _ } from "@atlantjs/arch";
-import cookieParser from "cookie-parser";
-import express from "express";
-import helmet from "helmet";
-import { useExpressServer, } from "routing-controllers";
-import { APP_PORT, ENVIRONMENT } from "../../backend/application/env/env-vars";
-import { BodyParserMiddleware } from "./body-parser-middleware";
-import { CorsMiddleware } from "./cors-middleware";
-import { DefaultErrorHandlerMiddleware } from "./default-error-handler-middleware";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const arch_1 = require("@atlantjs/arch");
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const express_1 = __importDefault(require("express"));
+const helmet_1 = __importDefault(require("helmet"));
+const routing_controllers_1 = require("routing-controllers");
+const env_vars_1 = require("../../backend/application/env/env-vars");
+const body_parser_middleware_1 = require("./body-parser-middleware");
+const cors_middleware_1 = require("./cors-middleware");
+const default_error_handler_middleware_1 = require("./default-error-handler-middleware");
 var LogMessage;
 (function (LogMessage) {
     LogMessage["$start_server"] = "\n\uD83D\uDDA5\uFE0F  Starting server...";
@@ -15,29 +21,20 @@ var LogMessage;
     LogMessage["$line"] = "========================================";
     LogMessage["$development_message"] = "\uD83D\uDE80  You are in the development environment\n              Ready to code!";
 })(LogMessage || (LogMessage = {}));
-export class Server {
-    static instance = express();
-    static routingOptions = {
-        validation: true,
-        classTransformer: true,
-        plainToClassTransformOptions: {
-            enableImplicitConversion: false,
-        },
-        defaultErrorHandler: true,
-    };
+class Server {
     static initialize() {
         Server.instance.disable("x-powered-by");
         Server.instance.set("trust proxy", ["uniquelocal", "loopback"]);
-        Server.instance.use(helmet());
-        Server.instance.use(CorsMiddleware.create());
-        Server.instance.use(cookieParser());
-        Server.instance.use(BodyParserMiddleware.create());
-        Server.instance.use(DefaultErrorHandlerMiddleware.create());
-        useExpressServer(Server.instance, Server.routingOptions);
+        Server.instance.use((0, helmet_1.default)());
+        Server.instance.use(cors_middleware_1.CorsMiddleware.create());
+        Server.instance.use((0, cookie_parser_1.default)());
+        Server.instance.use(body_parser_middleware_1.BodyParserMiddleware.create());
+        Server.instance.use(default_error_handler_middleware_1.DefaultErrorHandlerMiddleware.create());
+        (0, routing_controllers_1.useExpressServer)(Server.instance, Server.routingOptions);
         console.info(LogMessage.$start_server);
-        Server.instance.listen(APP_PORT, () => {
-            console.info(LogMessage.$started_server + APP_PORT);
-            if (_.isEqual(ENVIRONMENT, NodeEnvs.development)) {
+        Server.instance.listen(env_vars_1.APP_PORT, () => {
+            console.info(LogMessage.$started_server + env_vars_1.APP_PORT);
+            if (arch_1._.isEqual(env_vars_1.ENVIRONMENT, arch_1.NodeEnvs.development)) {
                 Server.logFooterDevelopmentMessage();
             }
         });
@@ -49,3 +46,13 @@ export class Server {
         console.info(LogMessage.$line);
     }
 }
+exports.Server = Server;
+Server.instance = (0, express_1.default)();
+Server.routingOptions = {
+    validation: true,
+    classTransformer: true,
+    plainToClassTransformOptions: {
+        enableImplicitConversion: false,
+    },
+    defaultErrorHandler: true,
+};

package/setup/server/unknow.error.js

@@ -1,3 +1,4 @@
+"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);
@@ -7,23 +8,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Expose, instanceToPlain } from "class-transformer";
-export class UnknownError {
-    unknownCode;
-    unknownMessage;
+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;
     }
     toPolygon() {
-        return instanceToPlain(this);
+        return (0, class_transformer_1.instanceToPlain)(this);
     }
 }
+exports.UnknownError = UnknownError;
 __decorate([
-    Expose(),
+    (0, class_transformer_1.Expose)(),
     __metadata("design:type", String)
 ], UnknownError.prototype, "unknownCode", void 0);
 __decorate([
-    Expose(),
+    (0, class_transformer_1.Expose)(),
     __metadata("design:type", String)
 ], UnknownError.prototype, "unknownMessage", void 0);