@itwin/imodel-transformer 2.0.0-dev.4 → 2.0.0-dev.41

package/lib/cjs/IModelImporter.js

@@ -13,8 +13,11 @@ const core_bentley_1 = require("@itwin/core-bentley");
 const core_common_1 = require("@itwin/core-common");
 const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
 const core_backend_1 = require("@itwin/core-backend");
-const assert = require("assert");
+const node_assert_1 = require("node:assert");
 const ElementCascadingDeleter_1 = require("./ElementCascadingDeleter");
+const ElementAspectCleanup_1 = require("./ElementAspectCleanup");
+const ecschema_metadata_1 = require("@itwin/ecschema-metadata");
+const IModelTransformerError_1 = require("./IModelTransformerError");
 const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter;
 /** Base class for importing data into an iModel.
  * @see [iModel Transformation and Data Exchange]($docs/learning/transformer/index.md)
@@ -25,6 +28,23 @@ const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IMo
 class IModelImporter {
     /** The read/write target iModel. */
     targetDb;
+    /** The [[EditTxn]] used for write operations on the target iModel.
+     * @beta
+     */
+    _editTxn;
+    /** The [[EditTxn]] used for write operations on the target iModel.
+     * @beta
+     */
+    get editTxn() {
+        return this._editTxn;
+    }
+    _elementAspectCleanup;
+    /** Deletes replaceable ElementAspects through this importer's customized deletion callback.
+     * @internal
+     */
+    get elementAspectCleanup() {
+        return this._elementAspectCleanup;
+    }
     /** resolved initialization options for the importer
      * @beta
      */
@@ -71,11 +91,12 @@ class IModelImporter {
         "geometryGuid", // cannot compare GeometricModel.GeometryGuid values across iModels
     ]);
     /** Construct a new IModelImporter
-     * @param targetDb The target IModelDb
+     * @param editTxn The [[EditTxn]] to use for write operations on the target iModel. The target db is derived from `editTxn.iModel`.
      * @param options The options that specify how the import should be done.
      */
