@atlantjs/backend 5.1.1 → 6.0.0

package/setup/dependency-injections/index.js

@@ -1,11 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.diContainer = void 0;
-exports.startContainer = startContainer;
-const di_container_1 = require("./di-container");
-const routing_controllers_1 = require("routing-controllers");
-function startContainer() {
-    (0, routing_controllers_1.useContainer)(di_container_1.diContainer);
+import { diContainer } from "./di-container";
+import { useContainer } from "routing-controllers";
+export function startContainer() {
+    useContainer(diContainer);
 }
-var di_container_2 = require("./di-container");
-Object.defineProperty(exports, "diContainer", { enumerable: true, get: function () { return di_container_2.diContainer; } });
+export { diContainer } from "./di-container";

package/setup/index.js

@@ -1,42 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeApi = initializeApi;
-exports.synthesizePaths = synthesizePaths;
-const arch_1 = require("@atlantjs/arch");
-const env_vars_1 = require("../backend/application/env/env-vars");
-const dependency_injections_1 = require("./dependency-injections");
-const server_1 = require("./server/server");
-function initializeApi(props) {
+import { _ } from "@atlantjs/arch";
+import { LOAD_MODULES } from "../backend/application/env/env-vars";
+import { diContainer, startContainer } from "./dependency-injections";
+import { Server } from "./server/server";
+export function initializeApi(props) {
     try {
         loadModules();
-        (0, dependency_injections_1.startContainer)();
-        if (arch_1._.isNotUndefined(props.databases)) {
+        startContainer();
+        if (_.isNotUndefined(props.databases)) {
             Promise.all([
                 props.databases.map((database) => {
-                    dependency_injections_1.diContainer.bind(database.token).toConstantValue(database.target);
+                    diContainer.bind(database.token).toConstantValue(database.target);
                     database.target.connect(new database.configs());
                 }),
             ]);
         }
-        server_1.Server.initialize();
+        Server.initialize();
     }
     catch (error) {
         console.error(`❌ Error occurred: ${error}`);
     }
 }
-function synthesizePaths() {
+export function synthesizePaths() {
     const moduleAlias = require("module-alias");
     const path = require("node:path");
     moduleAlias.addAlias("#", path.join(__dirname, "../../../../src"));
     moduleAlias.addAlias("!tests", path.join(__dirname, "../../../../tests"));
 }
-function loadModules(modules = env_vars_1.LOAD_MODULES) {
+function loadModules(modules = LOAD_MODULES) {
     let processedModules = modules;
     if (typeof modules === "string") {
         processedModules = modules
             .split(",")
             .map((x) => x.trim())
-            .filter((x) => arch_1._.isNotEmpty(x));
+            .filter((x) => x.isFilled());
     }
     console.log("\n📦 Loading modules...");
     for (const module of processedModules) {

package/setup/parchment/parchment.error.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PickEnvError = void 0;
-class PickEnvError extends Error {
+export class PickEnvError extends Error {
     constructor(variableName, variableDescription, messageError) {
         super(`\n❯ ${process.env.ENVIRONMENT} - ${messageError}:\n\n - ${variableName}: ${variableDescription}`);
     }
 }
-exports.PickEnvError = PickEnvError;

package/setup/parchment/parchment.js

@@ -1,56 +1,53 @@
-"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 {
+import { _ } from "@atlantjs/arch";
+import { PickEnvError } from "./parchment.error";
+export class Parchment {
     static verse({ ...verse }) {
         const setValue = process.env[verse.name] || verse.default?.toString();
-        if (arch_1._.isEmpty(setValue) && verse.isRequired.truthy()) {
-            throw new parchment_error_1.PickEnvError(verse.name, verse.description, "The environment variable must have its value defined");
+        if (_.isNullOrUndefined(setValue) && verse.isRequired.truthy()) {
+            throw new PickEnvError(verse.name, verse.description, "The environment variable must have its value defined");
         }
         return Parchment.convertSetValue(verse, setValue);
     }
     static convertSetValue(verse, value) {
-        if (arch_1._.isUndefined(value)) {
+        if (_.isUndefined(value)) {
             return undefined;
         }
         if (verse.type === "array") {
             return value.split(",");
         }
         if (verse.type === "boolean") {
-            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"`);
+            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"`);
             }
-            return arch_1._.isEqual(value, "true");
+            return _.isEqual(value, "true");
         }
         if (verse.type === "enum") {
-            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 (_.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 (verse.values.includes(value).falsy()) {
-                throw new parchment_error_1.PickEnvError(verse.name, verse.description, `A variável ${verse.name} deve conter algum dos seguintes valores: [${verse.values.join(", ")}]`);
+                throw new 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 parchment_error_1.PickEnvError(verse.name, verse.description, `The value of the environment variable ${verse.name} must be a valid float number`);
+                throw new 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 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`);
+                throw new 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 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`);
+                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`);
             }
             return portNumber;
         }
@@ -60,10 +57,11 @@ class Parchment {
         if (verse.type === "url-https") {
             const urlPattern = /^https?:\/\/[^\s/$.?#].[^\s]*$/i;
             if (!urlPattern.test(value)) {
-                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`);
+                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`);
             }
             return value;
         }
+        // If none of the types matched, return undefined
+        return undefined;
     }
 }
-exports.Parchment = Parchment;

package/setup/parchment/parchment.type.js

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

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

@@ -1,18 +1,10 @@
-"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,
-        });
-    }
+import bodyParser from "body-parser";
+export class BodyParserMiddleware {
+    plainTextEndpoints = ["/encrypted-webhook/notification"];
+    bodyParserJson = bodyParser.json({ limit: "50mb" });
+    bodyParserText = bodyParser.text({
+        type: () => true,
+    });
     static create() {
         const middleware = new BodyParserMiddleware();
         return (request, response, next) => middleware.use(request, response, next);
@@ -28,4 +20,3 @@ class BodyParserMiddleware {
         return this.plainTextEndpoints.some((endpoint) => url.startsWith(endpoint));
     }
 }
-exports.BodyParserMiddleware = BodyParserMiddleware;

package/setup/server/cors-middleware.js

@@ -1,20 +1,15 @@
-"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 {
+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,
+    });
     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) {
+    static create(corsSpecs = CORS_ALLOWED_ORIGINS) {
         const middleware = new CorsMiddleware(corsSpecs);
         return (request, response, next) => middleware.use(request, response, next);
     }
@@ -35,4 +30,3 @@ class CorsMiddleware {
         return new RegExp(pattern, flags);
     }
 }
-exports.CorsMiddleware = CorsMiddleware;

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

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

package/setup/server/server.js

@@ -1,18 +1,12 @@
-"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");
+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";
 var LogMessage;
 (function (LogMessage) {
     LogMessage["$start_server"] = "\n\uD83D\uDDA5\uFE0F  Starting server...";
@@ -21,20 +15,29 @@ var LogMessage;
     LogMessage["$line"] = "========================================";
     LogMessage["$development_message"] = "\uD83D\uDE80  You are in the development environment\n              Ready to code!";
 })(LogMessage || (LogMessage = {}));
-class Server {
+export class Server {
+    static instance = express();
+    static routingOptions = {
+        validation: true,
+        classTransformer: true,
+        plainToClassTransformOptions: {
+            enableImplicitConversion: false,
+        },
+        defaultErrorHandler: true,
+    };
     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.useExpressServer)(Server.instance, Server.routingOptions);
+        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);
         console.info(LogMessage.$start_server);
-        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.instance.listen(APP_PORT, () => {
+            console.info(LogMessage.$started_server + APP_PORT);
+            if (_.isEqual(ENVIRONMENT, NodeEnvs.development)) {
                 Server.logFooterDevelopmentMessage();
             }
         });
@@ -46,13 +49,3 @@ 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.d.ts

@@ -6,6 +6,6 @@ export declare class UnknownError {
     readonly unknownCode: string;
     readonly unknownMessage: string;
     constructor(error: UnknownApplicationError);
-    toPlain(): unknown;
+    toPolygon(): unknown;
 }
 export {};

package/setup/server/unknow.error.js

@@ -1,4 +1,3 @@
-"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);
@@ -8,24 +7,23 @@ 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);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownError = void 0;
-const class_transformer_1 = require("class-transformer");
-class UnknownError {
+import { Expose, instanceToPlain } from "class-transformer";
+export class UnknownError {
+    unknownCode;
+    unknownMessage;
     constructor(error) {
         this.unknownCode = error.code;
         this.unknownMessage = error.message;
     }
-    toPlain() {
-        return (0, class_transformer_1.instanceToPlain)(this);
+    toPolygon() {
+        return instanceToPlain(this);
     }
 }
-exports.UnknownError = UnknownError;
 __decorate([
-    (0, class_transformer_1.Expose)(),
+    Expose(),
     __metadata("design:type", String)
 ], UnknownError.prototype, "unknownCode", void 0);
 __decorate([
-    (0, class_transformer_1.Expose)(),
+    Expose(),
     __metadata("design:type", String)
 ], UnknownError.prototype, "unknownMessage", void 0);