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

package/dist/node/index.js

@@ -10,10 +10,11 @@ var __export = (target, all) => {
 };
 
 // src/application/model-controller.ts
-import { PermissionValidator } from "@declaro/core";
+import { PermissionValidator as PermissionValidator2 } from "@declaro/core";
 
 // src/application/read-only-model-controller.ts
 import"@declaro/auth";
+import { PermissionValidator } from "@declaro/core";
 
 class ReadOnlyModelController {
   service;
@@ -22,32 +23,48 @@ class ReadOnlyModelController {
     this.service = service;
     this.authValidator = authValidator;
   }
-  async load(lookup, options) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async loadPermissions(lookup) {
+    return PermissionValidator.create().someOf([
       this.service.getDescriptor("load", "*").toString(),
       this.service.getDescriptor("read", "*").toString()
-    ]));
+    ]);
+  }
+  async load(lookup, options) {
+    const permissions = await this.loadPermissions(lookup);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.load(lookup, options);
   }
-  async loadMany(lookups, options) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async loadManyPermissions(lookups) {
+    return PermissionValidator.create().someOf([
       this.service.getDescriptor("loadMany", "*").toString(),
       this.service.getDescriptor("read", "*").toString()
-    ]));
+    ]);
+  }
+  async loadMany(lookups, options) {
+    const permissions = await this.loadManyPermissions(lookups);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.loadMany(lookups, options);
   }
-  async search(input, options) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async searchPermissions(input, options) {
+    return PermissionValidator.create().someOf([
       this.service.getDescriptor("search", "*").toString(),
       this.service.getDescriptor("read", "*").toString()
-    ]));
+    ]);
+  }
+  async search(input, options) {
+    const permissions = await this.searchPermissions(input, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.search(input, options);
   }
-  async count(input, options) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async countPermissions(input, options) {
+    return PermissionValidator.create().someOf([
       this.service.getDescriptor("count", "*").toString(),
       this.service.getDescriptor("read", "*").toString()
-    ]));
+    ]);
+  }
+  async count(input, options) {
+    const permissions = await this.countPermissions(input, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.count(input, options);
   }
 }
@@ -61,64 +78,106 @@ class ModelController extends ReadOnlyModelController {
     this.service = service;
     this.authValidator = authValidator;
   }
-  async create(input) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async createPermissions(input, options) {
+    return PermissionValidator2.create().someOf([
       this.service.getDescriptor("create", "*").toString(),
       this.service.getDescriptor("write", "*").toString()
-    ]));
-    return this.service.create(input);
+    ]);
   }
-  async update(lookup, input) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async create(input, options) {
+    const permissions = await this.createPermissions(input, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
+    return this.service.create(input, options);
+  }
+  async updatePermissions(lookup, input, options) {
+    return PermissionValidator2.create().someOf([
       this.service.getDescriptor("update", "*").toString(),
       this.service.getDescriptor("write", "*").toString()
-    ]));
-    return this.service.update(lookup, input);
+    ]);
   }
-  async remove(lookup) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async update(lookup, input, options) {
+    const permissions = await this.updatePermissions(lookup, input, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
+    return this.service.update(lookup, input, options);
+  }
+  async removePermissions(lookup, options) {
+    return PermissionValidator2.create().someOf([
       this.service.getDescriptor("remove", "*").toString(),
       this.service.getDescriptor("write", "*").toString()
-    ]));
-    return this.service.remove(lookup);
+    ]);
   }
-  async restore(lookup) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async remove(lookup, options) {
+    const permissions = await this.removePermissions(lookup, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
+    return this.service.remove(lookup, options);
+  }
+  async restorePermissions(lookup, options) {
+    return PermissionValidator2.create().someOf([
       this.service.getDescriptor("restore", "*").toString(),
       this.service.getDescriptor("write", "*").toString()
-    ]));
-    return this.service.restore(lookup);
+    ]);
   }
