@atlantjs/backend 5.1.0 → 6.0.0

package/README.md

@@ -1,8 +0,0 @@
-# String Utils
-
-## Install
-
-```
-npm install @atlantjs/string-utils
-yarn add @atlantjs/string-utils
-```

package/backend/application/databases/database-lite.config.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseLiteConfigAbstract = void 0;
-const typeorm_1 = require("typeorm");
-const env_vars_1 = require("../env/env-vars");
-class DatabaseLiteConfigAbstract {
+import { DataSource } from "typeorm";
+import { DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED } from "../env/env-vars";
+export class DatabaseLiteConfigAbstract {
+    props;
+    configs;
     constructor(props) {
         this.props = props;
         const baseConfig = {
             type: this.props.type,
             database: this.props.binaryFilePath,
-            synchronize: env_vars_1.DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED,
+            synchronize: DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED,
             extra: {
                 cipher: "aes-256-cbc",
                 key: props.accessKey,
@@ -17,7 +16,6 @@ class DatabaseLiteConfigAbstract {
             entities: props.schemaPaths,
             migrations: props.migrationPaths,
         };
-        this.configs = new typeorm_1.DataSource(baseConfig);
+        this.configs = new DataSource(baseConfig);
     }
 }
-exports.DatabaseLiteConfigAbstract = DatabaseLiteConfigAbstract;

package/backend/application/databases/database.config.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseConfigAbstract = void 0;
-const arch_1 = require("@atlantjs/arch");
-const typeorm_1 = require("typeorm");
-const env_vars_1 = require("../env/env-vars");
-class DatabaseConfigAbstract {
+import { _ } from "@atlantjs/arch";
+import { DataSource } from "typeorm";
+import { DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED, DATABASE_SSL_ENABLED, } from "../env/env-vars";
+export class DatabaseConfigAbstract {
+    props;
+    configs;
+    sslConfig = {
+        ssl: true,
+        extra: {
+            ssl: {
+                rejectUnauthorized: false,
+            },
+        },
+    };
     constructor(props) {
         this.props = props;
-        this.sslConfig = {
-            ssl: true,
-            extra: {
-                ssl: {
-                    rejectUnauthorized: false,
-                },
-            },
-        };
         const baseConfig = {
             type: this.props.type,
             host: this.props.host,
@@ -23,21 +22,20 @@ class DatabaseConfigAbstract {
             password: this.props.adminPassword,
             database: this.props.name,
             schema: this.props.schemaName,
-            synchronize: env_vars_1.DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED,
+            synchronize: DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED,
             entities: this.props.schemaPaths,
             migrations: this.props.migrationPaths,
         };
-        if (arch_1._.isEqual(this.props.type, "aurora-mysql")) {
+        if (_.isEqual(this.props.type, "aurora-mysql")) {
             Object.assign(baseConfig, {
                 region: this.props.region ?? "",
                 secretArn: this.props.secretArn ?? "",
                 resourceArn: this.props.resourceArn ?? "",
             });
         }
-        if (env_vars_1.DATABASE_SSL_ENABLED) {
+        if (DATABASE_SSL_ENABLED) {
             Object.assign(baseConfig, this.sslConfig);
         }
-        this.configs = new typeorm_1.DataSource(baseConfig);
+        this.configs = new DataSource(baseConfig);
     }
 }
-exports.DatabaseConfigAbstract = DatabaseConfigAbstract;

package/backend/application/databases/database.helper.abstract.commit.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "@atlantjs/arch";
-export declare class DatabaseHelperAbstractCommitFailure extends FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractCommitFailure extends FailureSketchEdge {
     constructor(error?: any);
 }

package/backend/application/databases/database.helper.abstract.commit.failure.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstractCommitFailure = void 0;
-const arch_1 = require("@atlantjs/arch");
-class DatabaseHelperAbstractCommitFailure extends arch_1.FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export class DatabaseHelperAbstractCommitFailure extends FailureSketchEdge {
     constructor(error) {
         super({
-            className: DatabaseHelperAbstractCommitFailure.name,
+            failureClass: DatabaseHelperAbstractCommitFailure,
             message: "Transaction is not open. Run '.openTransaction()' before commit",
-            error,
+            stackTrace: error,
         });
     }
 }
-exports.DatabaseHelperAbstractCommitFailure = DatabaseHelperAbstractCommitFailure;

package/backend/application/databases/database.helper.abstract.d.ts

@@ -1,15 +1,15 @@
-import { FailureAbstract, Newable, Optional, Return } from "@atlantjs/arch";
+import { FailureSketchEdge, Newable, Optional, Return } from "@atlantjs/arch";
 import { DataSource, EntityTarget, FindOptionsRelations, ObjectLiteral } from "typeorm";
 import { DatabaseLiteConfigAbstract } from "./database-lite.config";
 import { DatabaseConfigAbstract } from "./database.config";
-import { EntityAbstract } from "../../domain/entities/entity.abstract";
-interface SchemaEntity {
-    schema: EntityTarget<ObjectLiteral>;
-    entity: EntityAbstract;
-    unique?: keyof EntityAbstract;
+import { SolidAbstract } from "../../domain/objects/solid.abstract";
+import { VertexAbstract } from "../../domain/objects/vertices/vertex.abstract";
+interface FaceEntity {
+    face: EntityTarget<ObjectLiteral>;
+    entity: SolidAbstract | VertexAbstract;
 }
-interface SchemaEntityReturn {
-    schema: EntityTarget<ObjectLiteral>;
+interface FaceEntityReturn {
+    face: EntityTarget<ObjectLiteral>;
     id: string;
 }
 export declare abstract class DatabaseHelperAbstract {
@@ -17,13 +17,13 @@ export declare abstract class DatabaseHelperAbstract {
     private queryRunner;
     connect(db: DatabaseConfigAbstract | DatabaseLiteConfigAbstract): Promise<DataSource>;
     disconnect(): Promise<void>;
-    read<T extends Newable<ObjectLiteral>, E extends ObjectLiteral>(schema: T, condition: {
+    read<T extends Newable<ObjectLiteral>, E extends ObjectLiteral>(face: T, condition: {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
-    }, relations: FindOptionsRelations<E>): Promise<Return<Optional<InstanceType<T>[]>, FailureAbstract>>;
-    write(schemaEntities: SchemaEntity[]): Promise<Return<SchemaEntityReturn[], FailureAbstract>>;
+    }, relations: FindOptionsRelations<E>): Promise<Return<Optional<InstanceType<T>[]>, FailureSketchEdge>>;
+    write(faceEntities: FaceEntity[]): Promise<Return<FaceEntityReturn[], FailureSketchEdge>>;
     delete<T extends Newable<ObjectLiteral>>(schema: T, condition: {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
-    }, isSoft?: boolean): Promise<Return<undefined, FailureAbstract>>;
+    }, isSoft?: boolean): Promise<Return<undefined, FailureSketchEdge>>;
     private getManager;
     private openTransaction;
     private commit;

package/backend/application/databases/database.helper.abstract.delete.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "@atlantjs/arch";
-export declare class DatabaseHelperAbstractDeleteFailure extends FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractDeleteFailure extends FailureSketchEdge {
     constructor(isSoft: boolean, error?: any);
 }

package/backend/application/databases/database.helper.abstract.delete.failure.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstractDeleteFailure = void 0;
-const arch_1 = require("@atlantjs/arch");
-class DatabaseHelperAbstractDeleteFailure extends arch_1.FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export class DatabaseHelperAbstractDeleteFailure extends FailureSketchEdge {
     constructor(isSoft, error) {
         super({
-            className: DatabaseHelperAbstractDeleteFailure.name,
-            message: `Failed to ${arch_1._.isTruthy(isSoft) ? "soft" : "hard"} delete the record in the database`,
-            error,
+            failureClass: DatabaseHelperAbstractDeleteFailure,
+            message: `Failed to ${isSoft.truthy() ? "soft" : "hard"} delete the record in the database`,
+            stackTrace: error,
         });
     }
 }
-exports.DatabaseHelperAbstractDeleteFailure = DatabaseHelperAbstractDeleteFailure;

package/backend/application/databases/database.helper.abstract.get-manager.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "@atlantjs/arch";
-export declare class DatabaseHelperAbstractGetManagerFailure extends FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractGetManagerFailure extends FailureSketchEdge {
     constructor(error?: any);
 }

package/backend/application/databases/database.helper.abstract.get-manager.failure.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstractGetManagerFailure = void 0;
-const arch_1 = require("@atlantjs/arch");
-class DatabaseHelperAbstractGetManagerFailure extends arch_1.FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export class DatabaseHelperAbstractGetManagerFailure extends FailureSketchEdge {
     constructor(error) {
         super({
-            className: DatabaseHelperAbstractGetManagerFailure.name,
+            failureClass: DatabaseHelperAbstractGetManagerFailure,
             message: "The database is not connected",
-            error,
+            stackTrace: error,
         });
     }
 }
-exports.DatabaseHelperAbstractGetManagerFailure = DatabaseHelperAbstractGetManagerFailure;

package/backend/application/databases/database.helper.abstract.js

@@ -1,103 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstract = void 0;
-const arch_1 = require("@atlantjs/arch");
-const database_helper_abstract_commit_failure_1 = require("./database.helper.abstract.commit.failure");
-const database_helper_abstract_delete_failure_1 = require("./database.helper.abstract.delete.failure");
-const database_helper_abstract_get_manager_failure_1 = require("./database.helper.abstract.get-manager.failure");
-const database_helper_abstract_rollback_failure_1 = require("./database.helper.abstract.rollback.failure");
-const database_helper_abstract_write_failure_1 = require("./database.helper.abstract.write.failure");
-class DatabaseHelperAbstract {
-    constructor() {
-        this.database = arch_1.Nothing;
-        this.queryRunner = arch_1.Nothing;
-    }
+import { Failure, Nothing, Optional, Success, _, } from "@atlantjs/arch";
+import { DatabaseHelperAbstractCommitFailure } from "./database.helper.abstract.commit.failure";
+import { DatabaseHelperAbstractDeleteFailure } from "./database.helper.abstract.delete.failure";
+import { DatabaseHelperAbstractGetManagerFailure } from "./database.helper.abstract.get-manager.failure";
+import { DatabaseHelperAbstractRollbackFailure } from "./database.helper.abstract.rollback.failure";
+import { DatabaseHelperAbstractWriteFailure } from "./database.helper.abstract.write.failure";
+export class DatabaseHelperAbstract {
+    database = Nothing;
+    queryRunner = Nothing;
     async connect(db) {
-        this.database = (0, arch_1.Optional)(db.configs);
+        this.database = Optional(db.configs);
         await this.database.unpack().initialize();
         return this.database.unpack();
     }
     async disconnect() {
         await this.database.unpack().destroy();
-        this.database = arch_1.Nothing;
+        this.database = Nothing;
     }
-    async read(schema, condition, relations) {
+    async read(face, condition, relations) {
         const clientWrapped = this.getManager();
         if (clientWrapped.hasFailure())
-            return (0, arch_1.Failure)(clientWrapped.unwrapFail());
+            return Failure(clientWrapped.unwrapFail());
         const client = clientWrapped.unwrap();
-        const repository = client.getRepository(schema);
-        const registryPacked = (0, arch_1.Optional)((await repository.find({
+        const repository = client.getRepository(face);
+        const registryPacked = Optional((await repository.find({
             where: { ...condition, deleted: false },
             relations,
         })));
         if (relations && registryPacked.hasSomething()) {
-            const filterDeletedRelations = (schema, rels) => {
-                if (!schema || typeof schema !== "object" || !rels)
+            const filterDeletedRelations = (face, rels) => {
+                if (!face || typeof face !== "object" || !rels)
                     return;
                 for (const rel of rels) {
-                    const relValue = schema[rel];
+                    const relValue = face[rel];
                     if (Array.isArray(relValue)) {
-                        schema[rel] = relValue.filter((item) => !item?.deleted);
+                        face[rel] = relValue.filter((item) => !item?.deleted);
                     }
                     else if (relValue.deleted) {
-                        schema[rel] = undefined;
+                        face[rel] = undefined;
                     }
                 }
             };
-            for (const schemas of registryPacked.unpack()) {
-                filterDeletedRelations(schemas, relations);
+            for (const faces of registryPacked.unpack()) {
+                filterDeletedRelations(faces, relations);
             }
         }
-        return (0, arch_1.Success)(registryPacked);
+        return Success(registryPacked);
     }
-    async write(schemaEntities) {
+    async write(faceEntities) {
         try {
             const client = await this.openTransaction();
             const ids = [];
-            for (const schemaEntity of schemaEntities) {
-                const repository = client.getRepository(schemaEntity.schema);
-                if (arch_1._.isUndefined(schemaEntity.entity.toSchema) ||
-                    arch_1._.isUndefined(schemaEntity.entity.id)) {
-                    return (0, arch_1.Failure)(new database_helper_abstract_write_failure_1.DatabaseHelperAbstractWriteFailure());
+            for (const faceEntity of faceEntities) {
+                const repository = client.getRepository(faceEntity.face);
+                if (_.isUndefined(faceEntity.entity.toSeal) ||
+                    _.isUndefined(faceEntity.entity.id)) {
+                    return Failure(new DatabaseHelperAbstractWriteFailure());
                 }
-                const uniqueColumnName = schemaEntity.unique ?? "id";
-                const uniqueColumnValue = arch_1._.isNotUndefined(schemaEntity.unique)
-                    ? String(schemaEntity.entity[schemaEntity.unique])
-                    : schemaEntity.entity.id.toString();
-                const registryFoundedPacked = (0, arch_1.Optional)(await repository.findOne({
+                const registryFoundedPacked = Optional(await repository.findOne({
                     where: {
-                        [uniqueColumnName]: uniqueColumnValue,
+                        id: faceEntity.entity.id.toString(),
                     },
                 }));
                 if (registryFoundedPacked.hasNothing()) {
-                    await repository.save(schemaEntity.entity.toSchema());
+                    await repository.save(faceEntity.entity.toSeal());
                 }
                 else {
-                    await repository.update({ id: schemaEntity.entity.id.toString() }, schemaEntity.entity.toSchema());
+                    await repository.update({ id: faceEntity.entity.id.toString() }, faceEntity.entity.toSeal());
                 }
                 ids.push({
-                    schema: schemaEntity.schema,
-                    id: schemaEntity.entity.id.toString(),
+                    face: faceEntity.face,
+                    id: faceEntity.entity.id.toString(),
                 });
             }
             await this.commit();
-            return (0, arch_1.Success)(ids);
+            return Success(ids);
         }
         catch (error) {
             await this.rollback();
-            return (0, arch_1.Failure)(new database_helper_abstract_write_failure_1.DatabaseHelperAbstractWriteFailure(error));
+            return Failure(new DatabaseHelperAbstractWriteFailure(error));
         }
     }
     async delete(schema, condition, isSoft = true) {
         try {
             const client = await this.openTransaction();
             const repository = client.getRepository(schema);
-            const registriesPacked = (0, arch_1.Optional)(await repository.find({ where: condition }));
+            const registriesPacked = Optional(await repository.find({ where: condition }));
             if (registriesPacked.hasNothing()) {
-                return (0, arch_1.Failure)(new database_helper_abstract_delete_failure_1.DatabaseHelperAbstractDeleteFailure(isSoft));
+                return Failure(new DatabaseHelperAbstractDeleteFailure(isSoft));
             }
-            if (arch_1._.isFalsy(isSoft)) {
+            if (isSoft.falsy()) {
                 repository.delete(condition);
             }
             else {
@@ -108,22 +99,22 @@ class DatabaseHelperAbstract {
                 }
             }
             await this.commit();
-            return (0, arch_1.Success)();
+            return Success();
         }
         catch (error) {
             await this.rollback();
-            return (0, arch_1.Failure)(new database_helper_abstract_delete_failure_1.DatabaseHelperAbstractDeleteFailure(isSoft, error));
+            return Failure(new DatabaseHelperAbstractDeleteFailure(isSoft, error));
         }
     }
     getManager() {
         if (this.database.hasNothing()) {
-            return (0, arch_1.Failure)(new database_helper_abstract_get_manager_failure_1.DatabaseHelperAbstractGetManagerFailure());
+            return Failure(new DatabaseHelperAbstractGetManagerFailure());
         }
-        return (0, arch_1.Success)(this.database.unpack().manager);
+        return Success(this.database.unpack().manager);
     }
     async openTransaction() {
         if (this.queryRunner.hasNothing()) {
-            this.queryRunner = (0, arch_1.Optional)(this.database.unpack().createQueryRunner());
+            this.queryRunner = Optional(this.database.unpack().createQueryRunner());
             await this.queryRunner.unpack().connect();
             await this.queryRunner.unpack().startTransaction();
         }
@@ -131,21 +122,20 @@ class DatabaseHelperAbstract {
     }
     async commit() {
         if (this.queryRunner.hasNothing()) {
-            return (0, arch_1.Failure)(new database_helper_abstract_commit_failure_1.DatabaseHelperAbstractCommitFailure());
+            return Failure(new DatabaseHelperAbstractCommitFailure());
         }
         await this.queryRunner.unpack().commitTransaction();
         await this.queryRunner.unpack().release();
-        this.queryRunner = arch_1.Nothing;
-        return (0, arch_1.Success)();
+        this.queryRunner = Nothing;
+        return Success();
     }
     async rollback() {
         if (this.queryRunner.hasNothing()) {
-            return (0, arch_1.Failure)(new database_helper_abstract_rollback_failure_1.DatabaseHelperAbstractRollbackFailure());
+            return Failure(new DatabaseHelperAbstractRollbackFailure());
         }
         await this.queryRunner.unpack().rollbackTransaction();
         await this.queryRunner.unpack().release();
-        this.queryRunner = arch_1.Nothing;
-        return (0, arch_1.Success)();
+        this.queryRunner = Nothing;
+        return Success();
     }
 }
-exports.DatabaseHelperAbstract = DatabaseHelperAbstract;

package/backend/application/databases/database.helper.abstract.rollback.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "@atlantjs/arch";
-export declare class DatabaseHelperAbstractRollbackFailure extends FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractRollbackFailure extends FailureSketchEdge {
     constructor(error?: any);
 }

package/backend/application/databases/database.helper.abstract.rollback.failure.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstractRollbackFailure = void 0;
-const arch_1 = require("@atlantjs/arch");
-class DatabaseHelperAbstractRollbackFailure extends arch_1.FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export class DatabaseHelperAbstractRollbackFailure extends FailureSketchEdge {
     constructor(error) {
         super({
-            className: DatabaseHelperAbstractRollbackFailure.name,
+            failureClass: DatabaseHelperAbstractRollbackFailure,
             message: "Transaction is not open. Run '.openTransaction()' before commit",
-            error,
+            stackTrace: error,
         });
     }
 }
-exports.DatabaseHelperAbstractRollbackFailure = DatabaseHelperAbstractRollbackFailure;

package/backend/application/databases/database.helper.abstract.write.failure.d.ts

@@ -1,4 +1,4 @@
-import { FailureAbstract } from "@atlantjs/arch";
-export declare class DatabaseHelperAbstractWriteFailure extends FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export declare class DatabaseHelperAbstractWriteFailure extends FailureSketchEdge {
     constructor(error?: any);
 }

package/backend/application/databases/database.helper.abstract.write.failure.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseHelperAbstractWriteFailure = void 0;
-const arch_1 = require("@atlantjs/arch");
-class DatabaseHelperAbstractWriteFailure extends arch_1.FailureAbstract {
+import { FailureSketchEdge } from "@atlantjs/arch";
+export class DatabaseHelperAbstractWriteFailure extends FailureSketchEdge {
     constructor(error) {
         super({
-            className: DatabaseHelperAbstractWriteFailure.name,
+            failureClass: DatabaseHelperAbstractWriteFailure,
             message: "Failed to insert or update the record in the database",
-            error,
+            stackTrace: error,
         });
     }
 }
-exports.DatabaseHelperAbstractWriteFailure = DatabaseHelperAbstractWriteFailure;

package/backend/application/env/env-vars.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVIRONMENT = exports.CORS_ALLOWED_ORIGINS = exports.LOAD_MODULES = exports.APP_PORT = exports.DATABASE_SSL_ENABLED = exports.DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED = exports.DATABASE_ADMIN_USER = exports.DATABASE_PORT = exports.DATABASE_ADMIN_PASSWORD = exports.DATABASE_HOST = exports.DATABASE_DEFAULT_SCHEMA = exports.DATABASE_NAME = exports.DATABASE_TYPE = void 0;
-const arch_1 = require("@atlantjs/arch");
-const parchment_1 = require("../../../setup/parchment/parchment");
-exports.DATABASE_TYPE = parchment_1.Parchment.verse({
+import { NodeEnvs } from "@atlantjs/arch";
+import { Parchment } from "../../../setup/parchment/parchment";
+export const DATABASE_TYPE = Parchment.verse({
     name: "DATABASE_TYPE",
     type: "enum",
     description: "The type of the database",
@@ -11,82 +8,82 @@ exports.DATABASE_TYPE = parchment_1.Parchment.verse({
     values: ["aurora-postgres", "postgres", "sqlite"],
     isRequired: true,
 });
-exports.DATABASE_NAME = parchment_1.Parchment.verse({
+export const DATABASE_NAME = Parchment.verse({
     name: "DATABASE_NAME",
     type: "text",
     description: "The name of the database",
     isRequired: true,
 });
-exports.DATABASE_DEFAULT_SCHEMA = parchment_1.Parchment.verse({
+export const DATABASE_DEFAULT_SCHEMA = Parchment.verse({
     name: "DATABASE_DEFAULT_SCHEMA",
     type: "text",
     description: "The name of default schema the database",
     isRequired: true,
 });
-exports.DATABASE_HOST = parchment_1.Parchment.verse({
+export const DATABASE_HOST = Parchment.verse({
     name: "DATABASE_HOST",
     description: "The host address of the database server",
     type: "text",
     isRequired: true,
 });
-exports.DATABASE_ADMIN_PASSWORD = parchment_1.Parchment.verse({
+export const DATABASE_ADMIN_PASSWORD = Parchment.verse({
     name: "DATABASE_ADMIN_PASSWORD",
     description: "The password for the database user",
     type: "text",
     isRequired: true,
 });
-exports.DATABASE_PORT = parchment_1.Parchment.verse({
+export const DATABASE_PORT = Parchment.verse({
     name: "DATABASE_PORT",
     type: "port-number",
     description: "The port number on which the database server is running",
     isRequired: true,
 });
-exports.DATABASE_ADMIN_USER = parchment_1.Parchment.verse({
+export const DATABASE_ADMIN_USER = Parchment.verse({
     name: "DATABASE_ADMIN_USER",
     description: "The username for the database database",
     type: "text",
     isRequired: true,
 });
-exports.DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED = parchment_1.Parchment.verse({
+export const DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED = Parchment.verse({
     name: "DATABASE_AUTOMATICALLY_CREATE_TABLES_ENABLED",
     type: "boolean",
     description: "Flag indicating whether the ORM automatically creates tables in the database based on .schema.ts files",
     isRequired: true,
 });
-exports.DATABASE_SSL_ENABLED = parchment_1.Parchment.verse({
+export const DATABASE_SSL_ENABLED = Parchment.verse({
     name: "DATABASE_SSL_ENABLED",
     type: "boolean",
     description: "Flag indicating whether the database requires an SSL connection",
     isRequired: true,
 });
-exports.APP_PORT = parchment_1.Parchment.verse({
+export const APP_PORT = Parchment.verse({
     name: "APP_PORT",
     type: "port-number",
     description: "The port number on which the application will run",
     isRequired: true,
 });
-exports.LOAD_MODULES = parchment_1.Parchment.verse({
+export const LOAD_MODULES = Parchment.verse({
     name: "LOAD_MODULES",
     type: "array",
     description: "List of modules, separated by commas, to be loaded by the application",
     isRequired: true,
 });
-exports.CORS_ALLOWED_ORIGINS = parchment_1.Parchment.verse({
+export const CORS_ALLOWED_ORIGINS = Parchment.verse({
     name: "CORS_ALLOWED_ORIGINS",
     default: "*",
     description: "Allowed origins for CORS",
     type: "text",
     isRequired: true,
 });
-exports.ENVIRONMENT = parchment_1.Parchment.verse({
+export const ENVIRONMENT = Parchment.verse({
     name: "ENVIRONMENT",
     type: "enum",
     isRequired: true,
     values: [
-        arch_1.NodeEnvs.test,
-        arch_1.NodeEnvs.development,
-        arch_1.NodeEnvs.production,
-        arch_1.NodeEnvs.homolog,
+        NodeEnvs.test,
+        NodeEnvs.development,
+        NodeEnvs.production,
+        NodeEnvs.homolog,
     ],
     description: "The current environment in which the application is running",
 });

package/backend/application/env/load-envs.js

@@ -1,14 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const arch_1 = require("@atlantjs/arch");
-const dotenv_1 = __importDefault(require("dotenv"));
-const envFilePath = node_path_1.default.join(__dirname, "..", "..", "..", "..", "..", "..", process.env.ENVIRONMENT === arch_1.NodeEnvs.test ? ".env.test" : ".env");
-if (!node_fs_1.default.existsSync(envFilePath)) {
-    console.error(`The ${process.env.ENVIRONMENT === arch_1.NodeEnvs.test ? ".env.test" : ".env"} file is missing with the variables and their values`);
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { NodeEnvs } from "@atlantjs/arch";
+import * as dotenv from "dotenv";
+const envFilePath = path.join(__dirname, "..", "..", "..", "..", "..", "..", process.env.ENVIRONMENT === NodeEnvs.test ? ".env.test" : ".env");
+if (!fs.existsSync(envFilePath)) {
+    console.error(`The ${process.env.ENVIRONMENT === NodeEnvs.test ? ".env.test" : ".env"} file is missing with the variables and their values`);
 }
-dotenv_1.default.config({ path: envFilePath });
+dotenv.config({ path: envFilePath });