@atlantjs/backend 6.0.15 → 6.0.16

package/setup/parchment/parchment.js

@@ -1,53 +1,56 @@
-import { _ } from "@atlantjs/arch";
-import { PickEnvError } from "./parchment.error";
-export class Parchment {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parchment = void 0;
+const arch_1 = require("@atlantjs/arch");
+const parchment_error_1 = require("./parchment.error");
+class Parchment {
     static verse({ ...verse }) {
         const setValue = process.env[verse.name] || verse.default?.toString();
-        if (_.isNullOrUndefined(setValue) && verse.isRequired.truthy()) {
-            throw new PickEnvError(verse.name, verse.description, "The environment variable must have its value defined");
+        if (arch_1._.isNullOrUndefined(setValue) && verse.isRequired.truthy()) {
+            throw new parchment_error_1.PickEnvError(verse.name, verse.description, "The environment variable must have its value defined");
         }
         return Parchment.convertSetValue(verse, setValue);
     }
     static convertSetValue(verse, value) {
-        if (_.isUndefined(value)) {
+        if (arch_1._.isUndefined(value)) {
             return undefined;
         }
         if (verse.type === "array") {
             return value.split(",");
         }
         if (verse.type === "boolean") {
-            if (_.isAnyOf(value, ["false", "true"]).falsy()) {
-                throw new PickEnvError(verse.name, verse.description, `The value of the environment variable ${value} must be "false" or "true"`);
+            if (arch_1._.isAnyOf(value, ["false", "true"]).falsy()) {
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `The value of the environment variable ${value} must be "false" or "true"`);
             }
-            return _.isEqual(value, "true");
+            return arch_1._.isEqual(value, "true");
         }
         if (verse.type === "enum") {
-            if (_.isUndefined(verse.values)) {
-                throw new PickEnvError(verse.name, verse.description, `A definição da variável de ambiente ${verse.name} deve conter os valores de referencia`);
+            if (arch_1._.isUndefined(verse.values)) {
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `A definição da variável de ambiente ${verse.name} deve conter os valores de referencia`);
             }
             if (verse.values.includes(value).falsy()) {
-                throw new PickEnvError(verse.name, verse.description, `A variável ${verse.name} deve conter algum dos seguintes valores: [${verse.values.join(", ")}]`);
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `A variável ${verse.name} deve conter algum dos seguintes valores: [${verse.values.join(", ")}]`);
             }
             return value;
         }
         if (verse.type === "float") {
             const floatValue = Number.parseFloat(value);
             if (Number.isNaN(floatValue)) {
-                throw new PickEnvError(verse.name, verse.description, `The value of the environment variable ${verse.name} must be a valid float number`);
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `The value of the environment variable ${verse.name} must be a valid float number`);
             }
             return floatValue;
         }
         if (verse.type === "int") {
             const intValue = Number.parseInt(value, 10);
             if (Number.isNaN(intValue)) {
-                throw new PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser um número inteiro válido`);
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser um número inteiro válido`);
             }
             return intValue;
         }
         if (verse.type === "port-number") {
             const portNumber = Number.parseInt(value, 10);
             if (Number.isNaN(portNumber) || portNumber < 1 || portNumber > 65535) {
-                throw new PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser um número de porta válido entre 1 e 65535`);
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser um número de porta válido entre 1 e 65535`);
             }
             return portNumber;
         }
@@ -57,7 +60,7 @@ export class Parchment {
         if (verse.type === "url-https") {
             const urlPattern = /^https?:\/\/[^\s/$.?#].[^\s]*$/i;
             if (!urlPattern.test(value)) {
-                throw new PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser uma URL válida começando com http ou https`);
+                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `O valor da variável de ambiente ${verse.name} deve ser uma URL válida começando com http ou https`);
             }
             return value;
         }
@@ -65,3 +68,4 @@ export class Parchment {
         return undefined;
     }
 }
+exports.Parchment = Parchment;

package/setup/parchment/parchment.type.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/setup/server/body-parser-middleware.js

@@ -1,10 +1,18 @@
-import bodyParser from "body-parser";
-export class BodyParserMiddleware {
-    plainTextEndpoints = ["/encrypted-webhook/notification"];
-    bodyParserJson = bodyParser.json({ limit: "50mb" });
-    bodyParserText = bodyParser.text({
-        type: () => true,
-    });
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyParserMiddleware = void 0;
+const body_parser_1 = __importDefault(require("body-parser"));
+class BodyParserMiddleware {
+    constructor() {
+        this.plainTextEndpoints = ["/encrypted-webhook/notification"];
+        this.bodyParserJson = body_parser_1.default.json({ limit: "50mb" });
+        this.bodyParserText = body_parser_1.default.text({
+            type: () => true,
+        });
+    }
     static create() {
         const middleware = new BodyParserMiddleware();
         return (request, response, next) => middleware.use(request, response, next);
@@ -20,3 +28,4 @@ export class BodyParserMiddleware {
         return this.plainTextEndpoints.some((endpoint) => url.startsWith(endpoint));
     }
 }
+exports.BodyParserMiddleware = BodyParserMiddleware;

package/setup/server/cors-middleware.js

@@ -1,15 +1,20 @@
-import { CORS_ALLOWED_ORIGINS } from "../../backend/application/env/env-vars";
-import cors from "cors";
-export class CorsMiddleware {
-    corsSpecs;
-    cors = cors({
-        origin: this.parseCorsAllowedOrigins(),
-        credentials: true,
-    });
+"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 env_vars_1 = require("../../backend/application/env/env-vars");
+const cors_1 = __importDefault(require("cors"));
+class CorsMiddleware {
     constructor(corsSpecs) {
         this.corsSpecs = corsSpecs;
+        this.cors = (0, cors_1.default)({
+            origin: this.parseCorsAllowedOrigins(),
+            credentials: true,
+        });
     }
-    static create(corsSpecs = CORS_ALLOWED_ORIGINS) {
+    static create(corsSpecs = env_vars_1.CORS_ALLOWED_ORIGINS) {
         const middleware = new CorsMiddleware(corsSpecs);
         return (request, response, next) => middleware.use(request, response, next);
     }
@@ -30,3 +35,4 @@ export class CorsMiddleware {
         return new RegExp(pattern, flags);
     }
 }
+exports.CorsMiddleware = CorsMiddleware;

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);