@itwin/core-backend 5.2.0-dev.7 → 5.2.0

package/lib/esm/TxnManager.js

@@ -12,6 +12,7 @@ import { BackendLoggerCategory } from "./BackendLoggerCategory";
 import { IpcHost } from "./IpcHost";
 import { _nativeDb } from "./internal/Symbols";
 import { RebaseChangesetConflictArgs } from "./internal/ChangesetConflictArgs";
+import { BriefcaseManager } from "./BriefcaseManager";
 /** Strictly for tests. @internal */
 export function setMaxEntitiesPerEvent(max) {
     const prevMax = ChangedEntitiesProc.maxPerEvent;
@@ -193,21 +194,162 @@ class ChangedEntitiesProc {
     }
 }
 /**
- * @internal
- * Manages conflict resolution during a merge operation.
-*/
-export class ChangeMergeManager {
+ * Manages the process of merging and rebasing local changes (transactions) in a [[BriefcaseDb]] or [[StandaloneDb]].
+ *
+ * The `RebaseManager` coordinates the rebase of local transactions when pulling and merging changes from other sources,
+ * such as remote repositories or other users. It provides mechanisms to handle transaction conflicts, register custom conflict
+ * handlers, and manage the rebase workflow. This includes resuming rebases, invoking user-defined handlers for conflict resolution,
+ * and tracking the current merge/rebase state.
+ *
+ * Key responsibilities:
+ * - Orchestrates the rebase of local transactions after a pull/merge operation.
+ * - Allows registration and removal of custom conflict handlers to resolve changeset conflicts during rebase.
+ * - Provides methods to check the current merge/rebase state.
+ * - Raises events before and after each transaction is rebased.
+ * - Ensures changes are saved or aborted appropriately based on the outcome of the rebase process.
+ *
+ * @alpha
+ */
+export class RebaseManager {
     _iModel;
     _conflictHandlers;
+    _customHandler;
     constructor(_iModel) {
         this._iModel = _iModel;
     }
-    resume() {
-        this._iModel[_nativeDb].pullMergeResume();
+    /**
+     * Resumes the rebase process for the current iModel, applying any pending local changes
+     * on top of the latest pulled changes from the remote source.
+     *
+     * This method performs the following steps:
+     * 1. Begins the rebase process using the native database.
+     * 2. Iterates through each transaction that needs to be rebased:
+     *    - Retrieves transaction properties.
+     *    - Raises events before and after rebasing each transaction.
+     *    - Optionally reinstates local changes based on the rebase handler.
+     *    - Optionally recomputes transaction data using the rebase handler.
+     *    - Updates the transaction in the native database.
+     * 3. Ends the rebase process and saves changes if the database is not read-only.
+     * 4. Drops any restore point associated with the pull-merge operation.
+     *
+     * If an error occurs during the process, the rebase is aborted and the error is rethrown.
+     *
+     * @throws {Error} If a transaction cannot be found or if any step in the rebase process fails.
+     */
+    async resume() {
+        const nativeDb = this._iModel[_nativeDb];
+        const txns = this._iModel.txns;
+        try {
+            nativeDb.pullMergeRebaseBegin();
+            let txnId = nativeDb.pullMergeRebaseNext();
+            while (txnId) {
+                const txnProps = txns.getTxnProps(txnId);
+                if (!txnProps) {
+                    throw new Error(`Transaction ${txnId} not found`);
+                }
+                txns.onRebaseTxnBegin.raiseEvent(txnProps);
+                Logger.logInfo(BackendLoggerCategory.IModelDb, `Rebasing local changes for transaction ${txnId}`);
+                const shouldReinstate = this._customHandler?.shouldReinstate(txnProps) ?? true;
+                if (shouldReinstate) {
+                    nativeDb.pullMergeRebaseReinstateTxn();
+                    Logger.logInfo(BackendLoggerCategory.IModelDb, `Reinstated local changes for transaction ${txnId}`);
+                }
+                if (this._customHandler) {
+                    await this._customHandler.recompute(txnProps);
+                }
+                nativeDb.pullMergeRebaseUpdateTxn();
+                txns.onRebaseTxnEnd.raiseEvent(txnProps);
+                txnId = nativeDb.pullMergeRebaseNext();
+            }
+            nativeDb.pullMergeRebaseEnd();
+            if (!nativeDb.isReadonly) {
+                nativeDb.saveChanges("Merge.");
+            }
+            if (BriefcaseManager.containsRestorePoint(this._iModel, BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME)) {
+                BriefcaseManager.dropRestorePoint(this._iModel, BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME);
+            }
+        }
+        catch (err) {
+            nativeDb.pullMergeRebaseAbortTxn();
+            throw err;
+        }
+    }
+    /**
+     * Determines whether the current transaction can be aborted.
+     *
+     * This method checks if a transaction is currently in progress and if a specific restore point,
+     * identified by `BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME`, exists in the briefcase manager.
+     *
+     * @returns {boolean} Returns `true` if a transaction is in progress and the required restore point exists; otherwise, returns `false`.
+     */
+    canAbort() {
+        return this.inProgress() && BriefcaseManager.containsRestorePoint(this._iModel, BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME);
+    }
+    /**
+     * Aborts the current transaction by restoring the iModel to a predefined restore point.
+     *
+     * If a restore point is available (as determined by `canAbort()`), this method restores the iModel
+     * to the state saved at the restore point named by `BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME`.
+     * If no restore point is available, an error is thrown.
+     *
+     * @returns A promise that resolves when the restore operation is complete.
+     * @throws {Error} If there is no restore point to abort to.
+     */
+    async abort() {
+        if (this.canAbort()) {
+            return BriefcaseManager.restorePoint(this._iModel, BriefcaseManager.PULL_MERGE_RESTORE_POINT_NAME);
+        }
+        else {
+            throw new Error("No restore point to abort to");
+        }
+    }
+    /**
+     * Sets the handler to be invoked for rebase operations.
+     *
+     * @param handler - The {@link RebaseHandler} to handle rebase events.
+     */
+    setCustomHandler(handler) {
+        if (this._customHandler) {
+            Logger.logWarning(BackendLoggerCategory.IModelDb, "Rebase handler already set");
+        }
+        this._customHandler = handler;
     }
+    /**
+     * Determines whether a transaction is currently in progress.
+     *
+     * @returns {boolean} Returns `true` if there is an active transaction stage, otherwise `false`.
+     */
     inProgress() {
-        return this._iModel[_nativeDb].pullMergeInProgress();
+        return this._iModel[_nativeDb].pullMergeGetStage() !== "None";
     }
+    /**
+     * Indicates whether the current transaction manager is in the "Rebasing" stage.
+     *
+     * This property checks the internal native database's merge stage to determine if a rebase operation is in progress.
+     *
+     * @returns `true` if the transaction manager is currently rebasing; otherwise, `false`.
+     */
+    get isRebasing() {
+        return this._iModel[_nativeDb].pullMergeGetStage() === "Rebasing";
+    }
+    /**
+     * Indicates whether the current iModel is in the process of merging changes from a pull operation.
+     *
+     * @returns `true` if the iModel is currently merging changes; otherwise, `false`.
+     */
+    get isMerging() {
+        return this._iModel[_nativeDb].pullMergeGetStage() === "Merging";
+    }
+    /**
+     * Attempts to resolve a changeset conflict by invoking registered conflict handlers in sequence.
+     *
+     * Iterates through the linked list of conflict handlers, passing the provided conflict arguments to each handler.
+     * If a handler returns a defined resolution, logs the resolution and returns it immediately.
+     * If no handler resolves the conflict, returns `undefined`.
+     *
+     * @param args - The arguments describing the changeset conflict to resolve.
+     * @returns The conflict resolution provided by a handler, or `undefined` if no handler resolves the conflict.
+     */
     onConflict(args) {
         let curr = this._conflictHandlers;
         while (curr) {
@@ -220,6 +362,18 @@ export class ChangeMergeManager {
         }
         return undefined;
     }
+    /**
+     * Registers a new conflict handler for rebase changeset conflicts.
+     *
+     * @param args - An object containing:
+     *   - `id`: A unique identifier for the conflict handler.
+     *   - `handler`: A function that handles rebase changeset conflicts and returns a `DbConflictResolution` or `undefined`.
+     * @throws IModelError if a conflict handler with the same `id` already exists.
+     *
+     * @remarks
+     * Conflict handlers are used during changeset rebase operations to resolve conflicts.
+     * Each handler must have a unique `id`. Attempting to register a handler with a duplicate `id` will result in an error.
+     */
     addConflictHandler(args) {
         const idExists = (id) => {
             let curr = this._conflictHandlers;
@@ -234,6 +388,14 @@ export class ChangeMergeManager {
             throw new IModelError(DbResult.BE_SQLITE_ERROR, `Conflict handler with id ${args.id} already exists`);
         this._conflictHandlers = { ...args, next: this._conflictHandlers };
     }
+    /**
+     * Removes a conflict handler from the internal linked list by its identifier.
+     *
+     * @param id - The unique identifier of the conflict handler to remove.
+     *
+     * If the handler with the specified `id` exists in the list, it will be removed.
+     * If no handler with the given `id` is found, the method does nothing.
+     */
     removeConflictHandler(id) {
         if (!this._conflictHandlers)
             return;
@@ -265,11 +427,11 @@ export class TxnManager {
         return this._isDisposed;
     }
     /** @internal */
-    changeMergeManager;
+    rebaser;
     /** @internal */
     constructor(_iModel) {
         this._iModel = _iModel;
-        this.changeMergeManager = new ChangeMergeManager(_iModel);
+        this.rebaser = new RebaseManager(_iModel);
         _iModel.onBeforeClose.addOnce(() => {
             this._isDisposed = true;
         });
@@ -367,12 +529,6 @@ export class TxnManager {
         this.onAfterUndoRedo.raiseEvent(isUndo);
         IpcHost.notifyTxns(this._iModel, "notifyAfterUndoRedo", isUndo);
     }
-    _onRebaseTxnBegin(txn) {
-        this.onRebaseTxnBegin.raiseEvent(txn);
-    }
-    _onRebaseTxnEnd(txn) {
-        this.onRebaseTxnEnd.raiseEvent(txn);
-    }
     _onRebaseLocalTxnConflict(internalArg) {
         const args = new RebaseChangesetConflictArgs(internalArg, this._iModel);
         const getChangeMetaData = () => {
@@ -404,7 +560,7 @@ export class TxnManager {
             }
         }
         try {
-            const resolution = this.changeMergeManager.onConflict(args);
+            const resolution = this.rebaser.onConflict(args);
             if (resolution !== undefined)
                 return resolution;
         }
@@ -435,11 +591,43 @@ export class TxnManager {
             return DbConflictResolution.Skip;
         }
         if (args.cause === "Constraint") {
-            Logger.logInfo(BackendLoggerCategory.IModelDb, "Constraint voilation detected. Generally caused by db constraints like UNIQUE index. Skipping local change.", getChangeMetaData());
+            Logger.logInfo(BackendLoggerCategory.IModelDb, "Constraint violation detected. Generally caused by db constraints like UNIQUE index. Skipping local change.", getChangeMetaData());
             return DbConflictResolution.Skip;
         }
         return DbConflictResolution.Replace;
     }
+    /**
+     * @alpha
+     * Retrieves the txn properties for a given txn ID.
+     *
+     * @param id - The unique identifier of the transaction.
+     * @returns The properties of the transaction if found; otherwise, `undefined`.
+     */
+    getTxnProps(id) {
+        return this._iModel[_nativeDb].getTxnProps(id);
+    }
+    /**
+     * @alpha
+     * Iterates over all transactions in the sequence, yielding each transaction's properties.
+     *
+     * @yields {TxnProps} The properties of each transaction in the sequence.
+     */
+    *queryTxns() {
+        let txn = this.getTxnProps(this.queryFirstTxnId());
+        while (txn) {
+            yield txn;
+            txn = txn.nextId ? this.getTxnProps(txn.nextId) : undefined;
+        }
+    }
+    /**
+     * @alpha
+     * Retrieves the properties of the last saved txn via `IModelDb.saveChanges()`, if available.
+     *
+     * @returns The properties of the last saved txn, or `undefined` if none exist.
+     */
+    getLastSavedTxnProps() {
+        return this.getTxnProps(this.queryPreviousTxnId(this.getCurrentTxnId()));
+    }
     /** Dependency handlers may call method this to report a validation error.
      * @param error The error. If error.fatal === true, the transaction will cancel rather than commit.
      */
@@ -489,12 +677,18 @@ export class TxnManager {
      * @see [[onReplayExternalTxns]] for the event raised before the changes are applied.
      */
     onReplayedExternalTxns = new BeEvent();
-    /** @internal */
+    /**
+     * @alpha
+     * Event raised when a rebase transaction begins.
+     */
     onRebaseTxnBegin = new BeEvent();
-    /** @internal */
+    /**
+     * @alpha
+     * Event raised when a rebase transaction ends.
+     */
     onRebaseTxnEnd = new BeEvent();
     /**
-     * if handler is set and it does not return undefiend then default handler will not be called
+     * if handler is set and it does not return undefined then default handler will not be called
      * @internal
      * */
     appCustomConflictHandler;
@@ -509,7 +703,7 @@ export class TxnManager {
         this._nativeDb.restartTxnSession();
     }
     /** Determine whether current txn is propagating indirect changes or not. */
-    get isIndirectChanges() { return this._nativeDb.isIndirectChanges(); }
+    get isIndirectChanges() { return this.getMode() === "indirect"; }
     /** Determine if there are currently any reversible (undoable) changes from this editing session. */
     get isUndoPossible() { return this._nativeDb.isUndoPossible(); }
     /** Determine if there are currently any reinstatable (redoable) changes */
@@ -574,6 +768,11 @@ export class TxnManager {
     queryPreviousTxnId(txnId) { return this._nativeDb.queryPreviousTxnId(txnId); }
     /** Get the Id of the current (tip) transaction.  */
     getCurrentTxnId() { return this._nativeDb.getCurrentTxnId(); }
+    /**
+     * @alpha
+     * Get the Id of the current session.
+     */
+    getCurrentSessionId() { return this._nativeDb.currentTxnSessionId(); }
     /** Get the description that was supplied when the specified transaction was saved. */
     getTxnDescription(txnId) { return this._nativeDb.getTxnDescription(txnId); }
     /** Test if a TxnId is valid */
@@ -587,6 +786,11 @@ export class TxnManager {
      * @see [[IModelDb.saveChanges]]
      */
     get hasUnsavedChanges() { return this._nativeDb.hasUnsavedChanges(); }
+    /**
+     * @alpha
+     * Query if there are any pending schema changes in this IModelDb.
+     */
+    get hasPendingSchemaChanges() { return this._nativeDb.hasPendingSchemaChanges(); }
     /**
      * Query if there are changes in memory that have not been saved to the iModelDb or if there are Txns that are waiting to be pushed.
      * @see [[IModelDb.saveChanges]]
@@ -616,5 +820,27 @@ export class TxnManager {
     getChangeTrackingMemoryUsed() {
         return this._iModel[_nativeDb].getChangeTrackingMemoryUsed();
     }
+    /**
+     * @alpha
+     * Get the current transaction mode.
+     * @returns The current transaction mode, either "direct" or "indirect".
+     */
+    getMode() {
+        return this._nativeDb.getTxnMode();
+    }
+    /**
+     * @alpha
+     * Execute a series of changes in an indirect transaction.
+     * @param callback The function containing the changes to make.
+     */
+    withIndirectTxnMode(callback) {
+        this._nativeDb.setTxnMode("indirect");
+        try {
+            callback();
+        }
+        finally {
+            this._nativeDb.setTxnMode("direct");
+        }
+    }
 }
 //# sourceMappingURL=TxnManager.js.map