@declaro/data 2.0.0-beta.115 → 2.0.0-beta.117

package/dist/node/index.js

@@ -207,12 +207,16 @@ var ModelQueryEvent;
 })(ModelQueryEvent ||= {});
 var ModelMutationAction;
 ((ModelMutationAction2) => {
+  ModelMutationAction2["Create"] = "create";
   ModelMutationAction2["BeforeCreate"] = "beforeCreate";
   ModelMutationAction2["AfterCreate"] = "afterCreate";
+  ModelMutationAction2["Update"] = "update";
   ModelMutationAction2["BeforeUpdate"] = "beforeUpdate";
   ModelMutationAction2["AfterUpdate"] = "afterUpdate";
+  ModelMutationAction2["Remove"] = "remove";
   ModelMutationAction2["BeforeRemove"] = "beforeRemove";
   ModelMutationAction2["AfterRemove"] = "afterRemove";
+  ModelMutationAction2["Restore"] = "restore";
   ModelMutationAction2["BeforeRestore"] = "beforeRestore";
   ModelMutationAction2["AfterRestore"] = "afterRestore";
 })(ModelMutationAction ||= {});
@@ -12622,31 +12626,16 @@ class BaseModelService {
     }
     return input[this.entityMetadata.primaryKey];
   }
+  getSchema() {
+    return this.schema;
+  }
 }
 // src/domain/services/read-only-model-service.ts
 class ReadOnlyModelService extends BaseModelService {
   async normalizeDetail(detail) {
-    const detailModel = this.schema.definition.detail;
-    if (detailModel) {
-      const validation = await detailModel.validate(detail, { strict: false });
-      if (validation.issues) {
-        console.warn(`${detailModel.labels.singularLabel} shape did not match the expected schema`, validation);
-      } else {
-        return validation.value;
-      }
-    }
     return detail;
   }
   async normalizeSummary(summary) {
-    const summaryModel = this.schema.definition.summary;
-    if (summaryModel) {
-      const validation = await summaryModel.validate(summary, { strict: false });
-      if (validation.issues) {
-        console.warn(`${summaryModel.labels.singularLabel} shape did not match the expected schema`);
-      } else {
-        return validation.value;
-      }
-    }
     return summary;
   }
   async load(lookup, options) {
@@ -12691,7 +12680,7 @@ class ModelService extends ReadOnlyModelService {
   constructor(args) {
     super(args);
   }
-  async normalizeInput(input) {
+  async normalizeInput(input, args) {
     return input;
   }
   async remove(lookup, options) {
@@ -12711,7 +12700,9 @@ class ModelService extends ReadOnlyModelService {
     return await this.normalizeSummary(result);
   }
   async create(input, options) {
-    const normalizedInput = await this.normalizeInput(input);
+    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);
     const result = await this.repository.create(normalizedInput, options);
@@ -12720,7 +12711,11 @@ class ModelService extends ReadOnlyModelService {
     return await this.normalizeDetail(result);
   }
   async update(lookup, input, options) {
-    const normalizedInput = await this.normalizeInput(input);
+    const existing = await this.repository.load(lookup, options);
+    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);
     const result = await this.repository.update(lookup, normalizedInput, options);
@@ -12729,25 +12724,33 @@ class ModelService extends ReadOnlyModelService {
     return await this.normalizeDetail(result);
   }
   async upsert(input, options) {
-    const normalizedInput = await this.normalizeInput(input);
-    const primaryKeyValue = this.getPrimaryKeyValue(normalizedInput);
+    const primaryKeyValue = this.getPrimaryKeyValue(input);
+    let operation;
     let beforeOperation;
     let afterOperation;
+    let existingItem = undefined;
     if (primaryKeyValue === undefined) {
+      operation = "create" /* Create */;
       beforeOperation = "beforeCreate" /* BeforeCreate */;
       afterOperation = "afterCreate" /* AfterCreate */;
     } else {
-      const existingItem = await this.load({
+      existingItem = await this.load({
         [this.entityMetadata.primaryKey]: primaryKeyValue
       }, options);
       if (existingItem) {
+        operation = "update" /* Update */;
         beforeOperation = "beforeUpdate" /* BeforeUpdate */;
         afterOperation = "afterUpdate" /* AfterUpdate */;
       } else {
+        operation = "create" /* Create */;
         beforeOperation = "beforeCreate" /* BeforeCreate */;
         afterOperation = "afterCreate" /* AfterCreate */;
       }
     }
+    const normalizedInput = await this.normalizeInput(input, {
+      descriptor: this.getDescriptor(operation),
+      existing: existingItem
+    });
     const beforeUpsertEvent = new MutationEvent(this.getDescriptor(beforeOperation), normalizedInput);
     await this.emitter.emitAsync(beforeUpsertEvent);
     const result = await this.repository.upsert(normalizedInput, options);
@@ -12759,68 +12762,61 @@ class ModelService extends ReadOnlyModelService {
     if (inputs.length === 0) {
       return [];
     }
-    const normalizedInputs = await Promise.all(inputs.map((input) => this.normalizeInput(input)));
-    const entityInfoMap = new Map;
-    const inputsWithoutPrimaryKey = [];
-    for (const input of normalizedInputs) {
+    const inputInfos = [];
+    const uniqueLookups = new Map;
+    for (let i = 0;i < inputs.length; i++) {
+      const input = inputs[i];
       const primaryKeyValue = this.getPrimaryKeyValue(input);
+      const inputInfo = {
+        input,
+        index: i,
+        primaryKeyValue
+      };
+      inputInfos.push(inputInfo);
       if (primaryKeyValue !== undefined) {
-        const entityInfo = {
-          input,
-          primaryKeyValue,
-          lookup: {
-            [this.entityMetadata.primaryKey]: primaryKeyValue
-          }
-        };
-        entityInfoMap.set(primaryKeyValue, entityInfo);
-      } else {
-        inputsWithoutPrimaryKey.push(input);
+        uniqueLookups.set(primaryKeyValue, {
+          [this.entityMetadata.primaryKey]: primaryKeyValue
+        });
       }
     }
-    const lookups = Array.from(entityInfoMap.values()).map((info) => info.lookup);
-    if (lookups.length > 0) {
+    const existingEntitiesMap = new Map;
+    if (uniqueLookups.size > 0) {
+      const lookups = Array.from(uniqueLookups.values());
       const existingEntities = await this.loadMany(lookups, options);
       existingEntities.forEach((entity) => {
         if (entity) {
           const pkValue = this.getPrimaryKeyValue(entity);
-          if (pkValue !== undefined && entityInfoMap.has(pkValue)) {
-            const entityInfo = entityInfoMap.get(pkValue);
-            entityInfo.existingEntity = entity;
+          if (pkValue !== undefined) {
+            existingEntitiesMap.set(pkValue, entity);
           }
         }
       });
     }
+    const normalizationPromises = inputInfos.map(async (inputInfo) => {
+      if (inputInfo.primaryKeyValue !== undefined) {
+        inputInfo.existingEntity = existingEntitiesMap.get(inputInfo.primaryKeyValue);
+      }
+      inputInfo.operation = inputInfo.existingEntity ? "beforeUpdate" /* BeforeUpdate */ : "beforeCreate" /* BeforeCreate */;
+      const normalizedInput = await this.normalizeInput(inputInfo.input, {
+        existing: inputInfo.existingEntity,
+        descriptor: this.getDescriptor(inputInfo.existingEntity ? "update" /* Update */ : "create" /* Create */)
+      });
+      inputInfo.input = normalizedInput;
+      return normalizedInput;
+    });
+    const normalizedInputs = await Promise.all(normalizationPromises);
     const beforeEvents = [];
-    for (const entityInfo of entityInfoMap.values()) {
-      const operation = entityInfo.existingEntity ? "beforeUpdate" /* BeforeUpdate */ : "beforeCreate" /* BeforeCreate */;
-      entityInfo.operation = operation;
-      beforeEvents.push(new MutationEvent(this.getDescriptor(operation), entityInfo.input));
-    }
-    for (const input of inputsWithoutPrimaryKey) {
-      beforeEvents.push(new MutationEvent(this.getDescriptor("beforeCreate" /* BeforeCreate */), input));
+    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)));
     const results = await this.repository.bulkUpsert(normalizedInputs, options);
-    const resultsByPrimaryKey = new Map;
-    const resultsWithoutPrimaryKey = [];
-    for (const result of results) {
-      const pkValue = this.getPrimaryKeyValue(result);
-      if (pkValue !== undefined) {
-        resultsByPrimaryKey.set(pkValue, result);
-      } else {
-        resultsWithoutPrimaryKey.push(result);
-      }
-    }
     const afterEvents = [];
-    let resultsWithoutPkIndex = 0;
-    for (const entityInfo of entityInfoMap.values()) {
-      const matchedResult = resultsByPrimaryKey.get(entityInfo.primaryKeyValue);
-      const afterOperation = entityInfo.operation === "beforeCreate" /* BeforeCreate */ ? "afterCreate" /* AfterCreate */ : "afterUpdate" /* AfterUpdate */;
-      afterEvents.push(new MutationEvent(this.getDescriptor(afterOperation), entityInfo.input).setResult(matchedResult));
-    }
-    for (const input of inputsWithoutPrimaryKey) {
-      const matchedResult = resultsWithoutPrimaryKey[resultsWithoutPkIndex++];
-      afterEvents.push(new MutationEvent(this.getDescriptor("afterCreate" /* AfterCreate */), input).setResult(matchedResult));
+    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)));
@@ -13096,5 +13092,5 @@ export {
   BaseModelService
 };
 
-//# debugId=71BB4C5702006B2764756E2164756E21
+//# debugId=90127405F5173D2664756E2164756E21
 //# sourceMappingURL=index.js.map