@atlantjs/arch 3.1.0 → 3.1.1

package/arch/modules/application/databases/database.config.d.ts

@@ -0,0 +1,19 @@
+import { DataSource, DatabaseType } from "typeorm";
+interface DatabaseConfigProps {
+    type: DatabaseType;
+    host: string;
+    port: number;
+    username: string;
+    password: string;
+    database: string;
+    region?: string;
+    secretArn?: string;
+    resourceArn?: string;
+}
+export declare abstract class DatabaseConfigAbstract {
+    private readonly props;
+    configs: DataSource;
+    private productionOrHomologConfigs;
+    constructor(props: DatabaseConfigProps);
+}
+export {};

package/arch/modules/application/databases/database.config.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseConfigAbstract = void 0;
+const typeorm_1 = require("typeorm");
+const guardian_1 = require("../../../../@tool-box/utils/type-guard/guardian");
+const env_vars_1 = require("../../../../setup/env/env-vars");
+class DatabaseConfigAbstract {
+    constructor(props) {
+        this.props = props;
+        this.productionOrHomologConfigs = {
+            ssl: true,
+            extra: {
+                ssl: {
+                    rejectUnauthorized: false,
+                },
+            },
+        };
+        const baseConfig = {
+            type: this.props.type,
+            host: this.props.host,
+            port: this.props.port,
+            username: this.props.username,
+            password: this.props.password,
+            database: this.props.database,
+            synchronize: guardian_1.Guardian.isFalsy((0, env_vars_1.isProdOrHomolog)()),
+            entities: [`${__dirname}/../../**/*.entity{.ts,.js}`],
+            migrations: ["./migrations/*.ts"],
+        };
+        if (guardian_1.Guardian.isEqual(this.props.type, "aurora-mysql")) {
+            Object.assign(baseConfig, {
+                region: this.props.region ?? "",
+                secretArn: this.props.secretArn ?? "",
+                resourceArn: this.props.resourceArn ?? "",
+            });
+        }
+        if (this.props.host.indexOf("localhost") < 0) {
+            Object.assign(baseConfig, this.productionOrHomologConfigs);
+        }
+        this.configs = new typeorm_1.DataSource(baseConfig);
+    }
+}
+exports.DatabaseConfigAbstract = DatabaseConfigAbstract;

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

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "../failures/failure.abstract";
+export declare class DatabaseHelperAbstractCommitFailure extends FailureAbstract {
+    constructor(error?: any);
+}

package/arch/modules/application/databases/database.helper.abstract.commit.failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractCommitFailure = void 0;
+const failure_abstract_1 = require("../failures/failure.abstract");
+class DatabaseHelperAbstractCommitFailure extends failure_abstract_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractCommitFailure.name,
+            message: "Transaction is not open",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractCommitFailure = DatabaseHelperAbstractCommitFailure;

package/arch/modules/application/databases/database.helper.abstract.d.ts

