@itwin/core-backend 5.13.0-dev.9 → 5.14.0-dev.1

package/lib/cjs/TxnManager.js

@@ -77,6 +77,16 @@ function setMaxEntitiesPerEvent(max) {
     ChangedEntitiesProc.maxPerEvent = max;
     return prevMax;
 }
+class TxnEntityMetadataImpl {
+    classFullName;
+    baseClasses = [];
+    constructor(classFullName) {
+        this.classFullName = classFullName;
+    }
+    is(baseClassFullName) {
+        return this.classFullName === baseClassFullName || this.baseClasses.some((baseClass) => baseClass.is(baseClassFullName));
+    }
+}
 /** Maintains an ordered array of entity Ids and a parallel array containing the index of the corresponding entity's class Id. */
 class ChangedEntitiesArray {
     entityIds = new core_bentley_1.OrderedId64Array();
@@ -109,12 +119,17 @@ class ChangedEntitiesArray {
             entities[type] = core_bentley_1.CompressedId64Set.compressIds(this.entityIds);
         entities[`${type}Meta`] = this._classIndices;
     }
-    iterable(classIds) {
+    iterable(classIds, metadata) {
         function* iterator(entityIds, classIndices) {
-            const entity = { id: "", classId: "" };
+            let entity;
             for (let i = 0; i < entityIds.length; i++) {
+                const classIndex = classIndices[i];
+                const entityMetadata = metadata[classIndex];
+                (0, core_bentley_1.assert)(undefined !== entityMetadata);
+                entity ??= { id: "", classId: "", metadata: entityMetadata };
                 entity.id = entityIds[i];
-                entity.classId = classIds[classIndices[i]];
+                entity.classId = classIds[classIndex];
+                entity.metadata = entityMetadata;
                 yield entity;
             }
         }
@@ -160,10 +175,10 @@ class ChangedEntitiesProc {
             const meta = db.classMetaDataRegistry.findByClassId(classId);
             nameToIndex.set(meta?.ecclass ?? "", nameToIndex.size);
         }
-        const result = [];
+        const metadata = [];
         function addMetadata(name, index) {
             const bases = [];
-            result[index] = { name, bases };
+            metadata[index] = { name, bases };
             // eslint-disable-next-line @typescript-eslint/no-deprecated
             const meta = db.tryGetMetaData(name);
             if (!meta) {
@@ -186,25 +201,43 @@ class ChangedEntitiesProc {
             }
             addMetadata(name, index);
         }
-        return result;
+        return metadata;
+    }
+    populateBackendMetadata(frontendMetadata) {
+        const backendMetadata = frontendMetadata.map(({ name }) => new TxnEntityMetadataImpl(name));
+        for (let index = 0; index < frontendMetadata.length; index++) {
+            const frontend = frontendMetadata[index];
+            const backend = backendMetadata[index];
+            (0, core_bentley_1.assert)(undefined !== frontend && undefined !== backend);
+            for (const baseClassIndex of frontend.bases) {
+                const baseClass = backendMetadata[baseClassIndex];
+                (0, core_bentley_1.assert)(undefined !== baseClass);
+                backend.baseClasses.push(baseClass);
+            }
+        }
+        return backendMetadata;
     }
     sendEvent(iModel, evt, evtName) {
         if (this._currSize === 0)
             return;
         const classIds = this._classIds.toArray();
-        // Notify backend listeners.
-        const txnEntities = {
-            inserts: this._inserted.iterable(classIds),
-            deletes: this._deleted.iterable(classIds),
-            updates: this._updated.iterable(classIds),
-        };
-        evt.raiseEvent(txnEntities);
+        const frontendMetadata = this.populateMetadata(iModel, classIds);
+        // Notify backend listeners. Avoid constructing the backend metadata graph when there are no listeners.
+        if (evt.numberOfListeners > 0) {
+            const backendMetadata = this.populateBackendMetadata(frontendMetadata);
+            const txnEntities = {
+                inserts: this._inserted.iterable(classIds, backendMetadata),
+                deletes: this._deleted.iterable(classIds, backendMetadata),
+                updates: this._updated.iterable(classIds, backendMetadata),
+            };
+            evt.raiseEvent(txnEntities);
+        }
         // Notify frontend listeners.
         const entities = {
             insertedMeta: [],
             updatedMeta: [],
             deletedMeta: [],
-            meta: this.populateMetadata(iModel, classIds),
+            meta: frontendMetadata,
         };
         this._inserted.addToChangedEntities(entities, "inserted");
         this._deleted.addToChangedEntities(entities, "deleted");
@@ -973,6 +1006,15 @@ class TxnManager {
             };
         };
         // Default conflict resolution for which custom handler is never called.
+        // A local txn that imported a domain replays an insert to `dgn_Domain` for a domain the
+        // just-merged changesets already registered. Both rows describe the same domain, so the
+        // merged row wins and the local insert is dropped. Only a primary key collision on an insert
+        // is benign - an update or delete whose "before" values do not match (`Data`) describes a real
+        // divergence and is left to the handlers below.
+        if (args.tableName === "dgn_Domain" && args.cause === "Conflict" && args.opcode === "Inserted") {
+            core_bentley_1.Logger.logInfo(BackendLoggerCategory_1.BackendLoggerCategory.IModelDb, "dgn_Domain insert conflict during rebase. Keeping the merged row and skipping the local change.", getChangeMetaData());
+            return core_bentley_1.DbConflictResolution.Skip;
+        }
         if (args.cause === "Data" && !args.indirect) {
             if (args.tableName === "be_Prop") {
                 if (args.getValueText(0, "Old") === "ec_Db" && args.getValueText(1, "Old") === "localDbInfo") {
@@ -1070,11 +1112,27 @@ class TxnManager {
     onEndValidation = new core_bentley_1.BeEvent();
     /** Called after validation completes from [[IModelDb.saveChanges]].
      * The argument to the event holds the list of elements that were inserted, updated, and deleted.
+     * Each changed entity includes its `id`, `classId`, and [[TxnChangedEntity.metadata]]. Use `metadata.classFullName` for an exact class match or `metadata.is` to match a class or one of its subclasses.
+     * @example
+     * ```ts
+     * iModel.txns.onElementsChanged.addListener((changes) => {
+     *   for (const change of changes.inserts) {
+     *     if (change.metadata.classFullName === "MySchema:MyElement")
+     *       invalidateCache();
+     *   }
+     *
+     *   for (const change of changes.updates) {
+     *     if (change.metadata.is("BisCore:GeometricElement"))
+     *       invalidateGeometryCache(change.id);
+     *   }
+     * });
+     * ```
      * @note If there are many changed elements in a single Txn, the notifications are sent in batches so this event *may be called multiple times* per Txn.
      */
     onElementsChanged = new core_bentley_1.BeEvent();
     /** Called after validation completes from [[IModelDb.saveChanges]].
      * The argument to the event holds the list of models that were inserted, updated, and deleted.
+     * Each changed model includes its `id`, `classId`, and [[TxnChangedEntity.metadata]]. Use `metadata.classFullName` for an exact class match or `metadata.is` to match a class or one of its subclasses.
      * @note If there are many changed models in a single Txn, the notifications are sent in batches so this event *may be called multiple times* per Txn.
      */
     onModelsChanged = new core_bentley_1.BeEvent();