@atlantjs/backend 5.0.3 → 5.0.5

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

@@ -20,9 +20,9 @@ export declare abstract class DatabaseHelperAbstract {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
     }, relations: FindOptionsRelations<E>): Promise<Return<Optional<InstanceType<T>[]>, FailureAbstract>>;
     write(schemaEntities: SchemaEntity[]): Promise<Return<SchemaEntityReturn[], FailureAbstract>>;
-    delete<T extends Newable<ObjectLiteral>>(entity: T, condition: {
+    delete<T extends Newable<ObjectLiteral>>(schema: T, condition: {
         [K in keyof InstanceType<T>]?: InstanceType<T>[K];
-    }): Promise<Return<undefined, undefined>>;
+    }, isSoft?: boolean): Promise<Return<undefined, FailureAbstract>>;
     private getManager;
     private openTransaction;
     private commit;

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

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

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

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

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

@@ -3,6 +3,7 @@ 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");
@@ -27,9 +28,33 @@ class DatabaseHelperAbstract {
         const client = clientWrapped.unwrap();
         const repository = client.getRepository(schema);
         const registryPacked = (0, arch_1.Optional)((await repository.find({
-            where: condition,
+            where: { ...condition, deleted: false },
             relations,
         })));
+        // Remove related entities that have deleted: true
+        if (relations && registryPacked.hasSomething()) {
+            const filterDeleted = (obj, rels) => {
+                for (const key of Object.keys(rels)) {
+                    if (Array.isArray(obj[key])) {
+                        obj[key] = obj[key].filter((item) => !item.deleted);
+                        // Recursively filter nested relations
+                        if (typeof rels[key] === "object") {
+                            obj[key].forEach((item) => filterDeleted(item, rels[key]));
+                        }
+                    }
+                    else if (obj[key] && typeof obj[key] === "object") {
+                        if (obj[key].deleted)
+                            obj[key] = undefined;
+                        else if (typeof rels[key] === "object") {
+                            filterDeleted(obj[key], rels[key]);
+                        }
+                    }
+                }
+            };
+            registryPacked
+                .unpack()
+                .forEach((entity) => filterDeleted(entity, relations));
+        }
         return (0, arch_1.Success)(registryPacked);
     }
     async write(schemaEntities) {
@@ -64,15 +89,31 @@ class DatabaseHelperAbstract {
             return (0, arch_1.Failure)(new database_helper_abstract_write_failure_1.DatabaseHelperAbstractWriteFailure(error));
         }
     }
-    async delete(entity, condition) {
-        const client = await this.openTransaction();
-        const repository = client.getRepository(entity);
-        const registryPacked = (0, arch_1.Optional)(await repository.find({ where: condition }));
-        if (registryPacked.hasNothing()) {
-            return (0, arch_1.Failure)();
+    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 }));
+            if (registriesPacked.hasNothing()) {
+                return (0, arch_1.Failure)(new database_helper_abstract_delete_failure_1.DatabaseHelperAbstractDeleteFailure(isSoft));
+            }
+            if (arch_1._.isFalsy(isSoft)) {
+                repository.delete(condition);
+            }
+            else {
+                const registries = registriesPacked.unpack();
+                for (const registry of registries) {
+                    registry.deleted = true;
+                    await repository.update({ id: registry.id.toString() }, registry);
+                }
+            }
+            await this.commit();
+            return (0, arch_1.Success)();
+        }
+        catch (error) {
+            await this.rollback();
+            return (0, arch_1.Failure)(new database_helper_abstract_delete_failure_1.DatabaseHelperAbstractDeleteFailure(isSoft, error));
         }
-        repository.delete(condition);
-        return (0, arch_1.Success)();
     }
     getManager() {
         if (this.database.hasNothing()) {

package/backend/infrastructure/repositories/schemas/schema.abstract.d.ts

@@ -1,4 +1,8 @@
 import { EntityAbstract } from "../../../domain/entities/entity.abstract";
 export declare abstract class SchemaAbstract {
+    abstract id: string;
+    abstract deleted: boolean;
+    abstract createdAt: string;
+    abstract updatedAt: string;
     abstract toSolid(): EntityAbstract;
 }

package/package.json

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