@declaro/data 2.0.0-beta.120 → 2.0.0-beta.125

package/dist/node/index.cjs

@@ -144,6 +144,22 @@ class ModelController extends ReadOnlyModelController {
     this.authValidator.validatePermissions((v) => v.someOf([createAndUpdateValidator, this.service.getDescriptor("write", "*").toString()]));
     return this.service.bulkUpsert(inputs, options);
   }
+  async permanentlyDeleteFromTrash(lookup) {
+    this.authValidator.validatePermissions((v) => v.someOf([
+      this.service.getDescriptor("permanently-delete-from-trash", "*").toString(),
+      this.service.getDescriptor("permanently-delete", "*").toString(),
+      this.service.getDescriptor("empty-trash", "*").toString()
+    ]));
+    return this.service.permanentlyDeleteFromTrash(lookup);
+  }
+  async permanentlyDelete(lookup) {
+    this.authValidator.validatePermissions((v) => v.someOf([this.service.getDescriptor("permanently-delete", "*").toString()]));
+    return this.service.permanentlyDelete(lookup);
+  }
+  async emptyTrash(filters) {
+    this.authValidator.validatePermissions((v) => v.someOf([this.service.getDescriptor("empty-trash", "*").toString()]));
+    return this.service.emptyTrash(filters);
+  }
 }
 // src/domain/events/domain-event.ts
 var import_core2 = require("@declaro/core");
@@ -258,17 +274,29 @@ var ModelMutationAction;
   ModelMutationAction2["Restore"] = "restore";
   ModelMutationAction2["BeforeRestore"] = "beforeRestore";
   ModelMutationAction2["AfterRestore"] = "afterRestore";
+  ModelMutationAction2["EmptyTrash"] = "emptyTrash";
+  ModelMutationAction2["BeforeEmptyTrash"] = "beforeEmptyTrash";
+  ModelMutationAction2["AfterEmptyTrash"] = "afterEmptyTrash";
+  ModelMutationAction2["PermanentlyDeleteFromTrash"] = "permanentlyDeleteFromTrash";
+  ModelMutationAction2["BeforePermanentlyDeleteFromTrash"] = "beforePermanentlyDeleteFromTrash";
+  ModelMutationAction2["AfterPermanentlyDeleteFromTrash"] = "afterPermanentlyDeleteFromTrash";
+  ModelMutationAction2["PermanentlyDelete"] = "permanentlyDelete";
+  ModelMutationAction2["BeforePermanentlyDelete"] = "beforePermanentlyDelete";
+  ModelMutationAction2["AfterPermanentlyDelete"] = "afterPermanentlyDelete";
 })(ModelMutationAction ||= {});
 // src/domain/events/request-event.ts
 class RequestEvent extends DomainEvent {
+  input;
   constructor(descriptor, input, meta = {}) {
     super({
-      meta: {
-        ...meta,
-        input
-      },
+      meta,
       descriptor
     });
+    this.input = input;
+  }
+  setInput(input) {
+    this.input = input;
+    return this;
   }
   setMeta(meta) {
     this.meta = { ...this.meta, ...meta };
@@ -278,6 +306,12 @@ class RequestEvent extends DomainEvent {
     this.data = result;
     return this;
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      input: this.input
+    };
+  }
 }
 
 // src/domain/events/mutation-event.ts
