@itwin/imodel-transformer 2.0.0-dev.67 → 2.0.0-dev.69

package/lib/cjs/IModelTransformer.js

@@ -61,6 +61,10 @@ const SchemaProcessingCoordinator_1 = require("./schema-processing/SchemaProcess
 const ChangesetScanner_1 = require("./ChangesetScanner");
 const IModelTransformerError_1 = require("./IModelTransformerError");
 const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelTransformer;
+/** Key of a relationship's source and target element ids. */
+function relationshipEndpointsKey(sourceId, targetId) {
+    return `${sourceId}|${targetId}`;
+}
 /**
  * Apply a function to each Id64 in a supported container type of Id64s.
  * Currently only supports raw Id64String or RelatedElement-like objects containing an `id` property that is a Id64String,
@@ -537,8 +541,14 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const combinedTransform = targetTransformInv.multiplyTransformTransform(srcTransform);
         return combinedTransform;
     }
-    // if undefined, it can be initialized by calling [[this.processChangesets]]
+    // if undefined, it can be initialized by calling [[this.prepareSourceChanges]]
     _deletedSourceRelationshipData = undefined;
+    /** Target relationship ids and target endpoint keys of [[_deletedSourceRelationshipData]] entries, for fast matching in [[onExportRelationship]]. */
+    _pendingRelationshipDeleteTargets = new Set();
+    /** Target relationships that this run imported from a source relationship and that a pending relationship delete also resolves to.
+     * A source relationship deleted and recreated with the same endpoints maps to the same target relationship, which must not be deleted.
+     */
+    _reimportedTargetRelationshipIds = new Set();
     /** Returns true if a change within sourceElement is detected.
      * @param sourceElement The Element from the source iModel
      * @note A subclass can override this method to provide custom change detection behavior.
@@ -1152,6 +1162,12 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async onExportRelationship(sourceRelationship, _isUpdate, sourceFedGuid, targetFedGuid) {
         const targetRelationshipProps = this.onTransformRelationship(sourceRelationship);
         const targetRelationshipInstanceId = await this.importer.importRelationship(targetRelationshipProps);
+        if (this._pendingRelationshipDeleteTargets.size > 0 &&
+            core_bentley_1.Id64.isValid(targetRelationshipInstanceId) &&
+            (this._pendingRelationshipDeleteTargets.has(targetRelationshipInstanceId) ||
+                this._pendingRelationshipDeleteTargets.has(relationshipEndpointsKey(targetRelationshipProps.sourceId, targetRelationshipProps.targetId)))) {
+            this._reimportedTargetRelationshipIds.add(targetRelationshipInstanceId);
+        }
         const provenanceDb = await this.getProvenanceDb();
         const provenanceEditTxn = await this._provenanceManager.getProvenanceEditTxn();
         if (!this._options.noProvenance &&
@@ -1189,7 +1205,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 sourceId: deletedRelData.sourceIdInTarget,
                 targetId: deletedRelData.targetIdInTarget,
             })?.id;
-        if (id) {
+        if (id && this._reimportedTargetRelationshipIds.has(id)) {
+            // The source relationship was recreated with the same endpoints and already imported into this target relationship.
+            core_bentley_1.Logger.logTrace(loggerCategory, `Skipping delete of target relationship ${id} because source relationship ${sourceRelInstanceId} was recreated`);
+        }
+        else if (id) {
             await this.importer.deleteRelationship({
                 id,
                 classFullName: deletedRelData.classFullName,
@@ -1370,9 +1390,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     /** state to prevent reinitialization, @see [[initialize]] */
     _initialized = false;
     _sourceChangeDataState = "uninited";
-    /** length === 0 when _changeDataState = "no-change", length > 0 means "has-changes", otherwise undefined  */
-    _csFileProps = undefined;
-    _deletionRecordsByChangeset;
+    _deletionBatches;
     /**
      * Initialize prerequisites of processing, you must initialize with an [[InitOptions]] if you
      * are intending to process changes. Callers may wish to explicitly call initialize if they need to execute code after initialize but before [[process]] is called.
@@ -1388,22 +1406,28 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         await this._cloneContext.initialize();
         const exporterInitOptions = await this.getExportInitOpts(this._options.argsForProcessChanges ?? {});
         await this.initializeChangesetScanAndExporter(exporterInitOptions);
-        // Exporter must be initialized prior to processing changesets in order to properly handle entity recreations (an entity delete followed by an insert of that same entity).
-        await this.processChangesets();
+        // Exporter must be initialized prior to remapping deletions in order to properly handle entity recreations (an entity delete followed by an insert of that same entity).
+        await this.prepareSourceChanges();
         this._initialized = true;
     }
     async initializeChangesetScanAndExporter(exporterInitOptions) {
-        if (this._csFileProps !== undefined &&
-            this._csFileProps.length > 0 &&
+        const ranges = this._changesetRanges;
+        if (ranges !== undefined &&
+            ranges.length > 0 &&
             this.sourceDb.isBriefcaseDb()) {
-            const changedInstanceIds = this.exporter.sourceDbChanges ??
+            let changedInstanceIds = this.exporter.sourceDbChanges ??
                 ("changedInstanceIds" in exporterInitOptions
                     ? exporterInitOptions.changedInstanceIds
-                    : new IModelExporter_1.ChangedInstanceIds(this.sourceDb));
-            this._deletionRecordsByChangeset = await ChangesetScanner_1.ChangesetScanner.scan(this.sourceDb, this._csFileProps, changedInstanceIds, {
-                populateChangedInstanceIds: this.exporter.sourceDbChanges === undefined &&
-                    !("changedInstanceIds" in exporterInitOptions),
-            });
+                    : undefined);
+            if (changedInstanceIds !== undefined) {
+                // The caller supplied changed IDs, so only deletion metadata is read.
+                this._deletionBatches = await ChangesetScanner_1.ChangesetScanner.scan(this.sourceDb, await ChangesetScanner_1.ChangesetScanner.download(this.sourceDb, ranges), {});
+            }
+            else {
+                const scanResult = await this.collectChanges(ranges);
+                changedInstanceIds = scanResult.changedInstanceIds;
+                this._deletionBatches = scanResult.deletionBatches;
+            }
             await this.exporter.initialize({
                 changedInstanceIds,
                 skipPropagateChangesToRootElements: exporterInitOptions.skipPropagateChangesToRootElements,
@@ -1414,19 +1438,42 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
     }
     /**
-     * Reads all the changeset files in the private member of the transformer: _csFileProps
-     * and finds the corresponding target entity for any deleted source entities and remaps the sourceId to the targetId.
-     * This function returns early if csFileProps is undefined or is of length 0.
-     * @returns void
+     * Reads the source changes for the changeset ranges being processed. Override to supply changes from another
+     * source, such as a precomputed cache, instead of downloading and reading changesets.
+     *
+     * An override can supply some ranges itself and pass the rest to `super.collectChanges()`. Pass the same
+     * `changedInstanceIds` to every call and handle the ranges in order, so that changes to the same instance in
+     * different ranges combine correctly. Use [[ChangedInstanceIds.addChangeRecord]] to add each supplied change.
+     * See [Supplying source changes]($docs/learning/transformer/change-scanning.md) for the full contract and an example.
+     * @param ranges Ordered, inclusive `[first, last]` changeset index ranges. They already exclude changesets
+     * that must be skipped, such as those pushed by a previous synchronization in the other direction, so an
+     * override must cover exactly these ranges.
+     * @param changedInstanceIds Receives the changes read from the ranges. Defaults to a new, empty instance.
+     * @returns The changed instance IDs to export and the records used to find the targets of deleted instances.
+     * See [[CollectedChanges]] for what the result must include.
+     * @note The default implementation downloads the changesets, reads them with `ChangesetReader`, and returns one
+     * deletion batch per range.
+     * @note Not called when the exporter already has changed instance IDs, for example when `changedInstanceIds`
+     * is passed in [[IModelTransformOptions.argsForProcessChanges]]. The transformer then still downloads and reads
+     * the changesets to find deletion records.
+     * @beta
+     */
+    async collectChanges(ranges, changedInstanceIds = new IModelExporter_1.ChangedInstanceIds(this.sourceDb)) {
+        const deletionBatches = await ChangesetScanner_1.ChangesetScanner.scan(this.sourceDb, await ChangesetScanner_1.ChangesetScanner.download(this.sourceDb, ranges), { changedInstanceIds });
+        return { changedInstanceIds, deletionBatches };
+    }
+    /**
+     * Remaps tracked elements, adds custom changes, and remaps deleted source entities to their targets using the
+     * deletion batches read for the changeset ranges being processed.
      */
-    async processChangesets() {
+    async prepareSourceChanges() {
         await this._provenanceManager.forEachTrackedElement((sourceElementId, targetElementId) => {
             this.context.remapElement(sourceElementId, targetElementId);
         });
         if (this.exporter.sourceDbChanges)
             await this.addCustomChanges(this.exporter.sourceDbChanges);
-        const csFileProps = this._csFileProps;
-        if (csFileProps === undefined || csFileProps.length === 0) {
+        const ranges = this._changesetRanges;
+        if (ranges === undefined || ranges.length === 0) {
             if (this.exporter.sourceDbChanges === undefined ||
                 !this.exporter.sourceDbChanges.hasChanges)
                 return;
@@ -1434,21 +1481,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             if (this._sourceChangeDataState === "no-changes")
                 this._sourceChangeDataState = "has-changes";
         }
-        const deletionRecordsByChangeset = this._deletionRecordsByChangeset;
-        if (deletionRecordsByChangeset === undefined)
+        const deletionBatches = this._deletionBatches;
+        if (deletionBatches === undefined)
             return;
-        const relationshipECClassIdsToSkip = new Set();
-        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementDrivesElement)", undefined, { usePrimaryConn: true })) {
-            relationshipECClassIdsToSkip.add(row.ECInstanceId);
-        }
-        const relationshipECClassIds = new Set();
-        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementRefersToElements)", undefined, { usePrimaryConn: true })) {
-            relationshipECClassIds.add(row.ECInstanceId);
-        }
-        const elementAspectECClassIds = new Set();
-        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementAspect)", undefined, { usePrimaryConn: true })) {
-            elementAspectECClassIds.add(row.ECInstanceId);
-        }
         // For later use when processing deletes.
         const alreadyImportedElementInserts = new Set();
         const alreadyImportedModelInserts = new Set();
