@itwin/core-backend 5.7.0-dev.12 → 5.7.0-dev.14

package/lib/esm/IModelDb.js

@@ -739,7 +739,7 @@ export class IModelDb extends IModel {
     saveChanges(descriptionOrArgs) {
         if (this.openMode === OpenMode.Readonly)
             throw new IModelError(IModelStatus.ReadOnly, "IModelDb was opened read-only");
-        if (this instanceof BriefcaseDb) {
+        if (this.isBriefcaseDb()) {
             if (this.txns.isIndirectChanges) {
                 throw new IModelError(IModelStatus.BadRequest, "Cannot save changes while in an indirect change scope");
             }
@@ -792,6 +792,21 @@ export class IModelDb extends IModel {
     restartTxnSession() {
         return this[_nativeDb].restartTxnSession();
     }
+    /**
+     * Get the class full name from a class Id.
+     * @param classId the Id of the class to look up
+     * @returns the full name of the class (e.g. "BisCore:Element")
+     * @throws IModelError if the classId is invalid or the class is not found.
+     * @internal
+     */
+    getClassNameFromId(classId) {
+        if (!Id64.isValid(classId))
+            throw new IModelError(IModelStatus.BadRequest, `Class Id ${classId} is invalid`);
+        const name = this[_nativeDb].classIdToName(classId);
+        if (name === undefined)
+            throw new IModelError(IModelStatus.NotFound, `Class not found: ${classId}`);
+        return name;
+    }
     /** Removes unused schemas from the database.
      *
      * If the removal was successful, the database is automatically saved to disk.
@@ -853,6 +868,9 @@ export class IModelDb extends IModel {
                     }
                     callbackResources.cachedData = callbackResult.cachedData;
                 }
+                if (this.isBriefcaseDb() && IModelHost.useSemanticRebase) {
+                    this.saveChanges("Save changes from schema import pre callback");
+                }
             }
         }
         catch (callbackError) {
@@ -872,6 +890,9 @@ export class IModelDb extends IModel {
         try {
             if (callback?.postSchemaImportCallback)
                 await callback.postSchemaImportCallback(context);
+            if (this.isBriefcaseDb() && IModelHost.useSemanticRebase) {
+                this.saveChanges("Save changes from schema import post callback");
+            }
         }
         catch (callbackError) {
             this.abandonChanges();
@@ -884,17 +905,31 @@ export class IModelDb extends IModel {
     }
     /** Shared implementation for importing schemas from file or string. */
     async importSchemasInternal(schemas, options, nativeImportOp) {
-        if (this instanceof BriefcaseDb) {
+        // BriefcaseDb-specific validation checks
+        if (this.isBriefcaseDb()) {
             if (this.txns.rebaser.isRebasing) {
                 throw new IModelError(IModelStatus.BadRequest, "Cannot import schemas while rebasing");
             }
             if (this.txns.isIndirectChanges) {
                 throw new IModelError(IModelStatus.BadRequest, "Cannot import schemas while in an indirect change scope");
             }
+            // Additional checks when semantic rebase is enabled
+            if (IModelHost.useSemanticRebase) {
+                if (this[_nativeDb].hasUnsavedChanges()) {
+                    throw new IModelError(IModelStatus.BadRequest, "Cannot import schemas with unsaved changes when useSemanticRebase flag is on");
+                }
+                if (this[_nativeDb].schemaSyncEnabled()) {
+                    throw new IModelError(IModelStatus.BadRequest, "Cannot import schemas when schema sync is enabled and also useSemanticRebase flag is on");
+                }
+            }
         }
         if (options?.channelUpgrade) {
             try {
                 await this.channels.upgradeChannel(options.channelUpgrade, this, options.data);
+                // If semantic rebase is enabled and channel upgrade made changes, save them
+                if (this.isBriefcaseDb() && IModelHost.useSemanticRebase) {
+                    this.saveChanges();
+                }
             }
             catch (error) {
                 this.abandonChanges();
@@ -935,8 +970,16 @@ export class IModelDb extends IModel {
                 schemaLockHeld: true,
                 ecSchemaXmlContext: maybeCustomNativeContext,
             };
-            if (this[_nativeDb].getITwinId() !== Guid.empty) // if this iModel is associated with an iTwin, importing schema requires the schema lock
-                await this.acquireSchemaLock();
+            // This check is different from isBriefcase in case of StandaloneDb, which is a briefcase but has no iTwinId.
+            if (this[_nativeDb].getITwinId() !== Guid.empty) { // if this iModel is associated with an iTwin, importing schema requires the schema lock
+                if (IModelHost.useSemanticRebase) {
+                    // Use shared lock for semantic rebase to allow concurrent schema imports
+                    await this.locks.acquireLocks({ shared: IModel.repositoryModelId });
+                }
+                else {
+                    await this.acquireSchemaLock();
+                }
+            }
             try {
                 nativeImportOp(schemas, nativeImportOptions);
             }
@@ -945,6 +988,17 @@ export class IModelDb extends IModel {
             }
         }
         this.clearCaches();
+        // Store schemas for semantic rebase (BriefcaseDb only)
+        if (this.isBriefcaseDb() && IModelHost.useSemanticRebase) {
+            const lastSavedTxnProps = this.txns.getLastSavedTxnProps();
+            if (lastSavedTxnProps === undefined) {
+                throw new IModelError(IModelStatus.BadRequest, "After schema import, no last saved transaction found");
+            }
+            if (lastSavedTxnProps.type !== "Schema" && lastSavedTxnProps.type !== "ECSchema") {
+                throw new IModelError(IModelStatus.BadRequest, "After schema import, last saved transaction is not a Schema transaction");
+            }
+            BriefcaseManager.storeSchemasForSemanticRebase(this, lastSavedTxnProps.id, schemas);
+        }
         if (options?.schemaImportCallbacks?.postSchemaImportCallback)
             await this.postSchemaImportCallback(options.schemaImportCallbacks, { iModel: this, resources: preSchemaImportCallbackResult, data: options.data });
     }
@@ -1430,7 +1484,7 @@ export class IModelDb extends IModel {
      * @note This method should not be called from {TxnManager.withIndirectTxnModeAsync} or {TxnManager.withIndirectTxnMode}.
      */
     saveFileProperty(prop, strValue, blobVal) {
-        if (this instanceof BriefcaseDb) {
+        if (this.isBriefcaseDb()) {
             if (this.txns.isIndirectChanges) {
                 throw new IModelError(IModelStatus.BadRequest, "Cannot save file property while in an indirect change scope");
             }
@@ -1442,7 +1496,7 @@ export class IModelDb extends IModel {
      * @note This method should not be called from {TxnManager.withIndirectTxnModeAsync} or {TxnManager.withIndirectTxnMode}.
      */
     deleteFileProperty(prop) {
-        if (this instanceof BriefcaseDb) {
+        if (this.isBriefcaseDb()) {
             if (this.txns.isIndirectChanges) {
                 throw new IModelError(IModelStatus.BadRequest, "Cannot delete file property while in an indirect change scope");
             }
@@ -2946,6 +3000,7 @@ export class BriefcaseDb extends IModelDb {
         this.clearCaches();
         this[_nativeDb].discardLocalChanges();
         this[_resetIModelDb]();
+        BriefcaseManager.deleteRebaseFolders(this);
         if (args?.retainLocks) {
             return;
         }
@@ -3118,6 +3173,15 @@ export class BriefcaseDb extends IModelDb {
         this.onOpened.raiseEvent(briefcaseDb, args);
         return briefcaseDb;
     }
+    /**
+     * Iterate through the existing transactions to see if any of them are schema transactions.
+     * @returns true if any schema transactions exist.
+     * @beta
+     */
+    checkIfSchemaTxnExists() {
+        const txnProps = Array.from(this.txns.queryTxns());
+        return txnProps.some((props) => props.type === "Schema" || props.type === "ECSchema");
+    }
     /**  This is called by native code when applying a changeset */
     onChangesetConflict(args) {
         // returning undefined will result in native handler to resolve conflict
@@ -3402,6 +3466,7 @@ export class BriefcaseDb extends IModelDb {
             this.initializeIModelDb("pullMerge");
         });
         this.txns._onChangesPushed(this.changeset);
+        BriefcaseManager.deleteRebaseFolders(this);
     }
     close(options) {
         if (this.isBriefcase && this.isOpen && !this.isReadonly && this.txns.rebaser.inProgress()) {