@@ -12680,7 +12714,7 @@ class ReadOnlyModelService extends BaseModelService {
   async load(lookup, options) {
     const beforeLoadEvent = new QueryEvent(this.getDescriptor("beforeLoad" /* BeforeLoad */, options?.scope), lookup);
     await this.emitter.emitAsync(beforeLoadEvent);
-    const details = await this.repository.load(lookup);
+    const details = await this.repository.load(lookup, options);
     const afterLoadEvent = new QueryEvent(this.getDescriptor("afterLoad" /* AfterLoad */, options?.scope), lookup).setResult(details);
     await this.emitter.emitAsync(afterLoadEvent);
     return await this.normalizeDetail(details);
@@ -12688,7 +12722,7 @@ class ReadOnlyModelService extends BaseModelService {
   async loadMany(lookups, options) {
     const beforeLoadManyEvent = new QueryEvent(this.getDescriptor("beforeLoadMany" /* BeforeLoadMany */, options?.scope), lookups);
     await this.emitter.emitAsync(beforeLoadManyEvent);
-    const details = await this.repository.loadMany(lookups);
+    const details = await this.repository.loadMany(lookups, options);
     const afterLoadManyEvent = new QueryEvent(this.getDescriptor("afterLoadMany" /* AfterLoadMany */, options?.scope), lookups).setResult(details);
     await this.emitter.emitAsync(afterLoadManyEvent);
     return await Promise.all(details.map((detail) => this.normalizeDetail(detail)));
@@ -12860,6 +12894,30 @@ class ModelService extends ReadOnlyModelService {
     await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)));
     return await Promise.all(results.map((result) => this.normalizeDetail(result)));
   }
+  async emptyTrash(filters) {
+    const beforeEmptyTrashEvent = new MutationEvent(this.getDescriptor("beforeEmptyTrash" /* BeforeEmptyTrash */), filters);
+    await this.emitter.emitAsync(beforeEmptyTrashEvent);
+    const count = await this.repository.emptyTrash(filters);
+    const afterEmptyTrashEvent = new MutationEvent(this.getDescriptor("afterEmptyTrash" /* AfterEmptyTrash */), filters).setResult(count);
+    await this.emitter.emitAsync(afterEmptyTrashEvent);
+    return count;
+  }
+  async permanentlyDeleteFromTrash(lookup) {
+    const beforePermanentlyDeleteFromTrashEvent = new MutationEvent(this.getDescriptor("beforePermanentlyDeleteFromTrash" /* BeforePermanentlyDeleteFromTrash */), lookup);
+    await this.emitter.emitAsync(beforePermanentlyDeleteFromTrashEvent);
+    const result = await this.repository.permanentlyDeleteFromTrash(lookup);
+    const afterPermanentlyDeleteFromTrashEvent = new MutationEvent(this.getDescriptor("afterPermanentlyDeleteFromTrash" /* AfterPermanentlyDeleteFromTrash */), lookup).setResult(result);
+    await this.emitter.emitAsync(afterPermanentlyDeleteFromTrashEvent);
+    return await this.normalizeSummary(result);
+  }
+  async permanentlyDelete(lookup) {
+    const beforePermanentlyDeleteEvent = new MutationEvent(this.getDescriptor("beforePermanentlyDelete" /* BeforePermanentlyDelete */), lookup);
+    await this.emitter.emitAsync(beforePermanentlyDeleteEvent);
+    const result = await this.repository.permanentlyDelete(lookup);
+    const afterPermanentlyDeleteEvent = new MutationEvent(this.getDescriptor("afterPermanentlyDelete" /* AfterPermanentlyDelete */), lookup).setResult(result);
+    await this.emitter.emitAsync(afterPermanentlyDeleteEvent);
+    return await this.normalizeSummary(result);
+  }
 }
 // src/test/mock/models/mock-book-models.ts
 var import_core11 = require("@declaro/core");
@@ -12909,15 +12967,39 @@ class MockMemoryRepository {
       throw new Error("Primary key must be specified for MockMemoryRepository");
     }
   }