@@ -1,4 +1,19 @@
+import { DataSource, EntityManager } from "typeorm";
+import { Return } from "../../../../@tool-box/utils/ducts/return-type";
+import { DatabaseConfigAbstract } from "./database.config";
+import { FailureAbstract } from "../failures/failure.abstract";
+import { SolidAbstract } from "../../domain/solid.abstract";
+import { EntityAbstract } from "../../infrastructure/repositories/entities/entity.abstract";
 export declare abstract class DatabaseHelperAbstract {
-    abstract connect(): Promise<void>;
-    abstract disconnect(): Promise<void>;
+    private database;
+    private queryRunner;
+    connect(db: DatabaseConfigAbstract): Promise<DataSource>;
+    disconnect(): Promise<void>;
+    abstract read<T extends EntityAbstract>(entity: T, condition: any): T;
+    abstract write<T extends EntityAbstract>(entity: T, data: SolidAbstract): unknown;
+    abstract delete<T extends EntityAbstract>(entity: T, condition: any): unknown;
+    protected getManager(): Return<EntityManager, FailureAbstract>;
+    protected openTransaction(): Promise<EntityManager>;
+    protected commit(): Promise<Return<undefined, FailureAbstract>>;
+    protected rollback(): Promise<Return<undefined, FailureAbstract>>;
 }

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

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "../failures/failure.abstract";
+export declare class DatabaseHelperAbstractGetManagerFailure extends FailureAbstract {
+    constructor(error?: any);
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractGetManagerFailure = void 0;
+const failure_abstract_1 = require("../failures/failure.abstract");
+class DatabaseHelperAbstractGetManagerFailure extends failure_abstract_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractGetManagerFailure.name,
+            message: "The database is not connected",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractGetManagerFailure = DatabaseHelperAbstractGetManagerFailure;

package/arch/modules/application/databases/database.helper.abstract.js

@@ -1,6 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseHelperAbstract = void 0;
+const optional_type_1 = require("../../../../@tool-box/utils/ducts/optional-type");
+const return_type_1 = require("../../../../@tool-box/utils/ducts/return-type");
+const database_helper_abstract_commit_failure_1 = require("./database.helper.abstract.commit.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");
 class DatabaseHelperAbstract {
+    constructor() {
+        this.database = optional_type_1.Nothing;
+        this.queryRunner = optional_type_1.Nothing;
+    }
+    async connect(db) {
+        this.database = (0, optional_type_1.Optional)(db.configs);
+        await this.database.unpack().initialize();
+        return this.database.unpack();
+    }
+    async disconnect() {
+        await this.database.unpack().destroy();
+        this.database = optional_type_1.Nothing;
+    }
+    getManager() {
+        if (this.database.hasNothing()) {
+            return (0, return_type_1.Failure)(new database_helper_abstract_get_manager_failure_1.DatabaseHelperAbstractGetManagerFailure());
+        }
+        return (0, return_type_1.Success)(this.database.unpack().manager);
+    }
+    async openTransaction() {
+        if (this.queryRunner.hasNothing()) {
+            this.queryRunner = (0, optional_type_1.Optional)(this.database.unpack().createQueryRunner());
+            await this.queryRunner.unpack().connect();
+            await this.queryRunner.unpack().startTransaction();
+        }
+        return this.queryRunner.unpack().manager;
+    }
+    async commit() {
+        if (this.queryRunner.hasNothing()) {
+            return (0, return_type_1.Failure)(new database_helper_abstract_commit_failure_1.DatabaseHelperAbstractCommitFailure());
+        }
+        await this.queryRunner.unpack().commitTransaction();
+        await this.queryRunner.unpack().release();
+        this.queryRunner = optional_type_1.Nothing;
+        return (0, return_type_1.Success)();
+    }
+    async rollback() {
+        if (this.queryRunner.hasNothing()) {
+            return (0, return_type_1.Failure)(new database_helper_abstract_rollback_failure_1.DatabaseHelperAbstractRollbackFailure());
+        }
+        await this.queryRunner.unpack().rollbackTransaction();
+        await this.queryRunner.unpack().release();
+        this.queryRunner = optional_type_1.Nothing;
+        return (0, return_type_1.Success)();
+    }
 }
 exports.DatabaseHelperAbstract = DatabaseHelperAbstract;

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

@@ -0,0 +1,4 @@
+import { FailureAbstract } from "../failures/failure.abstract";
+export declare class DatabaseHelperAbstractRollbackFailure extends FailureAbstract {
+    constructor(error?: any);
+}

package/arch/modules/application/databases/database.helper.abstract.rollback.failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseHelperAbstractRollbackFailure = void 0;
+const failure_abstract_1 = require("../failures/failure.abstract");
+class DatabaseHelperAbstractRollbackFailure extends failure_abstract_1.FailureAbstract {
+    constructor(error) {
+        super({
+            className: DatabaseHelperAbstractRollbackFailure.name,
+            message: "Transaction is not open",
+            error,
+        });
+    }
+}
+exports.DatabaseHelperAbstractRollbackFailure = DatabaseHelperAbstractRollbackFailure;

package/arch/modules/infrastructure/repositories/entities/entity.abstract.d.ts

@@ -1,6 +1,9 @@
 import { SolidAbstract } from "../../../domain/solid.abstract";
-export declare abstract class EntityAbstract {
+import { BaseEntity } from "typeorm";
+export declare abstract class EntityAbstract extends BaseEntity {
     createdAt: Date;
     updatedAt: Date;
     abstract toSolid(): SolidAbstract;
+    protected beforeInsert(): void;
+    protected beforeUpdate(): void;
 }

package/arch/modules/infrastructure/repositories/entities/entity.abstract.js

@@ -1,6 +1,43 @@
 "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);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.EntityAbstract = void 0;
-class EntityAbstract {
+const typeorm_1 = require("typeorm");
+class EntityAbstract extends typeorm_1.BaseEntity {
+    beforeInsert() {
+        this.createdAt = new Date(Date.now());
+        this.updatedAt = new Date(Date.now());
+    }
+    beforeUpdate() {
+        this.updatedAt = new Date(Date.now());
+    }
 }
 exports.EntityAbstract = EntityAbstract;
+__decorate([
+    (0, typeorm_1.Column)({ name: "createdAt", type: "date" }),
+    __metadata("design:type", Date)
+], EntityAbstract.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ name: "updatedAt", type: "date" }),
+    __metadata("design:type", Date)
+], EntityAbstract.prototype, "updatedAt", void 0);
+__decorate([
+    (0, typeorm_1.BeforeInsert)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], EntityAbstract.prototype, "beforeInsert", null);
+__decorate([
+    (0, typeorm_1.BeforeUpdate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], EntityAbstract.prototype, "beforeUpdate", null);

package/arch/modules/infrastructure/services/http-client.abstract.js

@@ -0,0 +1 @@
+"use strict";

package/arch/modules/infrastructure/services/payloads/service.payload.abstract.js

@@ -0,0 +1 @@
+"use strict";

package/arch/modules/infrastructure/services/responses/service.response.abstract.js

@@ -0,0 +1 @@
+"use strict";

package/index.d.ts

@@ -11,7 +11,6 @@ export { Success, Failure, Return } from "./@tool-box/utils/ducts/return-type";
 export { HttpClient } from "./@tool-box/utils/http-client/http-client";
 export { RandomValue } from "./@tool-box/utils/randoms/random-value";
 export { Guardian } from "./@tool-box/utils/type-guard/guardian";
-export { DatabaseFactoryAbstract } from "./arch/modules/application/databases/database.factory.abstract";
 export { DatabaseHelperAbstract } from "./arch/modules/application/databases/database.helper.abstract";
 export { FailureAbstract } from "./arch/modules/application/failures/failure.abstract";
 export { UnknownFailure } from "./arch/modules/application/failures/unknown-failure";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlantjs/arch",
-	"version": "3.1.0",
+	"version": "3.1.1",
 	"main": "index.js",
 	"license": "UNLICENSED",
 	"publishConfig": {
@@ -48,6 +48,7 @@
 		"module-alias": "^2.2.3",
 		"reflect-metadata": "^0.2.2",
 		"routing-controllers": "^0.10.4",
+		"typeorm": "^0.3.20",
 		"uuid": "^10.0.0"
 	},
 	"devDependencies": {

package/setup/index.d.ts

@@ -1,17 +1,16 @@
 import "reflect-metadata";
 import "./env/load-envs";
 import { Newable } from "../@tool-box/utils/datatypes/generic-types";
-import { DatabaseFactoryAbstract } from "../arch/modules/application/databases/database.factory.abstract";
+import { DatabaseConfigAbstract } from "../arch/modules/application/databases/database.config";
 import { DatabaseHelperAbstract } from "../arch/modules/application/databases/database.helper.abstract";
 interface ServerProps {
-    databases: [
+    databases?: [
         {
             ref: Newable<Symbol>;
-            target: Newable<DatabaseHelperAbstract>;
+            target: DatabaseHelperAbstract;
+            configs: DatabaseConfigAbstract;
         }
     ];
-    databaseFactories: DatabaseFactoryAbstract[];
-    databaseHelpers: DatabaseHelperAbstract[];
 }
 export declare function initializeApi(props: ServerProps): void;
 export {};

package/setup/index.js

@@ -12,13 +12,14 @@ function initializeApi(props) {
         initializeModules();
         (0, dependency_injections_1.startContainer)();
         server_1.Server.initialize();
-        Promise.all([
-            props.databases.map((database) => {
-                dependency_injections_1.diContainer.bind(database.ref).toConstantValue(database.target);
-            }),
-            props.databaseFactories.map((databaseFactory) => databaseFactory.create()),
-            props.databaseHelpers.map((databaseHelper) => databaseHelper.connect()),
-        ]);
+        if (guardian_1.Guardian.isNotUndefined(props.databases)) {
+            Promise.all([
+                props.databases.map((database) => {
+                    dependency_injections_1.diContainer.bind(database.ref).toConstantValue(database.target);
+                    database.target.connect(database.configs);
+                }),
+            ]);
+        }
     }
     catch (error) {
         console.error(`❌ Error occurred: ${error}`);