-  async upsert(input, options) {
-    const createAndUpdateValidator = PermissionValidator.create().allOf([
+  async restore(lookup, options) {
+    const permissions = await this.restorePermissions(lookup, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
+    return this.service.restore(lookup, options);
+  }
+  async upsertPermissions(input, options) {
+    const createAndUpdateValidator = PermissionValidator2.create().allOf([
       this.service.getDescriptor("create", "*").toString(),
       this.service.getDescriptor("update", "*").toString()
     ]);
-    this.authValidator.validatePermissions((v) => v.someOf([createAndUpdateValidator, this.service.getDescriptor("write", "*").toString()]));
+    return PermissionValidator2.create().someOf([
+      createAndUpdateValidator,
+      this.service.getDescriptor("write", "*").toString()
+    ]);
+  }
+  async upsert(input, options) {
+    const permissions = await this.upsertPermissions(input, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.upsert(input, options);
   }
-  async bulkUpsert(inputs, options) {
-    const createAndUpdateValidator = PermissionValidator.create().allOf([
+  async bulkUpsertPermissions(inputs, options) {
+    const createAndUpdateValidator = PermissionValidator2.create().allOf([
       this.service.getDescriptor("create", "*").toString(),
       this.service.getDescriptor("update", "*").toString()
     ]);
-    this.authValidator.validatePermissions((v) => v.someOf([createAndUpdateValidator, this.service.getDescriptor("write", "*").toString()]));
+    return PermissionValidator2.create().someOf([
+      createAndUpdateValidator,
+      this.service.getDescriptor("write", "*").toString()
+    ]);
+  }
+  async bulkUpsert(inputs, options) {
+    const permissions = await this.bulkUpsertPermissions(inputs, options);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.bulkUpsert(inputs, options);
   }
-  async permanentlyDeleteFromTrash(lookup) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async permanentlyDeleteFromTrashPermissions(lookup) {
+    return PermissionValidator2.create().someOf([
       this.service.getDescriptor("permanently-delete-from-trash", "*").toString(),
       this.service.getDescriptor("permanently-delete", "*").toString(),
       this.service.getDescriptor("empty-trash", "*").toString()
-    ]));
+    ]);
+  }
+  async permanentlyDeleteFromTrash(lookup) {
+    const permissions = await this.permanentlyDeleteFromTrashPermissions(lookup);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.permanentlyDeleteFromTrash(lookup);
   }
+  async permanentlyDeletePermissions(lookup) {
+    return PermissionValidator2.create().someOf([this.service.getDescriptor("permanently-delete", "*").toString()]);
+  }
   async permanentlyDelete(lookup) {
-    this.authValidator.validatePermissions((v) => v.someOf([this.service.getDescriptor("permanently-delete", "*").toString()]));
+    const permissions = await this.permanentlyDeletePermissions(lookup);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.permanentlyDelete(lookup);
   }
+  async emptyTrashPermissions(filters) {
+    return PermissionValidator2.create().someOf([this.service.getDescriptor("empty-trash", "*").toString()]);
+  }
   async emptyTrash(filters) {
-    this.authValidator.validatePermissions((v) => v.someOf([this.service.getDescriptor("empty-trash", "*").toString()]));
+    const permissions = await this.emptyTrashPermissions(filters);
+    this.authValidator.validatePermissions((v) => v.extend(permissions));
     return this.service.emptyTrash(filters);
   }
 }
@@ -12673,38 +12732,54 @@ class ReadOnlyModelService extends BaseModelService {
     return summary;
   }
   async load(lookup, options) {
-    const beforeLoadEvent = new QueryEvent(this.getDescriptor("beforeLoad" /* BeforeLoad */, options?.scope), lookup);
-    await this.emitter.emitAsync(beforeLoadEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeLoadEvent = new QueryEvent(this.getDescriptor("beforeLoad" /* BeforeLoad */, options?.scope), lookup);
+      await this.emitter.emitAsync(beforeLoadEvent);
+    }
     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);
+    if (!options?.doNotDispatchEvents) {
+      const afterLoadEvent = new QueryEvent(this.getDescriptor("afterLoad" /* AfterLoad */, options?.scope), lookup).setResult(details);
+      await this.emitter.emitAsync(afterLoadEvent);
+    }
     return await this.normalizeDetail(details);
   }
   async loadMany(lookups, options) {
-    const beforeLoadManyEvent = new QueryEvent(this.getDescriptor("beforeLoadMany" /* BeforeLoadMany */, options?.scope), lookups);
-    await this.emitter.emitAsync(beforeLoadManyEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeLoadManyEvent = new QueryEvent(this.getDescriptor("beforeLoadMany" /* BeforeLoadMany */, options?.scope), lookups);
+      await this.emitter.emitAsync(beforeLoadManyEvent);
+    }
     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);
+    if (!options?.doNotDispatchEvents) {
+      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)));
   }
   async search(filters, options) {
-    const beforeSearchEvent = new QueryEvent(this.getDescriptor("beforeSearch" /* BeforeSearch */, options?.scope), filters);
-    await this.emitter.emitAsync(beforeSearchEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeSearchEvent = new QueryEvent(this.getDescriptor("beforeSearch" /* BeforeSearch */, options?.scope), filters);
+      await this.emitter.emitAsync(beforeSearchEvent);
+    }
     const results = await this.repository.search(filters, options);
-    const afterSearchEvent = new QueryEvent(this.getDescriptor("afterSearch" /* AfterSearch */, options?.scope), filters).setResult(results);
-    await this.emitter.emitAsync(afterSearchEvent);
+    if (!options?.doNotDispatchEvents) {
+      const afterSearchEvent = new QueryEvent(this.getDescriptor("afterSearch" /* AfterSearch */, options?.scope), filters).setResult(results);
+      await this.emitter.emitAsync(afterSearchEvent);
+    }
     return {
       ...results,
       results: await Promise.all(results.results.map((detail) => this.normalizeSummary(detail)))
     };
   }
   async count(filters, options) {
-    const beforeCountEvent = new QueryEvent(this.getDescriptor("beforeCount" /* BeforeCount */, options?.scope), filters);
-    await this.emitter.emitAsync(beforeCountEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeCountEvent = new QueryEvent(this.getDescriptor("beforeCount" /* BeforeCount */, options?.scope), filters);
+      await this.emitter.emitAsync(beforeCountEvent);
+    }
     const count = await this.repository.count(filters, options);
-    const afterCountEvent = new QueryEvent(this.getDescriptor("afterCount" /* AfterCount */, options?.scope), filters).setResult(count);
-    await this.emitter.emitAsync(afterCountEvent);
+    if (!options?.doNotDispatchEvents) {
+      const afterCountEvent = new QueryEvent(this.getDescriptor("afterCount" /* AfterCount */, options?.scope), filters).setResult(count);
+      await this.emitter.emitAsync(afterCountEvent);
+    }
     return count;
   }
 }
