@itwin/imodel-transformer 2.0.0-dev.10 → 2.0.0-dev.12

package/lib/cjs/IModelImporter.js

@@ -106,7 +106,7 @@ class IModelImporter {
         this._elementsToUpdateDuringPreserveIds.add(elementId);
     }
     /** Import the specified ModelProps (either as an insert or an update) into the target iModel. */
-    importModel(modelProps) {
+    async importModel(modelProps) {
         if (undefined === modelProps.id || !core_bentley_1.Id64.isValidId64(modelProps.id))
             throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Model Id not provided, should be the same as the ModeledElementId");
         if (this.doNotUpdateElement(modelProps.id)) {
@@ -116,14 +116,14 @@ class IModelImporter {
         try {
             const model = this.targetDb.models.getModel(modelProps.id); // throws IModelError.NotFound if model does not exist
             if (hasEntityChanged(model, modelProps, this._modelPropertiesToIgnore)) {
-                this.onUpdateModel(modelProps);
+                await this.onUpdateModel(modelProps);
             }
         }
         catch (error) {
             // catch NotFound error and insertModel
             if (error instanceof core_common_1.IModelError &&
                 error.errorNumber === core_bentley_1.IModelStatus.NotFound) {
-                this.onInsertModel(modelProps);
+                await this.onInsertModel(modelProps);
                 return;
             }
             throw error;
@@ -132,11 +132,11 @@ class IModelImporter {
     /** Create a new Model from the specified ModelProps and insert it into the target iModel.
      * @note A subclass may override this method to customize insert behavior but should call `super.onInsertModel`.
      */
-    onInsertModel(modelProps) {
+    async onInsertModel(modelProps) {
         try {
             const modelId = this.targetDb.models.insertModel(modelProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatModelForLogger(modelProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return modelId;
         }
         catch (error) {
@@ -151,10 +151,10 @@ class IModelImporter {
     /** Update an existing Model in the target iModel from the specified ModelProps.
      * @note A subclass may override this method to customize update behavior but should call `super.onUpdateModel`.
      */
-    onUpdateModel(modelProps) {
+    async onUpdateModel(modelProps) {
         this.targetDb.models.updateModel(modelProps);
         core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatModelForLogger(modelProps)}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Format a Model for the Logger. */
     formatModelForLogger(modelProps) {
@@ -165,9 +165,9 @@ class IModelImporter {
      * Tries to update an element with the specified element properties.
      * If a duplicate code error occurs, it assigns a new unique code value and retries the update
      */
-    tryUpdateElement(elemProps) {
+    async tryUpdateElement(elemProps) {
         try {
-            this.onUpdateElement(elemProps);
+            await this.onUpdateElement(elemProps);
         }
         catch (err) {
             if (err.errorNumber === core_bentley_1.IModelStatus.DuplicateCode) {
@@ -176,7 +176,7 @@ class IModelImporter {
                 this._duplicateCodeValueMap.set(elemProps.id, elemProps.code.value);
                 // Using NULL code values as an alternative is not valid because definition elements cannot have NULL code values.
                 elemProps.code.value = core_bentley_1.Guid.createValue();
-                this.onUpdateElement(elemProps);
+                await this.onUpdateElement(elemProps);
             }
             else {
                 throw err;
@@ -184,7 +184,7 @@ class IModelImporter {
         }
     }
     /** Import the specified ElementProps (either as an insert or an update) into the target iModel. */
-    importElement(elementProps) {
+    async importElement(elementProps) {
         if (undefined !== elementProps.id &&
             this.doNotUpdateElement(elementProps.id)) {
             core_bentley_1.Logger.logInfo(loggerCategory, `Do not update target element ${elementProps.id}`);
@@ -200,24 +200,24 @@ class IModelImporter {
             // Always present elements (0xe, 0x1, 0x10) also will be updated to prevent duplicate inserts.
             if ((isSubCategory(elementProps) && isDefaultSubCategory(elementProps)) ||
                 this._rootElementIds.has(elementProps.id)) {
-                this.onUpdateElement(elementProps);
+                await this.onUpdateElement(elementProps);
             }
             else {
                 if (this._elementsToUpdateDuringPreserveIds.has(elementProps.id)) {
-                    this.tryUpdateElement(elementProps);
+                    await this.tryUpdateElement(elementProps);
                     this._elementsToUpdateDuringPreserveIds.delete(elementProps.id);
                 }
                 else {
-                    this.onInsertElement(elementProps);
+                    await this.onInsertElement(elementProps);
                 }
             }
         }
         else {
             if (undefined !== elementProps.id) {
-                this.tryUpdateElement(elementProps);
+                await this.tryUpdateElement(elementProps);
             }
             else {
-                elementProps.id = this.onInsertElement(elementProps); // targetElementProps.id assigned by insertElement
+                elementProps.id = await this.onInsertElement(elementProps); // targetElementProps.id assigned by insertElement
             }
         }
         return elementProps.id;
@@ -226,7 +226,7 @@ class IModelImporter {
      * @returns The Id of the newly inserted Element.
      * @note A subclass may override this method to customize insert behavior but should call `super.onInsertElement`.
      */
-    onInsertElement(elementProps) {
+    async onInsertElement(elementProps) {
         try {
             const elementId = this.targetDb.elements.insertElement(elementProps, {
                 forceUseId: this.options.preserveElementIdsForFiltering,
@@ -234,7 +234,7 @@ class IModelImporter {
             // set the id like [IModelDb.insertElement]($backend), does, the raw nativeDb method does not
             elementProps.id = elementId;
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatElementForLogger(elementProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             if (this.options.simplifyElementGeometry) {
                 this.targetDb.simplifyElementGeometry({
                     id: elementId,
@@ -256,13 +256,13 @@ class IModelImporter {
     /** Update an existing Element in the target iModel from the specified ElementProps.
      * @note A subclass may override this method to customize update behavior but should call `super.onUpdateElement`.
      */
-    onUpdateElement(elementProps) {
+    async onUpdateElement(elementProps) {
         if (!elementProps.id) {
             throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "ElementId not provided");
         }
         this.targetDb.elements.updateElement(elementProps);
         core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatElementForLogger(elementProps)}`);
-        this.trackProgress();
+        await this.trackProgress();
         if (this.options.simplifyElementGeometry) {
             this.targetDb.simplifyElementGeometry({
                 id: elementProps.id,
@@ -275,18 +275,18 @@ class IModelImporter {
      * Will delete special elements like definition elements and subjects.
      * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteElement`.
      */
-    onDeleteElement(elementId) {
+    async onDeleteElement(elementId) {
         (0, ElementCascadingDeleter_1.deleteElementTreeCascade)(this.targetDb, elementId);
         core_bentley_1.Logger.logInfo(loggerCategory, `Deleted element ${elementId} and its descendants`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified Element from the target iModel. */
-    deleteElement(elementId) {
+    async deleteElement(elementId) {
         if (this.doNotUpdateElement(elementId)) {
             core_bentley_1.Logger.logInfo(loggerCategory, `Do not delete target element ${elementId}`);
             return;
         }
-        this.onDeleteElement(elementId);
+        await this.onDeleteElement(elementId);
     }
     /** Delete the specified Model from the target iModel.
      * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteModel`.
@@ -294,7 +294,7 @@ class IModelImporter {
     async onDeleteModel(modelId) {
         this.targetDb.models.deleteModel(modelId);
         core_bentley_1.Logger.logInfo(loggerCategory, `Deleted model ${modelId}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified Model from the target iModel. */
     async deleteModel(modelId) {
@@ -310,14 +310,14 @@ class IModelImporter {
         return `${elementProps.classFullName} ${namePiece}[${elementProps.id}]`;
     }
     /** Import an ElementUniqueAspect into the target iModel. */
-    importElementUniqueAspect(aspectProps) {
+    async importElementUniqueAspect(aspectProps) {
         const aspects = this.targetDb.elements.getAspects(aspectProps.element.id, aspectProps.classFullName);
         if (aspects.length === 0) {
             return this.onInsertElementAspect(aspectProps);
         }
         else if (hasEntityChanged(aspects[0], aspectProps)) {
             aspectProps.id = aspects[0].id;
-            this.onUpdateElementAspect(aspectProps);
+            await this.onUpdateElementAspect(aspectProps);
         }
         return aspects[0].id;
     }
@@ -327,7 +327,7 @@ class IModelImporter {
      * @note For insert vs. update reasons, it is important to process all ElementMultiAspects owned by an Element at once since we don't have aspect-specific provenance.
      * @returns the array of ids of the resulting ElementMultiAspects, in the same order of the aspectPropsArray parameter
      */
-    importElementMultiAspects(aspectPropsArray, 
+    async importElementMultiAspects(aspectPropsArray, 
     /** caller must use this to enforce any aspects added by IModelTransformer are not considered for update */
     filterFunc = () => true) {
         const result = new Array(aspectPropsArray.length).fill(undefined);
@@ -341,7 +341,7 @@ class IModelImporter {
             aspectClassFullNames.add(aspectsProps.classFullName);
         });
         // Handle ElementMultiAspects in groups by class
-        aspectClassFullNames.forEach((aspectClassFullName) => {
+        for (const aspectClassFullName of aspectClassFullNames) {
             const proposedAspects = aspectPropsArray
                 .map((props, index) => ({ props, index }))
                 .filter(({ props }) => aspectClassFullName === props.classFullName);
@@ -350,50 +350,52 @@ class IModelImporter {
                 .map((props, index) => ({ props, index }))
                 .filter(({ props }) => filterFunc(props));
             if (proposedAspects.length >= currentAspects.length) {
-                proposedAspects.forEach(({ props, index: resultIndex }, index) => {
+                for (let index = 0; index < proposedAspects.length; index++) {
+                    const { props, index: resultIndex } = proposedAspects[index];
                     let id;
                     if (index < currentAspects.length) {
                         id = currentAspects[index].props.id;
                         props.id = id;
                         if (hasEntityChanged(currentAspects[index].props, props)) {
-                            this.onUpdateElementAspect(props);
+                            await this.onUpdateElementAspect(props);
                         }
                         id = props.id;
                     }
                     else {
-                        id = this.onInsertElementAspect(props);
+                        id = await this.onInsertElementAspect(props);
                     }
                     result[resultIndex] = id;
-                });
+                }
             }
             else {
-                currentAspects.forEach(({ props, index: resultIndex }, index) => {
+                for (let index = 0; index < currentAspects.length; index++) {
+                    const { props, index: resultIndex } = currentAspects[index];
                     let id;
                     if (index < proposedAspects.length) {
                         id = props.id;
                         proposedAspects[index].props.id = id;
                         if (hasEntityChanged(props, proposedAspects[index].props)) {
-                            this.onUpdateElementAspect(proposedAspects[index].props);
+                            await this.onUpdateElementAspect(proposedAspects[index].props);
                         }
                         result[resultIndex] = id;
                     }
                     else {
-                        this.onDeleteElementAspect(props);
+                        await this.onDeleteElementAspect(props);
                     }
-                });
+                }
             }
-        });
+        }
         assert(result.every((r) => typeof r !== undefined));
         return result;
     }
     /** Insert the ElementAspect into the target iModel.
      * @note A subclass may override this method to customize insert behavior but should call `super.onInsertElementAspect`.
      */
-    onInsertElementAspect(aspectProps) {
+    async onInsertElementAspect(aspectProps) {
         try {
             const id = this.targetDb.elements.insertAspect(aspectProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatElementAspectForLogger(aspectProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return id;
         }
         catch (error) {
@@ -408,18 +410,18 @@ class IModelImporter {
     /** Update the ElementAspect within the target iModel.
      * @note A subclass may override this method to customize update behavior but should call `super.onUpdateElementAspect`.
      */
-    onUpdateElementAspect(aspectProps) {
+    async onUpdateElementAspect(aspectProps) {
         this.targetDb.elements.updateAspect(aspectProps);
         core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatElementAspectForLogger(aspectProps)}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified ElementAspect from the target iModel.
      * @note A subclass may override this method to customize delete behavior but should call `super.onDeleteElementAspect`.
      */
-    onDeleteElementAspect(targetElementAspect) {
+    async onDeleteElementAspect(targetElementAspect) {
         this.targetDb.elements.deleteAspect(targetElementAspect.id);
         core_bentley_1.Logger.logInfo(loggerCategory, `Deleted ${this.formatElementAspectForLogger(targetElementAspect)}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Format an ElementAspect for the Logger. */
     formatElementAspectForLogger(elementAspectProps) {
@@ -428,7 +430,7 @@ class IModelImporter {
     /** Import the specified RelationshipProps (either as an insert or an update) into the target iModel.
      * @returns The instance Id of the inserted or updated Relationship.
      */
-    importRelationship(relationshipProps) {
+    async importRelationship(relationshipProps) {
         if (undefined === relationshipProps.sourceId ||
             !core_bentley_1.Id64.isValidId64(relationshipProps.sourceId)) {
             core_bentley_1.Logger.logInfo(loggerCategory, `Ignoring ${relationshipProps.classFullName} instance because of invalid RelationshipProps.sourceId`);
@@ -449,7 +451,7 @@ class IModelImporter {
             // if relationship found, update it
             relationshipProps.id = relationship.id;
             if (hasEntityChanged(relationship, relationshipProps)) {
-                this.onUpdateRelationship(relationshipProps);
+                await this.onUpdateRelationship(relationshipProps);
             }
             return relationshipProps.id;
         }
@@ -461,11 +463,11 @@ class IModelImporter {
      * @returns The instance Id of the newly inserted relationship.
      * @note A subclass may override this method to customize insert behavior but should call `super.onInsertRelationship`.
      */
-    onInsertRelationship(relationshipProps) {
+    async onInsertRelationship(relationshipProps) {
         try {
             const targetRelInstanceId = this.targetDb.relationships.insertInstance(relationshipProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatRelationshipForLogger(relationshipProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return targetRelInstanceId;
         }
         catch (error) {
@@ -480,43 +482,43 @@ class IModelImporter {
     /** Update an existing Relationship in the target iModel from the specified RelationshipProps.
      * @note A subclass may override this method to customize update behavior but should call `super.onUpdateRelationship`.
      */
-    onUpdateRelationship(relationshipProps) {
+    async onUpdateRelationship(relationshipProps) {
         if (!relationshipProps.id) {
             throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Relationship instance Id not provided");
         }
         this.targetDb.relationships.updateInstance(relationshipProps);
         core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatRelationshipForLogger(relationshipProps)}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified Relationship from the target iModel. */
-    onDeleteRelationship(relationshipProps) {
+    async onDeleteRelationship(relationshipProps) {
         // Only passing in what deleteInstance actually uses, full relationshipProps is not necessary.
         this.targetDb.relationships.deleteInstance({
             id: relationshipProps.id,
             classFullName: relationshipProps.classFullName,
         });
         core_bentley_1.Logger.logInfo(loggerCategory, `Deleted relationship ${relationshipProps.classFullName} id=${relationshipProps.id}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified Relationship from the target iModel. */
-    deleteRelationship(relationshipProps) {
-        this.onDeleteRelationship(relationshipProps);
+    async deleteRelationship(relationshipProps) {
+        await this.onDeleteRelationship(relationshipProps);
     }
     /** Format a Relationship for the Logger. */
     formatRelationshipForLogger(relProps) {
         return `${relProps.classFullName} sourceId=[${relProps.sourceId}] targetId=[${relProps.targetId}]`;
     }
     /** Tracks incremental progress */
-    trackProgress() {
+    async trackProgress() {
         this._progressCounter++;
         if (0 === this._progressCounter % this.progressInterval) {
-            this.onProgress();
+            await this.onProgress();
         }
     }
     /** This method is called when IModelImporter has made incremental progress based on the [[progressInterval]] setting.
      * @note A subclass may override this method to report custom progress but should call `super.onProgress`.
      */
-    onProgress() { }
+    async onProgress() { }
     /** Optionally compute the projectExtents for the target iModel depending on the options for this IModelImporter.
      * @note This method is automatically called from [IModelTransformer.process]($transformer).
      * @see [IModelDb.computeProjectExtents]($backend), [[autoExtendProjectExtents]]
@@ -533,11 +535,13 @@ class IModelImporter {
             const excludeOutliers = typeof this.options.autoExtendProjectExtents === "object"
                 ? this.options.autoExtendProjectExtents.excludeOutliers
                 : false;
-            // If excludeOutliers is true, use the extents without outliers. If extentsWithOutliers is undefined, fall back to extents.
-            const newProjectExtents = excludeOutliers
-                ? computedProjectExtents.extents
-                : (computedProjectExtents.extentsWithOutliers ??
-                    computedProjectExtents.extents);
+            // If excludeOutliers is true, use the extents without outliers.
+            // Otherwise prefer extentsWithOutliers, but fall back to extents if it's undefined or a null range.
+            const extentsWithOutliers = computedProjectExtents.extentsWithOutliers;
+            const useExtentsWithOutliers = !excludeOutliers && extentsWithOutliers && !extentsWithOutliers.isNull;
+            const newProjectExtents = useExtentsWithOutliers
+                ? extentsWithOutliers
+                : computedProjectExtents.extents;
             if (!newProjectExtents.isAlmostEqual(this.targetDb.projectExtents)) {
                 this.targetDb.updateProjectExtents(newProjectExtents);
                 core_bentley_1.Logger.logInfo(loggerCategory, `Updated projectExtents=${JSON.stringify(this.targetDb.projectExtents)}`);