@@ -1463,30 +1498,28 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 alreadyImportedModelInserts.add(targetModelId);
         });
         this._deletedSourceRelationshipData = new Map();
-        const isElementAspectDeletion = (change) => elementAspectECClassIds.has(change.ecClassId);
-        for (const changes of deletionRecordsByChangeset) {
-            /** a map of element ids to this transformation scope's ESA data for that element, in case the ESA is deleted in the target */
-            const elemIdToScopeEsa = new Map();
-            for (const change of changes) {
-                if (relationshipECClassIdsToSkip.has(change.ecClassId))
-                    continue;
-                if (change.classFullName === core_backend_1.ExternalSourceAspect.classFullName &&
-                    change.scopeId === this.targetScopeElementId &&
-                    change.kind === core_backend_1.ExternalSourceAspect.Kind.Element &&
-                    change.elementId !== undefined) {
-                    elemIdToScopeEsa.set(change.elementId, change);
-                }
-            }
-            // Loop to process deletes.
-            for (const change of changes) {
-                if (relationshipECClassIdsToSkip.has(change.ecClassId))
-                    continue;
-                if (isElementAspectDeletion(change))
-                    continue;
-                await this.processDeletedOp(change, elemIdToScopeEsa, relationshipECClassIds.has(change.ecClassId), alreadyImportedElementInserts, alreadyImportedModelInserts);
+        this._pendingRelationshipDeleteTargets.clear();
+        this._reimportedTargetRelationshipIds.clear();
+        for (const batch of deletionBatches) {
+            // Deletion records can only resolve targets within their own batch, so these lookups are rebuilt for each batch.
+            // They cover elements and scope ESAs deleted in the source, which can no longer be read from it.
+            const deletedScopeEsaByElementId = new Map();
+            for (const aspect of batch.externalSourceAspects) {
+                if (aspect.scopeId === this.targetScopeElementId &&
+                    aspect.kind === core_backend_1.ExternalSourceAspect.Kind.Element)
+                    deletedScopeEsaByElementId.set(aspect.elementId, aspect);
             }
+            const deletedFederationGuidByElementId = new Map();
+            for (const element of batch.elements)
+                if (element.federationGuid)
+                    deletedFederationGuidByElementId.set(element.ecInstanceId, element.federationGuid);
+            for (const relationship of batch.relationships)
+                await this.processDeletedRelationship(relationship, deletedScopeEsaByElementId, deletedFederationGuidByElementId);
+            for (const element of batch.elements)
+                await this.processDeletedElement(element.ecInstanceId, element.federationGuid, deletedScopeEsaByElementId, alreadyImportedElementInserts, alreadyImportedModelInserts);
+            for (const model of batch.models)
+                await this.processDeletedElement(model.ecInstanceId, undefined, deletedScopeEsaByElementId, alreadyImportedElementInserts, alreadyImportedModelInserts);
         }
-        return;
     }
     /**
      * This will be called when transformer is called with [[IModelTransformOptions.argsForProcessChanges]] to process changes.
@@ -1498,127 +1531,110 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     async addCustomChanges(_sourceDbChanges) { }
     /**
-     * Helper function for processChangesets. Remaps the id of element deleted found in the 'change' to an element in the targetDb.
-     * @param change the change to process, must be of changeType "Deleted"
-     * @param mapOfDeletedElemIdToScopeEsas a map of elementIds to changedECInstances (which are ESAs). the elementId is not the id of the esa itself, but the elementid that the esa was stored on before the esa's deletion.
-     * All ESAs in this map are part of the transformer's scope / ESA data and are tracked in case the ESA is deleted in the target.
-     * @param isRelationship is relationship or not
-     * @param alreadyImportedElementInserts used to handle entity recreation and not delete already handled element inserts.
-     * @param alreadyImportedModelInserts used to handle entity recreation and not delete already handled model inserts.
-     * @returns void
-     */
-    async processDeletedOp(change, mapOfDeletedElemIdToScopeEsas, isRelationship, alreadyImportedElementInserts, alreadyImportedModelInserts) {
-        // we need a connected iModel with changes to remap elements with deletions
-        const notConnectedModel = this.sourceDb.iTwinId === undefined;
-        const noChanges = (await this.getSynchronizationVersion()).index ===
-            this.sourceDb.changeset.index &&
-            (this.exporter.sourceDbChanges === undefined ||
-                !this.exporter.sourceDbChanges.hasChanges);
-        if (notConnectedModel || noChanges)
-            return;
+     * Finds the target ID of a source element while processing deletions, first through the transformation's
+     * ExternalSourceAspects when the source holds the provenance, then through the federation GUID. The element may be
+     * deleted itself, or be a surviving endpoint of a deleted relationship.
+     * @param sourceId the source element ID.
+     * @param federationGuid the source element's federation GUID, if known.
+     * @param deletedScopeEsaByElementId this transformation scope's deleted ESAs in the same batch, keyed by the ID of the element that owned each one.
+     */
+    async findTargetElementIdForDeletion(sourceId, federationGuid, deletedScopeEsaByElementId) {
         /**
          * If the deleted source entity is in the provenanceDb, then we can use its ids to query for ESAs.
          * This is because the ESAs are stored on an element Id thats present in the provenanceDb.
          */
-        const changeDataInProvenanceDb = this.sourceDb === (await this.getProvenanceDb());
-        const getTargetIdFromSourceId = async (id) => {
+        if (this.sourceDb === (await this.getProvenanceDb())) {
             let identifierValue;
-            let element;
-            if (isRelationship) {
-                element = this.sourceDb.elements.tryGetElement(id);
-            }
-            const fedGuid = isRelationship
-                ? element?.federationGuid
-                : change.federationGuid;
-            if (changeDataInProvenanceDb) {
-                // TODO: clarify what happens if there are multiple (e.g. elements were merged)
-                for await (const row of this.sourceDb.createQueryReader("SELECT esa.Identifier FROM bis.ExternalSourceAspect esa WHERE Scope.Id=:scopeId AND Kind=:kind AND Element.Id=:relatedElementId LIMIT 1", core_common_1.QueryBinder.from([
-                    this.targetScopeElementId,
-                    core_backend_1.ExternalSourceAspect.Kind.Element,
-                    id,
-                ]), { usePrimaryConn: true })) {
-                    identifierValue = row.Identifier;
-                }
-                identifierValue =
-                    identifierValue ?? mapOfDeletedElemIdToScopeEsas.get(id)?.identifier;
+            // TODO: clarify what happens if there are multiple (e.g. elements were merged)
+            for await (const row of this.sourceDb.createQueryReader("SELECT esa.Identifier FROM bis.ExternalSourceAspect esa WHERE Scope.Id=:scopeId AND Kind=:kind AND Element.Id=:relatedElementId LIMIT 1", core_common_1.QueryBinder.from([
+                this.targetScopeElementId,
+                core_backend_1.ExternalSourceAspect.Kind.Element,
+                sourceId,
+            ]), { usePrimaryConn: true })) {
+                identifierValue = row.Identifier;
             }
+            identifierValue =
+                identifierValue ?? deletedScopeEsaByElementId.get(sourceId)?.identifier;
             // Check for targetId by an esa first
-            if (changeDataInProvenanceDb && identifierValue) {
-                const targetId = identifierValue;
-                return targetId;
-            }
-            // Check for targetId using sourceId's fedguid if we didn't find an esa.
-            if (fedGuid) {
-                const targetId = this.targetDb.elements.getIdFromFederationGuid(fedGuid);
-                return targetId;
-            }
-            return undefined;
-        };
-        const changedInstanceId = change.ecInstanceId;
-        if (isRelationship) {
-            const sourceIdOfRelationshipInSource = change.sourceECInstanceId;
-            const targetIdOfRelationshipInSource = change.targetECInstanceId;
-            const classFullName = change.classFullName;
-            if (sourceIdOfRelationshipInSource === undefined ||
-                targetIdOfRelationshipInSource === undefined) {
-                core_bentley_1.ITwinError.throwError({
-                    iTwinErrorId: {
-                        scope: IModelTransformerError_1.IModelTransformerErrorScope,
-                        key: IModelTransformerError_1.IModelTransformerError.ChangedInstanceMetadataMissing,
-                    },
-                    message: `Relationship deletion ${changedInstanceId} is missing an endpoint.`,
-                });
-            }
-            const sourceIdOfRelationshipInTarget = await getTargetIdFromSourceId(sourceIdOfRelationshipInSource);
-            const targetIdOfRelationshipInTarget = await getTargetIdFromSourceId(targetIdOfRelationshipInSource);
-            if (sourceIdOfRelationshipInTarget && targetIdOfRelationshipInTarget) {
-                this._deletedSourceRelationshipData?.set(changedInstanceId, {
-                    classFullName: classFullName ?? "",
-                    sourceIdInTarget: sourceIdOfRelationshipInTarget,
-                    targetIdInTarget: targetIdOfRelationshipInTarget,
-                });
-            }
-            else if (this.sourceDb ===
-                (await this._provenanceManager.getProvenanceSourceDb())) {
-                const relProvenance = await this._provenanceManager.queryProvenanceForRelationship(changedInstanceId, {
-                    classFullName: classFullName ?? "",
-                    sourceId: sourceIdOfRelationshipInSource,
-                    targetId: targetIdOfRelationshipInSource,
+            if (identifierValue)
+                return identifierValue;
+        }
+        // Check for targetId using sourceId's fedguid if we didn't find an esa.
+        if (federationGuid)
+            return this.targetDb.elements.getIdFromFederationGuid(federationGuid);
+        return undefined;
+    }
+    /**
+     * Helper function for [[prepareSourceChanges]]. Records how to find the target relationship of a deleted source relationship.
+     * @param deletion the deleted source relationship.
+     * @param deletedScopeEsaByElementId this transformation scope's deleted ESAs in the same batch, keyed by the ID of the element that owned each one.
+     * @param deletedFederationGuidByElementId federation GUIDs of the elements deleted in the same batch, for endpoints that no longer exist in the source.
+     */
+    async processDeletedRelationship(deletion, deletedScopeEsaByElementId, deletedFederationGuidByElementId) {
+        const { ecInstanceId } = deletion;
+        const classFullName = this.sourceDb.getClassNameFromId(deletion.ecClassId);
+        const getEndpointInTarget = async (sourceId) => this.findTargetElementIdForDeletion(sourceId, this.sourceDb.elements.tryGetElement(sourceId)?.federationGuid ??
+            deletedFederationGuidByElementId.get(sourceId), deletedScopeEsaByElementId);
+        const sourceIdInTarget = await getEndpointInTarget(deletion.sourceECInstanceId);
+        const targetIdInTarget = await getEndpointInTarget(deletion.targetECInstanceId);
+        const isProvenanceSource = this.sourceDb === (await this._provenanceManager.getProvenanceSourceDb());
+        const queryRelationshipProvenance = async () => this._provenanceManager.queryProvenanceForRelationship(ecInstanceId, {
+            classFullName,
+            sourceId: deletion.sourceECInstanceId,
+            targetId: deletion.targetECInstanceId,
+        });
+        if (sourceIdInTarget && targetIdInTarget) {
+            // relationships with ESA provenance must have their aspect deleted too, even when the target relationship is found by endpoints
+            const provenanceAspectId = this._options.forceExternalSourceAspectProvenance && isProvenanceSource
+                ? (await queryRelationshipProvenance())?.aspectId
+                : undefined;
+            this._deletedSourceRelationshipData?.set(ecInstanceId, {
+                classFullName,
+                sourceIdInTarget,
+                targetIdInTarget,
+                provenanceAspectId,
+            });
+            this._pendingRelationshipDeleteTargets.add(relationshipEndpointsKey(sourceIdInTarget, targetIdInTarget));
+        }
+        else if (isProvenanceSource) {
+            const relProvenance = await queryRelationshipProvenance();
+            if (relProvenance && relProvenance.relationshipId) {
+                this._deletedSourceRelationshipData?.set(ecInstanceId, {
+                    classFullName,
+                    relId: relProvenance.relationshipId,
+                    provenanceAspectId: relProvenance.aspectId,
                 });
-                if (relProvenance && relProvenance.relationshipId)
-                    this._deletedSourceRelationshipData?.set(changedInstanceId, {
-                        classFullName: classFullName ?? "",
-                        relId: relProvenance.relationshipId,
-                        provenanceAspectId: relProvenance.aspectId,
-                    });
+                this._pendingRelationshipDeleteTargets.add(relProvenance.relationshipId);
             }
         }
-        else {
-            let targetId = await getTargetIdFromSourceId(changedInstanceId);
-            if (targetId === undefined &&
-                this.sourceDb ===
-                    (await this._provenanceManager.getProvenanceSourceDb())) {
-                const contextTargetId = this.context.findTargetElementId(changedInstanceId);
-                if (core_bentley_1.Id64.isValidId64(contextTargetId))
-                    targetId = contextTargetId;
-            }
-            // since we are processing one changeset at a time, we can see local source deletes
-            // of entities that were never synced and can be safely ignored
-            const deletionNotInTarget = !targetId;
-            if (deletionNotInTarget)
-                return;
-            if (targetId === undefined) {
-                throw new Error("targetId should be acquired from source id or transformation context");
-            }
-            this.context.remapElement(changedInstanceId, targetId);
-            // If an entity insert and an entity delete both point to the same entity in target iModel, that means that entity was recreated.
-            // In such case an entity update will be triggered and we no longer need to delete the entity.
-            if (alreadyImportedElementInserts.has(targetId)) {
-                this.exporter.sourceDbChanges?.element.deleteIds.delete(changedInstanceId);
-            }
-            if (alreadyImportedModelInserts.has(targetId)) {
-                this.exporter.sourceDbChanges?.model.deleteIds.delete(changedInstanceId);
-            }
+    }
+    /**
+     * Helper function for [[prepareSourceChanges]]. Remaps a deleted source element or model to its target.
+     * @param sourceId the deleted source element or model.
+     * @param federationGuid the deleted source element's federation GUID, if it had one. Undefined for models.
+     * @param deletedScopeEsaByElementId this transformation scope's deleted ESAs in the same batch, keyed by the ID of the element that owned each one.
+     * @param alreadyImportedElementInserts used to handle entity recreation and not delete already handled element inserts.
+     * @param alreadyImportedModelInserts used to handle entity recreation and not delete already handled model inserts.
+     */
+    async processDeletedElement(sourceId, federationGuid, deletedScopeEsaByElementId, alreadyImportedElementInserts, alreadyImportedModelInserts) {
+        let targetId = await this.findTargetElementIdForDeletion(sourceId, federationGuid, deletedScopeEsaByElementId);
+        if (targetId === undefined &&
+            this.sourceDb === (await this._provenanceManager.getProvenanceSourceDb())) {
+            const contextTargetId = this.context.findTargetElementId(sourceId);
+            if (core_bentley_1.Id64.isValidId64(contextTargetId))
+                targetId = contextTargetId;
+        }
+        // Entities inserted and deleted since the last synchronization were never synced and can be safely ignored.
+        if (!targetId)
+            return;
+        this.context.remapElement(sourceId, targetId);
+        // If an entity insert and an entity delete both point to the same entity in target iModel, that means that entity was recreated.
+        // In such case an entity update will be triggered and we no longer need to delete the entity.
+        if (alreadyImportedElementInserts.has(targetId)) {
+            this.exporter.sourceDbChanges?.element.deleteIds.delete(sourceId);
+        }
+        if (alreadyImportedModelInserts.has(targetId)) {
+            this.exporter.sourceDbChanges?.model.deleteIds.delete(sourceId);
         }
     }
     async _tryInitChangesetData(args) {
@@ -1632,7 +1648,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const noChanges = syncVersion.index === this.sourceDb.changeset.index;
         if (noChanges) {
             this._sourceChangeDataState = "no-changes";
-            this._csFileProps = [];
+            this._changesetRanges = [];
             return;
         }
         const startChangeset = "startChangeset" in args ? args.startChangeset : undefined;
@@ -1669,20 +1685,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         core_bentley_1.Logger.logTrace(loggerCategory, `changesets to skip: ${changesetsToSkip}`);
         this._changesetRanges = (0, Algo_1.rangesFromRangeAndSkipped)(startChangesetIndex, endChangesetIndex, changesetsToSkip);
         core_bentley_1.Logger.logTrace(loggerCategory, `ranges: ${this._changesetRanges}`);
-        const csFileProps = [];
-        for (const [first, end] of this._changesetRanges) {
-            // TODO: should the first changeset in a reverse sync really be included even though its 'initialized branch provenance'? The answer is no, its a bug that needs to be fixed.
-            const fileProps = await core_backend_1.BriefcaseManager.downloadChangesets({
-                iModelId: this.sourceDb.iModelId,
-                targetDir: core_backend_1.BriefcaseManager.getChangeSetsPath(this.sourceDb.iModelId),
-                range: { first, end },
-            });
-            csFileProps.push(...fileProps);
-        }
-        this._csFileProps = csFileProps;
-        /** Theres a possibility that our csFileProps length is still 0 here, since we skip cs indices found in the pendingSync and pendingReverseSync indices arrays. */
+        /** Skipping indices found in the pendingSync and pendingReverseSync arrays can leave no ranges to process. */
         this._sourceChangeDataState =
-            this._csFileProps.length === 0 ? "no-changes" : "has-changes";
+            this._changesetRanges.length === 0 ? "no-changes" : "has-changes";
     }
     /** Asserts that the EditTxn is active before any write operations. */
     assertEditTxnActive() {
@@ -1808,17 +1813,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const startChangeset = "startChangeset" in opts ? opts.startChangeset : undefined;
         return {
             skipPropagateChangesToRootElements: this._options.skipPropagateChangesToRootElements,
-            ...(this._csFileProps
-                ? { csFileProps: this._csFileProps }
-                : this._changesetRanges
-                    ? { changesetRanges: this._changesetRanges }
-                    : startChangeset
-                        ? { startChangeset }
-                        : {
-                            startChangeset: {
-                                index: (await this.getSynchronizationVersion()).index + 1,
-                            },
-                        }),
+            ...(this._changesetRanges
+                ? { changesetRanges: this._changesetRanges }
+                : startChangeset
+                    ? { startChangeset }
+                    : {
+                        startChangeset: {
+                            index: (await this.getSynchronizationVersion()).index + 1,
+                        },
+                    }),
         };
     }
     /** Combine an array of source elements into a single target element.