-    constructor(targetDb, options) {
-        this.targetDb = targetDb;
+    constructor(editTxn, options) {
+        this.targetDb = editTxn.iModel;
+        this._editTxn = editTxn;
         this.options = {
             autoExtendProjectExtents: options?.autoExtendProjectExtents ?? true,
             preserveElementIdsForFiltering: options?.preserveElementIdsForFiltering ?? false,
@@ -83,6 +104,7 @@ class IModelImporter {
             skipPropagateChangesToRootElements: options?.skipPropagateChangesToRootElements ?? true,
         };
         this._duplicateCodeValueMap = new Map();
+        this._elementAspectCleanup = new ElementAspectCleanup_1.ElementAspectCleanup(this.targetDb, this._editTxn, async (aspect) => this.onDeleteElementAspect(aspect));
     }
     /**
      * Checks [[IModelImportOptions.skipPropagateChangesToRootElements]], [[IModelImporter.rootElementIds]], and [[IModelImporter.doNotUpdateElementIds]] and returns true for 'do not update', false for do 'update'.
@@ -105,9 +127,15 @@ 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");
+            core_bentley_1.ITwinError.throwError({
+                iTwinErrorId: {
+                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                    key: IModelTransformerError_1.IModelTransformerError.InvalidModelId,
+                },
+                message: "Model Id not provided, should be the same as the ModeledElementId",
+            });
         if (this.doNotUpdateElement(modelProps.id)) {
             core_bentley_1.Logger.logInfo(loggerCategory, `Do not update target model ${modelProps.id}`);
             return;
@@ -115,14 +143,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;
@@ -131,29 +159,35 @@ 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);
+            const modelId = this._editTxn.insertModel(modelProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatModelForLogger(modelProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return modelId;
         }
         catch (error) {
             if (!this.targetDb.containsClass(modelProps.classFullName)) {
-                // replace standard insert error with something more helpful
-                const errorMessage = `Model class "${modelProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+                // Translate only confirmed missing-class failures; otherwise retain the backend error's identity.
+                core_bentley_1.ITwinError.throwError({
+                    iTwinErrorId: {
+                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                        key: IModelTransformerError_1.IModelTransformerError.TargetClassNotFound,
+                    },
+                    message: `Model class "${modelProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`,
+                    cause: error,
+                });
             }
-            throw error; // throw original error
+            throw error;
         }
     }
     /** 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) {
-        this.targetDb.models.updateModel(modelProps);
+    async onUpdateModel(modelProps) {
+        this._editTxn.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) {
@@ -164,18 +198,18 @@ 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) {
-                assert(elemProps.code.value !== undefined, "NULL code values are always considered unique and cannot clash");
+                (0, node_assert_1.strict)(elemProps.code.value !== undefined, "NULL code values are always considered unique and cannot clash");
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 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;
@@ -183,7 +217,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}`);
@@ -191,7 +225,13 @@ class IModelImporter {
         }
         if (this.options.preserveElementIdsForFiltering) {
             if (elementProps.id === undefined) {
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "elementProps.id must be defined during a preserveIds operation");
+                core_bentley_1.ITwinError.throwError({
+                    iTwinErrorId: {
+                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                        key: IModelTransformerError_1.IModelTransformerError.ElementIdRequired,
+                    },
+                    message: "elementProps.id must be defined during a preserveIds operation",
+                });
             }
             // Categories are the only element that onInserted will immediately insert a new element (their default subcategory)
             // since default subcategories always exist and always will be inserted after their categories, we treat them as an update
@@ -199,24 +239,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;
@@ -225,16 +265,15 @@ 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) {
-        /* eslint-disable @typescript-eslint/no-deprecated */
+    async onInsertElement(elementProps) {
         try {
-            const elementId = this.targetDb.elements.insertElement(elementProps, {
+            const elementId = this._editTxn.insertElement(elementProps, {
                 forceUseId: this.options.preserveElementIdsForFiltering,
             });
             // 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,
@@ -246,26 +285,35 @@ class IModelImporter {
         }
         catch (error) {
             if (!this.targetDb.containsClass(elementProps.classFullName)) {
-                // replace standard insert error with something more helpful
-                const errorMessage = `Element class "${elementProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+                core_bentley_1.ITwinError.throwError({
+                    iTwinErrorId: {
+                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                        key: IModelTransformerError_1.IModelTransformerError.TargetClassNotFound,
+                    },
+                    message: `Element class "${elementProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`,
+                    cause: error,
+                });
             }
-            throw error; // throw original error
+            throw error;
         }
-        /* eslint-enable @typescript-eslint/no-deprecated */
     }
     /** 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");
+            core_bentley_1.ITwinError.throwError({
+                iTwinErrorId: {
+                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                    key: IModelTransformerError_1.IModelTransformerError.ElementIdRequired,
+                },
+                message: "ElementId not provided",
+            });
         }
-        this.targetDb.elements.updateElement(elementProps);
+        this._editTxn.updateElement(elementProps);
         core_bentley_1.Logger.logInfo(loggerCategory, `Updated ${this.formatElementForLogger(elementProps)}`);
-        this.trackProgress();
+        await this.trackProgress();
         if (this.options.simplifyElementGeometry) {
-            /* eslint-disable-next-line @typescript-eslint/no-deprecated */
             this.targetDb.simplifyElementGeometry({
                 id: elementProps.id,
                 convertBReps: true,
@@ -277,30 +325,30 @@ 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) {
-        (0, ElementCascadingDeleter_1.deleteElementTreeCascade)(this.targetDb, elementId);
+    async onDeleteElement(elementId) {
+        (0, ElementCascadingDeleter_1.deleteElementTreeCascade)(this._editTxn, 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`.
      */
-    onDeleteModel(modelId) {
-        this.targetDb.models.deleteModel(modelId);
+    async onDeleteModel(modelId) {
+        this._editTxn.deleteModel(modelId);
         core_bentley_1.Logger.logInfo(loggerCategory, `Deleted model ${modelId}`);
-        this.trackProgress();
+        await this.trackProgress();
     }
     /** Delete the specified Model from the target iModel. */
-    deleteModel(modelId) {
-        this.onDeleteModel(modelId);
+    async deleteModel(modelId) {
+        await this.onDeleteModel(modelId);
     }
     /** Format an Element for the Logger. */
     formatElementForLogger(elementProps) {
@@ -312,14 +360,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;
     }
@@ -329,7 +377,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);
@@ -337,91 +385,96 @@ class IModelImporter {
             return result;
         }
         const elementId = aspectPropsArray[0].element.id;
-        // Determine the set of ElementMultiAspect classes to consider
-        const aspectClassFullNames = new Set();
-        aspectPropsArray.forEach((aspectsProps) => {
-            aspectClassFullNames.add(aspectsProps.classFullName);
+        const proposedAspectsByClass = new Map();
+        aspectPropsArray.forEach((props, index) => {
+            const proposedAspects = proposedAspectsByClass.get(props.classFullName) ?? [];
+            proposedAspects.push({ props, index });
+            proposedAspectsByClass.set(props.classFullName, proposedAspects);
         });
         // Handle ElementMultiAspects in groups by class
-        aspectClassFullNames.forEach((aspectClassFullName) => {
-            const proposedAspects = aspectPropsArray
-                .map((props, index) => ({ props, index }))
-                .filter(({ props }) => aspectClassFullName === props.classFullName);
+        for (const [aspectClassFullName, proposedAspects,] of proposedAspectsByClass) {
             const currentAspects = this.targetDb.elements
                 .getAspects(elementId, aspectClassFullName)
                 .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) => {
-                    let id;
+                for (let index = 0; index < currentAspects.length; index++) {
+                    const { props } = currentAspects[index];
                     if (index < proposedAspects.length) {
-                        id = props.id;
-                        proposedAspects[index].props.id = id;
-                        if (hasEntityChanged(props, proposedAspects[index].props)) {
-                            this.onUpdateElementAspect(proposedAspects[index].props);
+                        const { props: proposedProps, index: resultIndex } = proposedAspects[index];
+                        const id = props.id;
+                        proposedProps.id = id;
+                        if (hasEntityChanged(props, proposedProps)) {
+                            await this.onUpdateElementAspect(proposedProps);
                         }
                         result[resultIndex] = id;
                     }
                     else {
-                        this.onDeleteElementAspect(props);
+                        await this.onDeleteElementAspect(props);
                     }
-                });
+                }
             }
-        });
-        assert(result.every((r) => typeof r !== undefined));
+        }
+        (0, node_assert_1.strict)(result.every((r) => 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);
+            const id = this._editTxn.insertAspect(aspectProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatElementAspectForLogger(aspectProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return id;
         }
         catch (error) {
             if (!this.targetDb.containsClass(aspectProps.classFullName)) {
-                // replace standard insert error with something more helpful
-                const errorMessage = `ElementAspect class "${aspectProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+                core_bentley_1.ITwinError.throwError({
+                    iTwinErrorId: {
+                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                        key: IModelTransformerError_1.IModelTransformerError.TargetClassNotFound,
+                    },
+                    message: `ElementAspect class "${aspectProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`,
+                    cause: error,
+                });
             }
-            throw error; // throw original error
+            throw error;
         }
     }
     /** 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) {
-        this.targetDb.elements.updateAspect(aspectProps);
+    async onUpdateElementAspect(aspectProps) {
+        this._editTxn.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) {
-        this.targetDb.elements.deleteAspect(targetElementAspect.id);
+    async onDeleteElementAspect(targetElementAspect) {
+        this._editTxn.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) {
@@ -430,7 +483,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`);
@@ -451,7 +504,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;
         }
@@ -463,62 +516,73 @@ 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);
+            const targetRelInstanceId = this._editTxn.insertRelationship(relationshipProps);
             core_bentley_1.Logger.logInfo(loggerCategory, `Inserted ${this.formatRelationshipForLogger(relationshipProps)}`);
-            this.trackProgress();
+            await this.trackProgress();
             return targetRelInstanceId;
         }
         catch (error) {
             if (!this.targetDb.containsClass(relationshipProps.classFullName)) {
-                // replace standard insert error with something more helpful
-                const errorMessage = `Relationship class "${relationshipProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`;
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidName, errorMessage);
+                core_bentley_1.ITwinError.throwError({
+                    iTwinErrorId: {
+                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                        key: IModelTransformerError_1.IModelTransformerError.TargetClassNotFound,
+                    },
+                    message: `Relationship class "${relationshipProps.classFullName}" not found in the target iModel. Was the latest version of the schema imported?`,
+                    cause: error,
+                });
             }
-            throw error; // throw original error
+            throw error;
         }
     }
     /** 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");
+            core_bentley_1.ITwinError.throwError({
+                iTwinErrorId: {
+                    scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                    key: IModelTransformerError_1.IModelTransformerError.RelationshipIdRequired,
+                },
+                message: "Relationship instance Id not provided",
+            });
         }
-        this.targetDb.relationships.updateInstance(relationshipProps);
+        this._editTxn.updateRelationship(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({
+        this._editTxn.deleteRelationship({
             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]]
@@ -535,13 +599,15 @@ 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);
+                this._editTxn.updateProjectExtents(newProjectExtents);
                 core_bentley_1.Logger.logInfo(loggerCategory, `Updated projectExtents=${JSON.stringify(this.targetDb.projectExtents)}`);
             }
             if (!excludeOutliers &&
@@ -566,7 +632,6 @@ class IModelImporter {
      */
     optimizeGeometry(options) {
         if (options.inlineUniqueGeometryParts) {
-            /* eslint-disable-next-line @typescript-eslint/no-deprecated */
             const result = this.targetDb.inlineGeometryParts();
             core_bentley_1.Logger.logInfo(loggerCategory, `Inlined ${result.numRefsInlined} references to ${result.numCandidateParts} geometry parts and deleted ${result.numPartsDeleted} parts.`);
         }
@@ -575,7 +640,7 @@ class IModelImporter {
         for (const [elementId, codeValue] of this._duplicateCodeValueMap) {
             const element = this.targetDb.elements.getElement(elementId);
             element.code.value = codeValue;
-            element.update();
+            this._editTxn.updateElement(element.toJSON());
         }
         this._duplicateCodeValueMap.clear();
     }
@@ -598,22 +663,26 @@ exports.IModelImporter = IModelImporter;
  */
 function hasEntityChanged(entity, entityProps, namesToIgnore) {
     let changed = false;
-    entity.forEachProperty((propertyName, propertyMeta) => {
+    const entityClass = entity.iModel.schemaContext.getSchemaItemSync(entity.schemaItemKey);
+    (0, node_assert_1.strict)(ecschema_metadata_1.EntityClass.isEntityClass(entityClass) ||
+        ecschema_metadata_1.RelationshipClass.isRelationshipClass(entityClass), `Cannot get metadata for ${entity.classFullName}.`);
+    for (const property of entityClass.getPropertiesSync()) {
+        const propertyName = property.name;
         if (!changed) {
             if (namesToIgnore && namesToIgnore.has(propertyName)) {
                 // skip
             }
-            else if (core_common_1.PrimitiveTypeCode.Binary === propertyMeta.primitiveType) {
-                changed = hasBinaryValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+            else if (ecschema_metadata_1.PropertyType.Binary === property.propertyType) {
+                changed = hasBinaryValueChanged(entity.asAny[core_common_1.ECJsNames.toJsName(propertyName)], entityProps[core_common_1.ECJsNames.toJsName(propertyName)]);
             }
-            else if (propertyMeta.isNavigation) {
-                changed = hasNavigationValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+            else if (property.isNavigation()) {
+                changed = hasNavigationValueChanged(entity.asAny[core_common_1.ECJsNames.toJsName(propertyName)], entityProps[core_common_1.ECJsNames.toJsName(propertyName)]);
             }
             else {
-                changed = hasValueChanged(entity.asAny[propertyName], entityProps[propertyName]);
+                changed = hasValueChanged(entity.asAny[core_common_1.ECJsNames.toJsName(propertyName)], entityProps[core_common_1.ECJsNames.toJsName(propertyName)]);
             }
         }
-    });
+    }
     return changed;
 }
 /** Returns true if the specified binary values are different. */
@@ -643,9 +712,21 @@ function isDefaultSubCategory(props) {
     if (props.id === undefined)
         return false;
     if (!core_bentley_1.Id64.isId64(props.id))
-        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "subcategory had invalid id");
+        core_bentley_1.ITwinError.throwError({
+            iTwinErrorId: {
+                scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                key: IModelTransformerError_1.IModelTransformerError.InvalidSubCategory,
+            },
+            message: "subcategory had invalid id",
+        });
     if (props.parent?.id === undefined)
-        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, `subcategory with id ${props.id} had no parent`);
+        core_bentley_1.ITwinError.throwError({
+            iTwinErrorId: {
+                scope: IModelTransformerError_1.IModelTransformerErrorScope,
+                key: IModelTransformerError_1.IModelTransformerError.InvalidSubCategory,
+            },
+            message: `subcategory with id ${props.id} had no parent`,
+        });
     return props.id === core_backend_1.IModelDb.getDefaultSubCategoryId(props.parent.id);
 }
 //# sourceMappingURL=IModelImporter.js.map