@@ -12737,24 +12812,32 @@ class ModelService extends ReadOnlyModelService {
     const normalizedInput = await this.normalizeInput(input, {
       descriptor: this.getDescriptor("create" /* Create */)
     });
-    const beforeCreateEvent = new MutationEvent(this.getDescriptor("beforeCreate" /* BeforeCreate */), normalizedInput);
-    await this.emitter.emitAsync(beforeCreateEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeCreateEvent = new MutationEvent(this.getDescriptor("beforeCreate" /* BeforeCreate */), normalizedInput);
+      await this.emitter.emitAsync(beforeCreateEvent);
+    }
     const result = await this.repository.create(normalizedInput, options);
-    const afterCreateEvent = new MutationEvent(this.getDescriptor("afterCreate" /* AfterCreate */), normalizedInput).setResult(result);
-    await this.emitter.emitAsync(afterCreateEvent);
+    if (!options?.doNotDispatchEvents) {
+      const afterCreateEvent = new MutationEvent(this.getDescriptor("afterCreate" /* AfterCreate */), normalizedInput).setResult(result);
+      await this.emitter.emitAsync(afterCreateEvent);
+    }
     return await this.normalizeDetail(result);
   }
   async update(lookup, input, options) {
-    const existing = await this.repository.load(lookup, options);
+    const existing = await this.repository.load(lookup, { ...options, doNotDispatchEvents: true });
     const normalizedInput = await this.normalizeInput(input, {
       existing,
       descriptor: this.getDescriptor("update" /* Update */)
     });
-    const beforeUpdateEvent = new MutationEvent(this.getDescriptor("beforeUpdate" /* BeforeUpdate */), normalizedInput);
-    await this.emitter.emitAsync(beforeUpdateEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeUpdateEvent = new MutationEvent(this.getDescriptor("beforeUpdate" /* BeforeUpdate */), normalizedInput);
+      await this.emitter.emitAsync(beforeUpdateEvent);
+    }
     const result = await this.repository.update(lookup, normalizedInput, options);
-    const afterUpdateEvent = new MutationEvent(this.getDescriptor("afterUpdate" /* AfterUpdate */), normalizedInput).setResult(result);
-    await this.emitter.emitAsync(afterUpdateEvent);
+    if (!options?.doNotDispatchEvents) {
+      const afterUpdateEvent = new MutationEvent(this.getDescriptor("afterUpdate" /* AfterUpdate */), normalizedInput).setResult(result);
+      await this.emitter.emitAsync(afterUpdateEvent);
+    }
     return await this.normalizeDetail(result);
   }
   async upsert(input, options) {
@@ -12770,7 +12853,10 @@ class ModelService extends ReadOnlyModelService {
     } else {
       existingItem = await this.load({
         [this.entityMetadata.primaryKey]: primaryKeyValue
-      }, options);
+      }, {
+        ...options,
+        doNotDispatchEvents: true
+      });
       if (existingItem) {
         operation = "update" /* Update */;
         beforeOperation = "beforeUpdate" /* BeforeUpdate */;
@@ -12785,11 +12871,15 @@ class ModelService extends ReadOnlyModelService {
       descriptor: this.getDescriptor(operation),
       existing: existingItem
     });
