@itwin/imodel-transformer 1.0.0-dev.17 → 1.0.0-dev.18

package/lib/cjs/IModelTransformer.js

@@ -19,8 +19,6 @@ const core_common_1 = require("@itwin/core-common");
 const IModelExporter_1 = require("./IModelExporter");
 const IModelImporter_1 = require("./IModelImporter");
 const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
-const PendingReferenceMap_1 = require("./PendingReferenceMap");
-const EntityMap_1 = require("./EntityMap");
 const IModelCloneContext_1 = require("./IModelCloneContext");
 const EntityUnifier_1 = require("./EntityUnifier");
 const Algo_1 = require("./Algo");
@@ -31,30 +29,6 @@ const nullLastProvenanceEntityInfo = {
     aspectVersion: "",
     aspectKind: core_backend_1.ExternalSourceAspect.Kind.Element,
 };
-/**
- * A container for tracking the state of a partially committed entity and finalizing it when it's ready to be fully committed
- * @internal
- */
-class PartiallyCommittedEntity {
-    constructor(
-    /**
-     * A set of "model|element ++ ID64" pairs, (e.g. `model0x11` or `element0x12`)
-     * It is possible for the submodel of an element to be separately resolved from the actual element,
-     * so its resolution must be tracked separately
-     */
-    _missingReferences, _onComplete) {
-        this._missingReferences = _missingReferences;
-        this._onComplete = _onComplete;
-    }
-    resolveReference(id) {
-        this._missingReferences.delete(id);
-        if (this._missingReferences.size === 0)
-            this._onComplete();
-    }
-    forceComplete() {
-        this._onComplete();
-    }
-}
 /**
  * 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,
@@ -217,13 +191,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      */
     constructor(source, target, options) {
         super();
-        /** map of (unprocessed element, referencing processed element) pairs to the partially committed element that needs the reference resolved
-         * and have some helper methods below for now */
-        this._pendingReferences = new PendingReferenceMap_1.PendingReferenceMap();
         /** a set of elements for which source provenance will be explicitly tracked by ExternalSourceAspects */
         this._elementsWithExplicitlyTrackedProvenance = new Set();
-        /** map of partially committed entities to their partial commit progress */
-        this._partiallyCommittedEntities = new EntityMap_1.EntityMap();
+        this._partiallyCommittedElementIds = new Set();
+        this._partiallyCommittedAspectIds = new Set();
         /**
          * A private variable meant to be set by tests which have an outdated way of setting up transforms. In all synchronizations today we expect to find an ESA in the branch db which describes the master -> branch relationship.
          * The exception to this is the first transform aka the provenance initializing transform which requires that the master imodel and the branch imodel are identical at the time of provenance initialization.
@@ -232,10 +203,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
          */
         this._allowNoScopingESA = false;
         this._changesetRanges = undefined;
-        /** Set of entity keys which were not exported and don't need to be tracked for pending reference resolution.
-         * @note Currently only tracks elements which were not exported.
-         */
-        this._skippedEntities = new Set();
         /**
          * Previously the transformer would insert provenance always pointing to the "target" relationship.
          * It should (and now by default does) instead insert provenance pointing to the provenanceSource
@@ -954,80 +921,69 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         nodeAssert(this._hasElementChangedCache !== undefined, "has element changed cache should be initialized by now");
         return this._hasElementChangedCache.has(sourceElement.id);
     }
-    static transformCallbackFor(transformer, entity) {
-        if (entity instanceof core_backend_1.Element)
-            return transformer.onTransformElement; // eslint-disable-line @typescript-eslint/unbound-method
-        else if (entity instanceof core_backend_1.Element)
-            return transformer.onTransformModel; // eslint-disable-line @typescript-eslint/unbound-method
-        else if (entity instanceof core_backend_1.Relationship)
-            return transformer.onTransformRelationship; // eslint-disable-line @typescript-eslint/unbound-method
-        else if (entity instanceof core_backend_1.ElementAspect)
-            return transformer.onTransformElementAspect; // eslint-disable-line @typescript-eslint/unbound-method
-        else
-            (0, core_bentley_1.assert)(false, `unreachable; entity was '${entity.constructor.name}' not an Element, Relationship, or ElementAspect`);
-    }
-    /** callback to perform when a partial element says it's ready to be completed
-     * transforms the source element with all references now valid, then updates the partial element with the results
-     */
-    makePartialEntityCompleter(sourceEntity) {
-        return () => {
-            const targetId = this.context.findTargetEntityId(core_backend_1.EntityReferences.from(sourceEntity));
-            if (!core_backend_1.EntityReferences.isValid(targetId))
-                throw Error(`${sourceEntity.id} has not been inserted into the target yet, the completer is invalid. This is a bug.`);
-            const onEntityTransform = IModelTransformer.transformCallbackFor(this, sourceEntity);
-            const updateEntity = EntityUnifier_1.EntityUnifier.updaterFor(this.targetDb, sourceEntity);
-            const targetProps = onEntityTransform.call(this, sourceEntity);
-            if (sourceEntity instanceof core_backend_1.Relationship) {
-                targetProps.sourceId =
-                    this.context.findTargetElementId(sourceEntity.sourceId);
-                targetProps.targetId =
-                    this.context.findTargetElementId(sourceEntity.targetId);
+    completePartiallyCommittedElements() {
+        for (const sourceElementId of this._partiallyCommittedElementIds) {
+            const sourceElement = this.sourceDb.elements.getElement({
+                id: sourceElementId,
+                wantGeometry: this.exporter.wantGeometry,
+                wantBRepData: this.exporter.wantGeometry,
+            });
+            const targetId = this.context.findTargetElementId(sourceElementId);
+            if (core_bentley_1.Id64.isInvalid(targetId)) {
+                throw new Error(`source-target element mapping not found for element "${sourceElementId}" when completing partially committed elements. This is a bug.`);
             }
-            updateEntity({ ...targetProps, id: core_backend_1.EntityReferences.toId64(targetId) });
-            this._partiallyCommittedEntities.delete(sourceEntity);
-        };
+            const targetProps = this.onTransformElement(sourceElement);
+            this.targetDb.elements.updateElement({ ...targetProps, id: targetId });
+        }
     }
-    /** collect references this entity has that are yet to be mapped, and if there are any
-     * create a [[PartiallyCommittedEntity]] to track resolution of those references
-     */
-    collectUnmappedReferences(entity) {
-        const missingReferences = new core_common_1.EntityReferenceSet();
-        let thisPartialElem;
-        // eslint-disable-next-line deprecation/deprecation
-        for (const referenceId of entity.getReferenceConcreteIds()) {
-            // TODO: probably need to rename from 'id' to 'ref' so these names aren't so ambiguous
-            const referenceIdInTarget = this.context.findTargetEntityId(referenceId);
-            const alreadyProcessed = core_backend_1.EntityReferences.isValid(referenceIdInTarget) ||
-                this._skippedEntities.has(referenceId);
-            if (alreadyProcessed)
-                continue;
-            core_bentley_1.Logger.logTrace(loggerCategory, `Deferring resolution of reference '${referenceId}' of element '${entity.id}'`);
-            const referencedExistsInSource = EntityUnifier_1.EntityUnifier.exists(this.sourceDb, {
-                entityReference: referenceId,
+    completePartiallyCommittedAspects() {
+        for (const sourceAspectId of this._partiallyCommittedAspectIds) {
+            const sourceAspect = this.sourceDb.elements.getAspect(sourceAspectId);
+            const targetAspectId = this.context.findTargetAspectId(sourceAspectId);
+            if (core_bentley_1.Id64.isInvalid(targetAspectId)) {
+                throw new Error(`source-target aspect mapping not found for aspect "${sourceAspectId}" when completing partially committed aspects. This is a bug.`);
+            }
+            const targetAspectProps = this.onTransformElementAspect(sourceAspect);
+            this.targetDb.elements.updateAspect({
+                ...targetAspectProps,
+                id: targetAspectId,
             });
-            if (!referencedExistsInSource) {
-                core_bentley_1.Logger.logWarning(loggerCategory, `Source ${EntityUnifier_1.EntityUnifier.getReadableType(entity)} (${entity.id}) has a dangling reference to (${referenceId})`);
-                switch (this._options.danglingReferencesBehavior) {
-                    case "ignore":
-                        continue;
-                    case "reject":
-                        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.NotFound, [
-                            `Found a reference to an element "${referenceId}" that doesn't exist while looking for references of "${entity.id}".`,
-                            "This must have been caused by an upstream application that changed the iModel.",
-                            "You can set the IModelTransformOptions.danglingReferencesBehavior option to 'ignore' to ignore this, but this will leave the iModel",
-                            "in a state where downstream consuming applications will need to handle the invalidity themselves. In some cases, writing a custom",
-                            "transformer to remove the reference and fix affected elements may be suitable.",
-                        ].join("\n"));
+        }
+    }
+    doAllReferencesExistInTarget(entity) {
+        let allReferencesExist = true;
+        for (const referenceId of entity.getReferenceIds()) {
+            const referencedEntityId = core_backend_1.EntityReferences.toId64(referenceId);
+            if (referencedEntityId === core_common_1.IModel.repositoryModelId ||
+                referencedEntityId === core_common_1.IModel.dictionaryId ||
+                referencedEntityId === "0xe") {
+                continue;
+            }
+            if (allReferencesExist &&
+                !core_backend_1.EntityReferences.isValid(this.context.findTargetEntityId(referenceId))) {
+                // if we care about references existing then we cannot return early and must check all other references.
+                if (this._options.danglingReferencesBehavior === "ignore") {
+                    return false;
                 }
+                allReferencesExist = false;
             }
-            if (thisPartialElem === undefined) {
-                thisPartialElem = new PartiallyCommittedEntity(missingReferences, this.makePartialEntityCompleter(entity));
-                if (!this._partiallyCommittedEntities.has(entity))
-                    this._partiallyCommittedEntities.set(entity, thisPartialElem);
+            if (this._options.danglingReferencesBehavior === "reject") {
+                this.assertReferenceExistsInSource(referenceId, entity);
             }
-            missingReferences.add(referenceId);
-            const entityReference = core_backend_1.EntityReferences.from(entity);
-            this._pendingReferences.set({ referenced: referenceId, referencer: entityReference }, thisPartialElem);
+        }
+        return allReferencesExist;
+    }
+    assertReferenceExistsInSource(referenceId, entity) {
+        const referencedExistsInSource = EntityUnifier_1.EntityUnifier.exists(this.sourceDb, {
+            entityReference: referenceId,
+        });
+        if (!referencedExistsInSource) {
+            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.NotFound, [
+                `Found a reference to an element "${referenceId}" that doesn't exist while looking for references of "${entity.id}".`,
+                "This must have been caused by an upstream application that changed the iModel.",
+                "You can set the IModelTransformOptions.danglingReferencesBehavior option to 'ignore' to ignore this,",
+                `and the referenceId found on "${entity.id}" will not be carried over to corresponding target element.`,
+            ].join("\n"));
         }
     }
     /** Cause the specified Element and its child Elements (if applicable) to be exported from the source iModel and imported into the target iModel.
@@ -1055,24 +1011,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     shouldExportElement(_sourceElement) {
         return true;
     }
-    onSkipElement(sourceElementId) {
-        if (this.context.findTargetElementId(sourceElementId) !== core_bentley_1.Id64.invalid) {
-            // element already has provenance
-            return;
-        }
-        core_bentley_1.Logger.logInfo(loggerCategory, `Element '${sourceElementId}' won't be exported. Marking its references as resolved`);
-        const elementKey = `e${sourceElementId}`;
-        this._skippedEntities.add(elementKey);
-        // Mark any existing pending references to the skipped element as resolved.
-        for (const referencer of this._pendingReferences.getReferencersByEntityKey(elementKey)) {
-            const key = PendingReferenceMap_1.PendingReference.from(referencer, elementKey);
-            const pendingRef = this._pendingReferences.get(key);
-            if (!pendingRef)
-                continue;
-            pendingRef.resolveReference(elementKey);
-            this._pendingReferences.delete(key);
-        }
-    }
     /**
      * If they haven't been already, import all of the required references
      * @internal do not call, override or implement this, it will be removed
@@ -1182,7 +1120,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         }
         if (!this.hasElementChanged(sourceElement))
             return;
-        this.collectUnmappedReferences(sourceElement);
+        if (!this.doAllReferencesExistInTarget(sourceElement)) {
+            this._partiallyCommittedElementIds.add(sourceElement.id);
+        }
         // targetElementId will be valid (indicating update) or undefined (indicating insert)
         targetElementProps.id = core_bentley_1.Id64.isValid(targetElementId)
             ? targetElementId
@@ -1191,8 +1131,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this.importer.importElement(targetElementProps); // don't need to import if iModel was copied
         }
         this.context.remapElement(sourceElement.id, targetElementProps.id); // targetElementProps.id assigned by importElement
-        // now that we've mapped this elem we can fix unmapped references to it
-        this.resolvePendingReferences(sourceElement);
         // the transformer does not currently 'split' or 'join' any elements, therefore, it does not
         // insert external source aspects because federation guids are sufficient for this.
         // Other transformer subclasses must insert the appropriate aspect (as provided by a TBD API)
@@ -1220,16 +1158,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this.markLastProvenance(provenance, { isRelationship: false });
         }
     }
-    resolvePendingReferences(entity) {
-        for (const referencer of this._pendingReferences.getReferencers(entity)) {
-            const key = PendingReferenceMap_1.PendingReference.from(referencer, entity);
-            const pendingRef = this._pendingReferences.get(key);
-            if (!pendingRef)
-                continue;
-            pendingRef.resolveReference(core_backend_1.EntityReferences.from(entity));
-            this._pendingReferences.delete(key);
-        }
-    }
     /** Override of [IModelExportHandler.onDeleteElement]($transformer) that is called when [IModelExporter]($transformer) detects that an Element has been deleted from the source iModel.
      * This override propagates the delete to the target iModel via [IModelImporter.deleteElement]($transformer).
      */
@@ -1254,7 +1182,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             return;
         const targetModelProps = this.onTransformModel(sourceModel, targetModeledElementId);
         this.importer.importModel(targetModelProps);
-        this.resolvePendingReferences(sourceModel);
     }
     /** Override of [IModelExportHandler.onDeleteModel]($transformer) that is called when [IModelExporter]($transformer) detects that a [Model]($backend) has been deleted from the source iModel. */
     onDeleteModel(sourceModelId) {
@@ -1488,20 +1415,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.updateSynchronizationVersion({
             initializeReverseSyncVersion: this._isProvenanceInitTransform,
         });
-        if (this._partiallyCommittedEntities.size > 0) {
-            const message = [
-                "The following elements were never fully resolved:",
-                [...this._partiallyCommittedEntities.keys()].join(","),
-                "This indicates that either some references were excluded from the transformation",
-                "or the source has dangling references.",
-            ].join("\n");
-            if (this._options.danglingReferencesBehavior === "reject")
-                throw new Error(message);
-            core_bentley_1.Logger.logWarning(loggerCategory, message);
-            for (const partiallyCommittedElem of this._partiallyCommittedEntities.values()) {
-                partiallyCommittedElem.forceComplete();
-            }
-        }
         // TODO: ignore if we remove change cache usage
         if (!this._options.noDetachChangeCache) {
             if (core_backend_1.ChangeSummaryManager.isChangeCacheAttached(this.sourceDb))
@@ -1658,22 +1571,25 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * This override calls [[onTransformElementAspect]] and then [IModelImporter.importElementUniqueAspect]($transformer) to update the target iModel.
      */
     onExportElementUniqueAspect(sourceAspect) {
-        const targetElementId = this.context.findTargetElementId(sourceAspect.element.id);
-        const targetAspectProps = this.onTransformElementAspect(sourceAspect, targetElementId);
-        this.collectUnmappedReferences(sourceAspect);
+        const targetAspectProps = this.onTransformElementAspect(sourceAspect);
+        if (!this.doAllReferencesExistInTarget(sourceAspect)) {
+            this._partiallyCommittedAspectIds.add(sourceAspect.id);
+        }
         const targetId = this.importer.importElementUniqueAspect(targetAspectProps);
         this.context.remapElementAspect(sourceAspect.id, targetId);
-        this.resolvePendingReferences(sourceAspect);
     }
     /** Override of [IModelExportHandler.onExportElementMultiAspects]($transformer) that imports ElementMultiAspects into the target iModel when they are exported from the source iModel.
      * This override calls [[onTransformElementAspect]] for each ElementMultiAspect and then [IModelImporter.importElementMultiAspects]($transformer) to update the target iModel.
      * @note ElementMultiAspects are handled as a group to make it easier to differentiate between insert, update, and delete.
      */
     onExportElementMultiAspects(sourceAspects) {
-        const targetElementId = this.context.findTargetElementId(sourceAspects[0].element.id);
         // Transform source ElementMultiAspects into target ElementAspectProps
-        const targetAspectPropsArray = sourceAspects.map((srcA) => this.onTransformElementAspect(srcA, targetElementId));
-        sourceAspects.forEach((a) => this.collectUnmappedReferences(a));
+        const targetAspectPropsArray = sourceAspects.map((srcA) => this.onTransformElementAspect(srcA));
+        sourceAspects.forEach((a) => {
+            if (!this.doAllReferencesExistInTarget(a)) {
+                this._partiallyCommittedAspectIds.add(a.id);
+            }
+        });
         // const targetAspectsToImport = targetAspectPropsArray.filter((targetAspect, i) => hasEntityChanged(sourceAspects[i], targetAspect));
         const targetIds = this.importer.importElementMultiAspects(targetAspectPropsArray, (a) => {
             const isExternalSourceAspectFromTransformer = a instanceof core_backend_1.ExternalSourceAspect &&
@@ -1683,16 +1599,14 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         });
         for (let i = 0; i < targetIds.length; ++i) {
             this.context.remapElementAspect(sourceAspects[i].id, targetIds[i]);
-            this.resolvePendingReferences(sourceAspects[i]);
         }
     }
     /** Transform the specified sourceElementAspect into ElementAspectProps for the target iModel.
      * @param sourceElementAspect The ElementAspect from the source iModel to be transformed.
-     * @param _targetElementId The ElementId of the target Element that will own the ElementAspects after transformation.
      * @returns ElementAspectProps for the target iModel.
      * @note A subclass can override this method to provide custom transform behavior.
      */
-    onTransformElementAspect(sourceElementAspect, _targetElementId) {
+    onTransformElementAspect(sourceElementAspect) {
         const targetElementAspectProps = this.context.cloneElementAspect(sourceElementAspect);
         return targetElementAspectProps;
     }
@@ -1816,6 +1730,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.context.remapElement(sourceSubjectId, targetSubjectId);
         await this.processChildElements(sourceSubjectId);
         await this.processSubjectSubModels(sourceSubjectId);
+        this.completePartiallyCommittedElements();
+        this.completePartiallyCommittedAspects();
     }
     /**
      * Initialize prerequisites of processing, you must initialize with an [[InitOptions]] if you
@@ -2137,7 +2053,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         else {
             await this.exporter.exportModel(core_common_1.IModel.repositoryModelId);
         }
+        this.completePartiallyCommittedElements();
         await this.exporter["exportAllAspects"](); // eslint-disable-line @typescript-eslint/dot-notation
+        this.completePartiallyCommittedAspects();
         await this.exporter.exportRelationships(core_backend_1.ElementRefersToElements.classFullName);
         if (this._options.forceExternalSourceAspectProvenance &&
             this.shouldDetectDeletes()) {
@@ -2176,6 +2094,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     async processChanges(options) {
         // must wait for initialization of synchronization provenance data
         await this.exporter.exportChanges(this.getExportInitOpts(options));
+        this.completePartiallyCommittedElements();
+        this.completePartiallyCommittedAspects();
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
         this.importer.computeProjectExtents();