@atlantjs/arch 2.6.4 → 3.0.0

package/setup/server/cors-middleware.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorsMiddleware = void 0;
+const cors_1 = __importDefault(require("cors"));
+const env_vars_1 = require("../env/env-vars");
+class CorsMiddleware {
+    constructor(corsSpecs) {
+        this.corsSpecs = corsSpecs;
+        this.cors = (0, cors_1.default)({
+            origin: this.parseCorsAllowedOrigins(),
+            credentials: true,
+        });
+    }
+    static create(corsSpecs = env_vars_1.CORS_ALLOWED_ORIGINS) {
+        const middleware = new CorsMiddleware(corsSpecs);
+        return (request, response, next) => middleware.use(request, response, next);
+    }
+    use(request, response, next) {
+        this.cors(request, response, next);
+    }
+    parseCorsAllowedOrigins() {
+        return this.corsSpecs.split(",").map((corsSpec) => {
+            if (corsSpec.startsWith("/")) {
+                return this.stringToRegex(corsSpec);
+            }
+            return corsSpec;
+        });
+    }
+    stringToRegex(expression) {
+        const flags = expression.replace(/.*\/([gimy]*)$/, "$1");
+        const pattern = expression.replace(new RegExp(`^/(.*?)/${flags}$`), "$1");
+        return new RegExp(pattern, flags);
+    }
+}
+exports.CorsMiddleware = CorsMiddleware;

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorHandlerMiddleware = void 0;
+const http_status_codes_enum_1 = require("../../arch/modules/domain/enums/http-status-codes.enum");
+const routing_controllers_1 = require("routing-controllers");
+class DefaultErrorHandlerMiddleware {
+    static create() {
+        const middleware = new DefaultErrorHandlerMiddleware();
+        return (error, request, response, next) => middleware.use(error, request, response, next);
+    }
+    use(error, request, response, next) {
+        if (response.headersSent) {
+            next(error);
+            return;
+        }
+        this.handleError(error, response);
+    }
+    handleError(error, response) {
+        if (!(error instanceof routing_controllers_1.HttpError)) {
+            this.handleExceptions(error, response);
+            return;
+        }
+        if (error.httpCode < http_status_codes_enum_1.HttpStatusCodes.INTERNAL_SERVER_ERROR) {
+            response.status(error.httpCode).send(error);
+            return;
+        }
+        response.status(error.httpCode).send({
+            code: http_status_codes_enum_1.HttpStatusCodes[error.httpCode].toLocaleLowerCase(),
+            message: http_status_codes_enum_1.HttpStatusCodes[error.httpCode],
+        });
+    }
+    handleExceptions(error, response) {
+        this.logUnhandledError(error);
+        response.status(http_status_codes_enum_1.HttpStatusCodes.INTERNAL_SERVER_ERROR).send({
+            code: "internal_error",
+            message: "Internal server error",
+        });
+    }
+    logUnhandledError(error) {
+        console.error("\nUnhandled request error", {
+            error,
+        });
+    }
+}
+exports.DefaultErrorHandlerMiddleware = DefaultErrorHandlerMiddleware;

package/setup/server/server.d.ts

@@ -0,0 +1,6 @@
+export declare class Server {
+    static readonly instance: import("express-serve-static-core").Express;
+    private static readonly routingOptions;
+    static initialize(): void;
+    private static logFooterDevelopmentMessage;
+}

package/setup/server/server.js

@@ -0,0 +1,61 @@
+"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 guardian_1 = require("@atlantjs/guardian");
+const node_envs_enum_1 = require("../../arch/modules/domain/enums/node-envs.enum");
+const dependency_injections_1 = require("../dependency-injections");
+const env_vars_1 = require("../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");
+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");
+var LogMessage;
+(function (LogMessage) {
+    LogMessage["$start_server"] = "\n\uD83D\uDDA5\uFE0F  Starting server...";
+    LogMessage["$started_server"] = "\u2714\uFE0F  Server running on port ";
+    LogMessage["$break_line"] = "\n";
+    LogMessage["$line"] = "========================================";
+    LogMessage["$development_message"] = "\uD83D\uDE80  You are in the development environment\n              Ready to code!";
+})(LogMessage || (LogMessage = {}));
+class Server {
+    static initialize() {
+        Server.instance.disable("x-powered-by");
+        Server.instance.set("trust proxy", ["uniquelocal", "loopback"]);
+        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.useContainer)(dependency_injections_1.diContainer);
+        (0, routing_controllers_1.useExpressServer)(Server.instance, Server.routingOptions);
+        console.info(LogMessage.$start_server);
+        Server.instance.listen(env_vars_1.APP_PORT, () => {
+            console.info(LogMessage.$started_server + env_vars_1.APP_PORT);
+            if (guardian_1.Guardian.isEqual(env_vars_1.ENVIRONMENT, node_envs_enum_1.NodeEnvs.development)) {
+                Server.logFooterDevelopmentMessage();
+            }
+        });
+    }
+    static logFooterDevelopmentMessage() {
+        console.info(LogMessage.$break_line);
+        console.info(LogMessage.$line);
+        console.info(LogMessage.$development_message);
+        console.info(LogMessage.$line);
+    }
+}
+exports.Server = Server;
+Server.instance = (0, express_1.default)();
+Server.routingOptions = {
+    validation: true,
+    classTransformer: true,
+    plainToClassTransformOptions: {
+        enableImplicitConversion: false,
+    },
+    defaultErrorHandler: false,
+};