-    const beforeUpsertEvent = new MutationEvent(this.getDescriptor(beforeOperation), normalizedInput);
-    await this.emitter.emitAsync(beforeUpsertEvent);
+    if (!options?.doNotDispatchEvents) {
+      const beforeUpsertEvent = new MutationEvent(this.getDescriptor(beforeOperation), normalizedInput);
+      await this.emitter.emitAsync(beforeUpsertEvent);
+    }
     const result = await this.repository.upsert(normalizedInput, options);
-    const afterUpsertEvent = new MutationEvent(this.getDescriptor(afterOperation), normalizedInput).setResult(result);
-    await this.emitter.emitAsync(afterUpsertEvent);
+    if (!options?.doNotDispatchEvents) {
+      const afterUpsertEvent = new MutationEvent(this.getDescriptor(afterOperation), normalizedInput).setResult(result);
+      await this.emitter.emitAsync(afterUpsertEvent);
+    }
     return await this.normalizeDetail(result);
   }
   async bulkUpsert(inputs, options) {
@@ -12816,7 +12906,10 @@ class ModelService extends ReadOnlyModelService {
     const existingEntitiesMap = new Map;
     if (uniqueLookups.size > 0) {
       const lookups = Array.from(uniqueLookups.values());
-      const existingEntities = await this.loadMany(lookups, options);
+      const existingEntities = await this.loadMany(lookups, {
+        ...options,
+        doNotDispatchEvents: true
+      });
       existingEntities.forEach((entity) => {
         if (entity) {
           const pkValue = this.getPrimaryKeyValue(entity);
@@ -12839,20 +12932,24 @@ class ModelService extends ReadOnlyModelService {
       return normalizedInput;
     });
     const normalizedInputs = await Promise.all(normalizationPromises);
-    const beforeEvents = [];
-    for (const inputInfo of inputInfos) {
-      beforeEvents.push(new MutationEvent(this.getDescriptor(inputInfo.operation), inputInfo.input));
+    if (!options?.doNotDispatchEvents) {
+      const beforeEvents = [];
+      for (const inputInfo of inputInfos) {
+        beforeEvents.push(new MutationEvent(this.getDescriptor(inputInfo.operation), inputInfo.input));
+      }
+      await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)));
     }
-    await Promise.all(beforeEvents.map((event) => this.emitter.emitAsync(event)));
     const results = await this.repository.bulkUpsert(normalizedInputs, options);
-    const afterEvents = [];
-    for (let i = 0;i < inputInfos.length; i++) {
-      const inputInfo = inputInfos[i];
-      const result = results[i];
-      const afterOperation = inputInfo.operation === "beforeCreate" /* BeforeCreate */ ? "afterCreate" /* AfterCreate */ : "afterUpdate" /* AfterUpdate */;
-      afterEvents.push(new MutationEvent(this.getDescriptor(afterOperation), inputInfo.input).setResult(result));
-    }
-    await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)));
+    if (!options?.doNotDispatchEvents) {
+      const afterEvents = [];
+      for (let i = 0;i < inputInfos.length; i++) {
+        const inputInfo = inputInfos[i];
+        const result = results[i];
+        const afterOperation = inputInfo.operation === "beforeCreate" /* BeforeCreate */ ? "afterCreate" /* AfterCreate */ : "afterUpdate" /* AfterUpdate */;
+        afterEvents.push(new MutationEvent(this.getDescriptor(afterOperation), inputInfo.input).setResult(result));
+      }
+      await Promise.all(afterEvents.map((event) => this.emitter.emitAsync(event)));
+    }
     return await Promise.all(results.map((result) => this.normalizeDetail(result)));
   }
   async emptyTrash(filters) {
@@ -13210,5 +13307,5 @@ export {
   BaseModelService
 };
 
-//# debugId=4FCC17E6392BEFF464756E2164756E21
+//# debugId=2F46F5B1D5A9235464756E2164756E21
 //# sourceMappingURL=index.js.map