@declaro/data 2.0.0-beta.126 → 2.0.0-beta.128

package/dist/node/index.cjs

@@ -49,10 +49,11 @@ __export(exports_src, {
 module.exports = __toCommonJS(exports_src);
 
 // src/application/model-controller.ts
-var import_core = require("@declaro/core");
+var import_core2 = require("@declaro/core");
 
 // src/application/read-only-model-controller.ts
 var import_auth = require("@declaro/auth");
+var import_core = require("@declaro/core");
 
 class ReadOnlyModelController {
   service;
@@ -61,32 +62,48 @@ class ReadOnlyModelController {
     this.service = service;
     this.authValidator = authValidator;
   }
-  async load(lookup, options) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async loadPermissions(lookup) {
+    return import_core.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 import_core.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 import_core.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 import_core.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);
   }
 }
@@ -100,69 +117,111 @@ class ModelController extends ReadOnlyModelController {
     this.service = service;
     this.authValidator = authValidator;
   }
-  async create(input) {
-    this.authValidator.validatePermissions((v) => v.someOf([
+  async createPermissions(input, options) {
+    return import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 import_core2.PermissionValidator.create().someOf([
       this.service.getDescriptor("restore", "*").toString(),
       this.service.getDescriptor("write", "*").toString()
-    ]));
-    return this.service.restore(lookup);
+    ]);
   }
-  async upsert(input, options) {
-    const createAndUpdateValidator = import_core.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 = import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 = import_core.PermissionValidator.create().allOf([
+  async bulkUpsertPermissions(inputs, options) {
+    const createAndUpdateValidator = import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 import_core2.PermissionValidator.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 import_core2.PermissionValidator.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);
   }
 }
 // src/domain/events/domain-event.ts
-var import_core2 = require("@declaro/core");
+var import_core3 = require("@declaro/core");
 
 // ../../node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
@@ -229,7 +288,7 @@ class DomainEvent {
     }
     this.eventId = options.eventId ?? v4_default();
     this.timestamp = options.timestamp ?? new Date;
-    this.descriptor = options.descriptor ? import_core2.ActionDescriptor.fromJSON(options.descriptor) : import_core2.ActionDescriptor.fromString(this.type);
+    this.descriptor = options.descriptor ? import_core3.ActionDescriptor.fromJSON(options.descriptor) : import_core3.ActionDescriptor.fromString(this.type);
     if (options.descriptor && this.type === "UNKNOWN_EVENT") {
       this.type = this.descriptor.toString();
     }
@@ -12654,7 +12713,7 @@ var v4_default2 = classic_default;
 
 // src/domain/models/pagination.ts
 var import_zod = require("@declaro/zod");
-var import_core9 = require("@declaro/core");
+var import_core10 = require("@declaro/core");
 var PaginationInput = new import_zod.ZodModel("PaginationInput", v4_default2.object({
   page: v4_default2.number().int().min(1).default(1).nullish(),
   pageSize: v4_default2.number().int().min(1).default(25).nullish()
@@ -12665,12 +12724,12 @@ var PaginationOutput = new import_zod.ZodModel("PaginationOutput", v4_default2.o
   total: v4_default2.number().int().min(0).default(0),
   totalPages: v4_default2.number().int().min(1).default(1)
 }));
-var PaginationSchema = import_core9.ModelSchema.create("Pagination").custom({
+var PaginationSchema = import_core10.ModelSchema.create("Pagination").custom({
   input: () => PaginationInput,
   output: () => PaginationOutput
 });
 // src/domain/services/base-model-service.ts
-var import_core10 = require("@declaro/core");
+var import_core11 = require("@declaro/core");
 
 class BaseModelService {
   namespace;
@@ -12686,7 +12745,7 @@ class BaseModelService {
     this.entityMetadata = this.schema.getEntityMetadata();
   }
   getDescriptor(action, scope) {
-    return import_core10.ActionDescriptor.fromJSON({
+    return import_core11.ActionDescriptor.fromJSON({
       namespace: this.namespace,
       resource: this.schema.name,
       action,
@@ -12712,38 +12771,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;
   }
 }
@@ -12756,6 +12831,34 @@ class ModelService extends ReadOnlyModelService {
   async normalizeInput(input, args) {
     return input;
   }
+  async detailsToInput(detail) {
+    const inputModel = this.schema.definition.input;
+    const inputJsonSchema = inputModel.toJSONSchema();
+    const inputFields = Object.keys(inputJsonSchema.properties ?? {});
+    const picked = {};
+    for (const field of inputFields) {
+      if (field in detail) {
+        picked[field] = detail[field];
+      }
+    }
+    const result = await inputModel.validate(picked);
+    if ("value" in result) {
+      return result.value;
+    }
+    return picked;
+  }
+  async duplicate(lookup, overrides, options) {
+    const existing = await this.load(lookup);
+    if (!existing) {
+      throw new Error("Item not found");
+    }
+    const input = await this.detailsToInput(existing);
+    if (this.entityMetadata?.primaryKey) {
+      delete input[this.entityMetadata.primaryKey];
+    }
+    const finalInput = overrides ? Object.assign({}, input, overrides) : input;
+    return this.create(finalInput, options);
+  }
   async remove(lookup, options) {
     const beforeRemoveEvent = new MutationEvent(this.getDescriptor("beforeRemove" /* BeforeRemove */), lookup);
     await this.emitter.emitAsync(beforeRemoveEvent);
@@ -12776,24 +12879,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) {
@@ -12809,7 +12920,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 */;
@@ -12824,11 +12938,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) {
@@ -12855,7 +12973,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);
@@ -12878,20 +12999,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) {
@@ -12920,9 +13045,9 @@ class ModelService extends ReadOnlyModelService {
   }
 }
 // src/test/mock/models/mock-book-models.ts
-var import_core11 = require("@declaro/core");
+var import_core12 = require("@declaro/core");
 var import_zod2 = require("@declaro/zod");
-var MockBookSchema = import_core11.ModelSchema.create("Book").read({
+var MockBookSchema = import_core12.ModelSchema.create("Book").read({
   detail: (h) => new import_zod2.ZodModel(h.name, exports_external.object({
     id: exports_external.number().int().positive(),
     title: exports_external.string().min(2).max(100),
@@ -13231,5 +13356,5 @@ class MockMemoryRepository {
   }
 }
 
-//# debugId=E3CA467BBFBED82664756E2164756E21
+//# debugId=F7D58E636DC6E2AF64756E2164756E21
 //# sourceMappingURL=index.cjs.map