@atlantjs/backend 4.0.18 → 4.0.20

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

@@ -3,6 +3,14 @@ import { DataSource, FindOptionsRelations, ObjectLiteral } from "typeorm";
 import { DatabaseLiteConfigAbstract } from "./database-lite.config";
 import { DatabaseConfigAbstract } from "./database.config";
 import { EntityAbstract } from "../../domain/entities/entity.abstract";
+interface SchemaEntity<T> {
+    schema: T;
+    entity: EntityAbstract;
+}
+interface SchemaEntityReturn {
+    schema: string;
+    id: string;
+}
 export declare abstract class DatabaseHelperAbstract {
     private database;
     private queryRunner;
@@ -11,7 +19,7 @@ export declare abstract class DatabaseHelperAbstract {
     read<T extends Newable<ObjectLiteral>, E extends ObjectLiteral>(schema: T, condition: {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
     }, relations: FindOptionsRelations<E>): Promise<Return<Optional<InstanceType<T>[]>, FailureAbstract>>;
-    write<T extends Newable<ObjectLiteral>>(schema: T, entity: EntityAbstract): Promise<Return<undefined, undefined>>;
+    write<T extends Newable<ObjectLiteral>>(schemaEntities: SchemaEntity<T>[]): Promise<Return<SchemaEntityReturn[], FailureAbstract>>;
     delete<T extends Newable<ObjectLiteral>>(entity: T, condition: {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
     }): Promise<Return<undefined, undefined>>;
@@ -20,3 +28,4 @@ export declare abstract class DatabaseHelperAbstract {
     private commit;
     private rollback;
 }
+export {};

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

@@ -5,6 +5,7 @@ const arch_1 = require("@atlantjs/arch");
 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");
+const database_helper_abstract_write_failure_1 = require("./database.helper.abstract.write.failure");
 class DatabaseHelperAbstract {
     constructor() {
         this.database = arch_1.Nothing;
@@ -31,29 +32,36 @@ class DatabaseHelperAbstract {
         })));
         return (0, arch_1.Success)(registryPacked);
     }
-    async write(schema, entity) {
+    async write(schemaEntities) {
         try {
             const client = await this.openTransaction();
-            const repository = client.getRepository(schema);
-            if (arch_1._.isUndefined(entity.toSchema) ||
-                arch_1._.isUndefined(entity.id)) {
-                return (0, arch_1.Failure)();
-            }
-            const registryPacked = (0, arch_1.Optional)(await repository.findOne({
-                where: { id: entity.id.toString() },
-            }));
-            if (registryPacked.hasNothing()) {
-                await repository.save(entity.toSchema());
-            }
-            else {
-                await repository.update({ id: entity.id.toString() }, entity.toSchema());
+            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());
+                }
+                const registryFoundedPacked = (0, arch_1.Optional)(await repository.findOne({
+                    where: { id: schemaEntity.entity.id.toString() },
+                }));
+                if (registryFoundedPacked.hasNothing()) {
+                    await repository.save(schemaEntity.entity.toSchema());
+                }
+                else {
+                    await repository.update({ id: schemaEntity.entity.id.toString() }, schemaEntity.entity.toSchema());
+                }
+                ids.push({
+                    schema: schemaEntity.schema.name,
+                    id: schemaEntity.entity.id.toString(),
+                });
             }
             await this.commit();
-            return (0, arch_1.Success)();
+            return (0, arch_1.Success)(ids);
         }
-        catch {
+        catch (error) {
             await this.rollback();
-            return (0, arch_1.Failure)();
+            return (0, arch_1.Failure)(new database_helper_abstract_write_failure_1.DatabaseHelperAbstractWriteFailure(error));
         }
     }
     async delete(entity, condition) {

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlantjs/backend",
-	"version": "4.0.18",
+	"version": "4.0.20",
 	"main": "index.js",
 	"license": "UNLICENSED",
 	"publishConfig": {