-  async load(input) {
+  findOne(lookup, map2) {
+    if (typeof this.args.lookup === "function") {
+      return Array.from(map2.values()).find((data) => this.args.lookup(data, lookup));
+    } else {
+      return map2.get(lookup[this.entityMetadata.primaryKey]);
+    }
+  }
+  findOneWithKey(lookup, map2) {
+    if (typeof this.args.lookup === "function") {
+      const item = Array.from(map2.values()).find((data) => this.args.lookup(data, lookup));
+      if (item) {
+        return { item, key: item[this.entityMetadata.primaryKey] };
+      }
+    } else {
+      const key = lookup[this.entityMetadata.primaryKey];
+      const item = map2.get(key);
+      if (item) {
+        return { item, key };
+      }
+    }
+    return;
+  }
+  async load(input, options = {}) {
     if (!this.entityMetadata?.primaryKey) {
       throw new Error("Primary key is not defined in the schema metadata");
     }
     let item;
-    if (typeof this.args.lookup === "function") {
-      item = Array.from(this.data.values()).find((data) => this.args.lookup(data, input));
+    if (options.removedOnly) {
+      item = this.findOne(input, this.trash);
+    } else if (options.includeRemoved) {
+      item = this.findOne(input, this.data) ?? this.findOne(input, this.trash);
     } else {
-      item = await this.data.get(input[this.entityMetadata.primaryKey]);
+      item = this.findOne(input, this.data);
     }
     return item || null;
   }
@@ -12941,7 +13023,7 @@ class MockMemoryRepository {
   }
   async search(input, options) {
     const pagination = options?.pagination || { page: 1, pageSize: 25 };
-    let items = this.applyFilters(input);
+    let items = this.applyFilters(input, options);
     if (options?.sort && Array.isArray(options.sort)) {
       items = items.sort((a, b) => {
         for (const sortField of options.sort) {
@@ -12979,45 +13061,25 @@ class MockMemoryRepository {
     if (!this.entityMetadata?.primaryKey) {
       throw new Error("Primary key is not defined in the schema metadata");
     }
-    let item;
-    let itemKey;
-    if (typeof this.args.lookup === "function") {
-      item = Array.from(this.data.values()).find((data) => this.args.lookup(data, lookup));
-      if (item) {
-        itemKey = item[this.entityMetadata.primaryKey];
-      }
-    } else {
-      itemKey = lookup[this.entityMetadata.primaryKey];
-      item = this.data.get(itemKey);
-    }
-    if (!item) {
+    const found = this.findOneWithKey(lookup, this.data);
+    if (!found) {
       throw new Error("Item not found");
     }
-    this.trash.set(itemKey, item);
-    this.data.delete(itemKey);
-    return item;
+    this.trash.set(found.key, found.item);
+    this.data.delete(found.key);
+    return found.item;
   }
   async restore(lookup) {
     if (!this.entityMetadata?.primaryKey) {
       throw new Error("Primary key is not defined in the schema metadata");
     }
-    let item;
-    let itemKey;
-    if (typeof this.args.lookup === "function") {
-      item = Array.from(this.trash.values()).find((data) => this.args.lookup(data, lookup));
-      if (item) {
-        itemKey = item[this.entityMetadata.primaryKey];
-      }
-    } else {
-      itemKey = lookup[this.entityMetadata.primaryKey];
-      item = this.trash.get(itemKey);
-    }
-    if (!item) {
+    const found = this.findOneWithKey(lookup, this.trash);
+    if (!found) {
       throw new Error("Item not found in trash");
     }
-    this.trash.delete(itemKey);
-    this.data.set(itemKey, item);
-    return item;
+    this.trash.delete(found.key);
+    this.data.set(found.key, found.item);
+    return found.item;
   }
   async create(input) {
     if (!this.entityMetadata?.primaryKey) {
@@ -13063,7 +13125,7 @@ class MockMemoryRepository {
     return updatedItem;
   }
   async count(search, options) {
-    const filteredItems = this.applyFilters(search);
+    const filteredItems = this.applyFilters(search, options);
     return filteredItems.length;
   }
   async upsert(input, options) {
@@ -13082,8 +13144,64 @@ class MockMemoryRepository {
   async bulkUpsert(inputs, options) {
     return await Promise.all(inputs.map((input) => this.upsert(input, options)));
   }
-  applyFilters(input) {
-    return Array.from(this.data.values()).filter((item) => {
+  async permanentlyDelete(lookup) {
+    if (!this.entityMetadata?.primaryKey) {
+      throw new Error("Primary key is not defined in the schema metadata");
+    }
+    const foundInData = this.findOneWithKey(lookup, this.data);
+    if (foundInData) {
+      this.data.delete(foundInData.key);
+      return foundInData.item;
+    }
+    const foundInTrash = this.findOneWithKey(lookup, this.trash);
+    if (foundInTrash) {
+      this.trash.delete(foundInTrash.key);
+      return foundInTrash.item;
+    }
+    throw new Error("Item not found");
+  }
+  async permanentlyDeleteFromTrash(lookup) {
+    if (!this.entityMetadata?.primaryKey) {
+      throw new Error("Primary key is not defined in the schema metadata");
+    }
+    const found = this.findOneWithKey(lookup, this.trash);
+    if (!found) {
+      throw new Error("Item not found in trash");
+    }
+    this.trash.delete(found.key);
+    return found.item;
+  }
+  async emptyTrash(filters) {
+    if (!filters || Object.keys(filters).length === 0) {
+      const count = this.trash.size;
+      this.trash.clear();
+      return count;
+    }
+    const itemsToDelete = [];
+    for (const [key, item] of this.trash.entries()) {
+      if (typeof this.args.filter === "function") {
+        if (this.args.filter(item, filters)) {
+          itemsToDelete.push(key);
+        }
+      } else {
+        itemsToDelete.push(key);
+      }
+    }
+    for (const key of itemsToDelete) {
+      this.trash.delete(key);
+    }
+    return itemsToDelete.length;
+  }
+  applyFilters(input, options) {
+    let sourceItems;
+    if (options?.removedOnly) {
+      sourceItems = Array.from(this.trash.values());
+    } else if (options?.includeRemoved) {
+      sourceItems = [...Array.from(this.data.values()), ...Array.from(this.trash.values())];
+    } else {
+      sourceItems = Array.from(this.data.values());
+    }
+    return sourceItems.filter((item) => {
       if (typeof this.args.filter === "function") {
         return this.args.filter(item, input);
       } else {
@@ -13113,5 +13231,5 @@ class MockMemoryRepository {
   }
 }
 
-//# debugId=CDABACEBE68C85EA64756E2164756E21
+//# debugId=E3CA467BBFBED82664756E2164756E21
 //# sourceMappingURL=index.cjs.map