@itwin/core-backend 5.7.0-dev.8 → 5.8.0-dev.1

package/lib/esm/BriefcaseManager.js

@@ -5,6 +5,58 @@
 /** @packageDocumentation
  * @module iModels
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 // cspell:ignore cset csets ecchanges
 import * as path from "node:path";
 import * as os from "node:os";
@@ -19,6 +71,8 @@ import { SchemaSync } from "./SchemaSync";
 import { _hubAccess, _nativeDb, _releaseAllLocks } from "./internal/Symbols";
 import { IModelNative } from "./internal/NativePlatform";
 import { StashManager } from "./StashManager";
+import { ChangesetECAdaptor, ECChangeUnifierCache, PartialECChangeUnifier } from "./ChangesetECAdaptor";
+import { SqliteChangesetReader } from "./SqliteChangesetReader";
 const loggerCategory = BackendLoggerCategory.IModelDb;
 /** Manages downloading Briefcases and downloading and uploading changesets.
  * @public
@@ -229,6 +283,8 @@ export class BriefcaseManager {
                 briefcaseId: db.getBriefcaseId(),
             };
             db.closeFile();
+            if (this.isValidBriefcaseId(briefcase.briefcaseId))
+                this.cleanupRebaseFolders(filePath, briefcase.briefcaseId); // cleanup rebase folders
             if (accessToken) {
                 if (this.isValidBriefcaseId(briefcase.briefcaseId)) {
                     await BriefcaseManager.releaseBriefcase(accessToken, briefcase);
@@ -462,10 +518,24 @@ export class BriefcaseManager {
             Logger.logInfo(loggerCategory, `Creating restore point ${this.PULL_MERGE_RESTORE_POINT_NAME}`);
             await this.createRestorePoint(briefcaseDb, this.PULL_MERGE_RESTORE_POINT_NAME);
         }
+        const hasIncomingSchemaChange = changesets.some((changeset) => changeset.changesType === ChangesetType.Schema);
+        const hasLocalSchemaTxn = briefcaseDb?.checkIfSchemaTxnExists() ?? false;
+        const useSemanticRebase = briefcaseDb !== undefined &&
+            IModelHost.useSemanticRebase &&
+            (hasIncomingSchemaChange || hasLocalSchemaTxn);
+        if (useSemanticRebase) {
+            Logger.logInfo(loggerCategory, `Using semantic rebase (incoming schema change: ${hasIncomingSchemaChange}, local schema txn: ${hasLocalSchemaTxn})`);
+        }
         if (!reverse) {
             if (briefcaseDb) {
+                if (useSemanticRebase) {
+                    this.capturePatchInstances(briefcaseDb);
+                }
                 briefcaseDb.txns.rebaser.notifyReverseLocalChangesBegin();
                 const reversedTxns = nativeDb.pullMergeReverseLocalChanges();
+                if (useSemanticRebase) {
+                    nativeDb.clearECDbCache(); // Clear the ECDb cache after reversing local changes to ensure consistency during semantic rebase with schema changes.
+                }
                 const reversedTxnProps = reversedTxns.map((txn) => briefcaseDb.txns.getTxnProps(txn)).filter((props) => props !== undefined);
                 briefcaseDb.txns.rebaser.notifyReverseLocalChangesEnd(reversedTxnProps);
                 Logger.logInfo(loggerCategory, `Reversed ${reversedTxns.length} local changes`);
@@ -498,7 +568,10 @@ export class BriefcaseManager {
         }
         if (!reverse) {
             if (briefcaseDb) {
-                await briefcaseDb.txns.rebaser.resume();
+                if (useSemanticRebase)
+                    await briefcaseDb.txns.rebaser.resumeSemantic();
+                else
+                    await briefcaseDb.txns.rebaser.resume();
             }
             else {
                 // Only Briefcase has change management. Following is
@@ -678,5 +751,267 @@ export class BriefcaseManager {
             }
         }
     }
+    // #region Semantic Rebase Interop Helper
+    static REBASING_FOLDER = ".rebasing";
+    static EC_FOLDER = "ec";
+    static SCHEMAS_FOLDER = "schemas";
+    static DATA_FOLDER = "data";
+    static DATA_FILE_NAME = "data.json";
+    /**
+     * Captures the changed instances as patch instances from each data txn in the briefcase db for semantic rebase
+     * @param db The {@link BriefcaseDb} instance for which to capture the changed instances as patch instances for all data txns
+     * @internal
+     */
+    static capturePatchInstances(db) {
+        const txns = Array.from(db.txns.queryTxns());
+        txns.forEach((txn) => {
+            if (txn.type !== "Data")
+                return;
+            // already captured(This actually shows that first rebase operation is already done but during that while reinstating this txns,
+            // some error happened so the folder still exists so we don't want to capture again)
+            if (this.semanticRebaseDataFolderExists(db, txn.id))
+                return;
+            const changedInstances = this.captureChangedInstancesAsJSON(db, txn.id);
+            const instancePatches = this.constructPatchInstances(db, changedInstances);
+            this.storeChangedInstancesForSemanticRebase(db, txn.id, instancePatches);
+        });
+    }
+    /**
+     * Captures changed instances from a txn as JSON
+     * @param txnId The txn id for which to capture changed instances
+     * @param db The {@link BriefcaseDb} instance from which to capture changed instances as json
+     * @returns changed instances for semantic rebase
+     * @internal
+     */
+    static captureChangedInstancesAsJSON(db, txnId) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = SqliteChangesetReader.openTxn({
+                txnId, db, disableSchemaCheck: true
+            });
+            const adaptor = new ChangesetECAdaptor(reader);
+            const indirectUnifier = __addDisposableResource(env_1, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+            const directUnifier = __addDisposableResource(env_1, new PartialECChangeUnifier(reader.db, ECChangeUnifierCache.createInMemoryCache()), false);
+            while (adaptor.step()) {
+                if (adaptor.reader.isIndirect)
+                    indirectUnifier.appendFrom(adaptor);
+                else
+                    directUnifier.appendFrom(adaptor);
+            }
+            return [...Array.from(directUnifier.instances).map((instance) => ({ isIndirect: false, instance })), ...Array.from(indirectUnifier.instances).map((instance) => ({ isIndirect: true, instance }))];
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    /**
+     * Constructs patch instances from changed instances
+     * @param changedInstances The changed instances from which to construct the patch instances
+     * @param db The {@link BriefcaseDb} instance for which to construct the patch instances
+     * @returns  The {@link InstancePatch} instance patches for semantic rebase
+     * @internal
+     */
+    static constructPatchInstances(db, changedInstances) {
+        return changedInstances
+            .filter((changedInstance) => !(changedInstance.instance.$meta?.op === "Updated" && changedInstance.instance.$meta.stage === "Old")) // we will not take the old stage of updated instances
+            .map((changedInstance) => this.constructPatchInstance(db, changedInstance));
+    }
+    /**
+     * Constructs a single patch instance from changed instance
+     * @param changedInstance The changed instance from which to construct the patch instance
+     * @param db The {@link BriefcaseDb} instance for which to construct the single patch instance
+     * @returns a single instance patch {@link InstancePatch}
+     * @throws IModelError If cannot determine classId or unknown operation encountered
+     */
+    static constructPatchInstance(db, changedInstance) {
+        const className = (changedInstance.instance.ECClassId && db.getClassNameFromId(changedInstance.instance.ECClassId))
+            ?? changedInstance.instance.$meta?.classFullName
+            ?? (changedInstance.instance.$meta?.fallbackClassId && db.getClassNameFromId(changedInstance.instance.$meta.fallbackClassId));
+        if (!className)
+            throw new IModelError(IModelStatus.BadArg, "Cannot determine classId of changed instance");
+        const instanceKey = { id: changedInstance.instance.ECInstanceId, classFullName: className };
+        const op = changedInstance.instance.$meta?.op;
+        if (op !== "Inserted" && op !== "Updated" && op !== "Deleted")
+            throw new IModelError(IModelStatus.BadArg, `Unknown operation: ${op}`);
+        return {
+            key: instanceKey,
+            op,
+            isIndirect: changedInstance.isIndirect,
+            props: op !== "Deleted" ? db[_nativeDb].readInstance(instanceKey, { useJsNames: true }) : undefined,
+        };
+    }
+    /**
+     * Stores changed instances for semantic rebase locally in appropriate json file in a folder structure
+     * @param db The {@link BriefcaseDb} instance for storing the changed instances against a txn
+     * @param txnId The txn id for which we are storing the changed instances
+     * @param instancePatches The {@link InstancePatch} instance patches to be stored
+     * @internal
+     */
+    static storeChangedInstancesForSemanticRebase(db, txnId, instancePatches) {
+        const basePath = this.getBasePathForSemanticRebaseLocalFiles(db);
+        const targetDir = path.join(basePath, txnId, this.DATA_FOLDER);
+        const filePath = path.join(targetDir, this.DATA_FILE_NAME);
+        if (IModelJsFs.existsSync(targetDir))
+            IModelJsFs.removeSync(targetDir);
+        IModelJsFs.recursiveMkDirSync(targetDir);
+        IModelJsFs.writeFileSync(filePath, JSON.stringify(instancePatches, undefined, 2));
+    }
+    /**
+     * Gets the base path for semantic rebase local files
+     * @param db The {@link BriefcaseDb} instance for which to get the base path
+     * @returns base path for semantic rebase local files
+     * @internal
+     */
+    static getBasePathForSemanticRebaseLocalFiles(db) {
+        return path.join(path.dirname(db.pathName), this.REBASING_FOLDER, db.briefcaseId.toString(), this.EC_FOLDER);
+    }
+    /**
+     * Stores schemas for semantic rebase locally in appropriate folder structure
+     * @param db The {@link BriefcaseDb} instance for storing the schemas against a txn
+     * @param txnId The txn id for which we are storing the schemas
+     * @param schemaFileNames The schema file paths or schema xml strings to be stored
+     * @internal
+     */
+    static storeSchemasForSemanticRebase(db, txnId, schemaFileNames) {
+        const basePath = this.getBasePathForSemanticRebaseLocalFiles(db);
+        const targetDir = path.join(basePath, txnId, this.SCHEMAS_FOLDER);
+        if (IModelJsFs.existsSync(targetDir))
+            IModelJsFs.removeSync(targetDir);
+        IModelJsFs.recursiveMkDirSync(targetDir);
+        schemaFileNames.forEach((schemaFileOrXml, index) => {
+            if (IModelJsFs.existsSync(schemaFileOrXml)) { // This means it is a file
+                const fileName = path.basename(schemaFileOrXml);
+                const filePath = path.join(targetDir, fileName);
+                IModelJsFs.copySync(schemaFileOrXml, filePath);
+            }
+            else {
+                const fileName = `${"Schema"}_${index}.ecschema.xml`;
+                const filePath = path.join(targetDir, fileName);
+                IModelJsFs.writeFileSync(filePath, schemaFileOrXml);
+            }
+        });
+    }
+    /**
+     * Gets schemas for semantic rebase for a txn
+     * @param db The {@link BriefcaseDb} instance for getting the locally stored schemas against a txn
+     * @param txnId The txn id for which we are getting the schemas
+     * @returns the schema file paths
+     * @internal
+     */
+    static getSchemasForTxn(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const folderPath = path.join(basePath, txnId, BriefcaseManager.SCHEMAS_FOLDER);
+        return IModelJsFs.readdirSync(folderPath).map((file) => path.join(folderPath, file));
+    }
+    /**
+     * Get the changed instances data for semantic rebase for a txn
+     * @param db - The {@link BriefcaseDb} instance for getting the locally stored changed instances against a txn
+     * @param txnId - The txn id for which we are getting the changed instances
+     * @returns Instance patches
+     * @internal
+     */
+    static getChangedInstancesDataForTxn(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const folderPath = path.join(basePath, txnId, BriefcaseManager.DATA_FOLDER);
+        const filePath = path.join(folderPath, BriefcaseManager.DATA_FILE_NAME);
+        const fileContents = IModelJsFs.readFileWithEncodingSync(filePath, "utf-8");
+        return JSON.parse(fileContents);
+    }
+    /**
+     * Checks if schema folder exists for semantic rebase for a txn
+     * @param db - The {@link BriefcaseDb} instance for which TO check the schema folder
+     * @param txnId - The txn id for which we are check the schema folder
+     * @returns true if exists, false otherwise
+     * @internal
+     */
+    static semanticRebaseSchemaFolderExists(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const folderPath = path.join(basePath, txnId, BriefcaseManager.SCHEMAS_FOLDER);
+        return IModelJsFs.existsSync(folderPath);
+    }
+    /**
+     * Checks if data folder exists for semantic rebase for a txn
+     * @param db The {@link BriefcaseDb} instance for which to check the data folder.
+     * @param txnId The txn id for which to check the data folder
+     * @returns true if exists, false otherwise
+     * @internal
+     */
+    static semanticRebaseDataFolderExists(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const folderPath = path.join(basePath, txnId, BriefcaseManager.DATA_FOLDER);
+        return IModelJsFs.existsSync(folderPath);
+    }
+    /**
+     * Deletes the schema folder for semantic rebase for a txn
+     * @param db The {@link BriefcaseDb} instance for which to delete the schema folder.
+     * @param txnId The txn id for which to delete the schema folder
+     * @internal
+     */
+    static deleteTxnSchemaFolder(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const txnFolderPath = path.join(basePath, txnId);
+        const folderPath = path.join(txnFolderPath, BriefcaseManager.SCHEMAS_FOLDER);
+        if (!IModelJsFs.existsSync(folderPath))
+            return;
+        IModelJsFs.removeSync(folderPath);
+        if (IModelJsFs.readdirSync(txnFolderPath).length === 0) // Also delete the txn folder if empty
+            IModelJsFs.removeSync(txnFolderPath);
+    }
+    /**
+    * Deletes the data folder for semantic rebase for a txn
+    * @param db The {@link BriefcaseDb} instance for which to delete the data folder.
+    * @param txnId The txn id for which to delete the data folder
+    * @internal
+    */
+    static deleteTxnDataFolder(db, txnId) {
+        const basePath = BriefcaseManager.getBasePathForSemanticRebaseLocalFiles(db);
+        const txnFolderPath = path.join(basePath, txnId);
+        const folderPath = path.join(txnFolderPath, BriefcaseManager.DATA_FOLDER);
+        if (!IModelJsFs.existsSync(folderPath))
+            return;
+        IModelJsFs.removeSync(folderPath);
+        if (IModelJsFs.readdirSync(txnFolderPath).length === 0) // Also delete the txn folder if empty
+            IModelJsFs.removeSync(txnFolderPath);
+    }
+    /**
+     * Deletes rebase folders for semantic rebase
+     * @param db The {@link BriefcaseDb} instance for which to delete the rebase folders.
+     * @param checkIfEmpty If true, only deletes the base folder if it is empty, default is false
+     * @internal
+     */
+    static deleteRebaseFolders(db, checkIfEmpty = false) {
+        const briefcaseRebasingRoot = path.join(path.dirname(db.pathName), this.REBASING_FOLDER, db.briefcaseId.toString());
+        if (!IModelJsFs.existsSync(briefcaseRebasingRoot))
+            return;
+        if (checkIfEmpty) {
+            const basePath = this.getBasePathForSemanticRebaseLocalFiles(db);
+            if (IModelJsFs.existsSync(basePath) && IModelJsFs.readdirSync(basePath).length > 0)
+                return;
+        }
+        IModelJsFs.removeSync(briefcaseRebasingRoot);
+        // remove .rebasing root if it's now empty
+        const rebasingRoot = path.join(path.dirname(db.pathName), this.REBASING_FOLDER);
+        if (IModelJsFs.existsSync(rebasingRoot) && IModelJsFs.readdirSync(rebasingRoot).length === 0)
+            IModelJsFs.removeSync(rebasingRoot);
+    }
+    /**
+     * Cleans up rebase folders for semantic rebase given briefcase file path and briefcase id
+     * @param briefcaseFilePath The briefcase file path
+     * @param briefcaseId The briefcase id
+     * @internal
+     */
+    static cleanupRebaseFolders(briefcaseFilePath, briefcaseId) {
+        const briefcaseRebasingRoot = path.join(path.dirname(briefcaseFilePath), this.REBASING_FOLDER, briefcaseId.toString());
+        if (IModelJsFs.existsSync(briefcaseRebasingRoot))
+            IModelJsFs.removeSync(briefcaseRebasingRoot);
+        // remove .rebasing root if it's now empty
+        const rebasingRoot = path.join(path.dirname(briefcaseFilePath), this.REBASING_FOLDER);
+        if (IModelJsFs.existsSync(rebasingRoot) && IModelJsFs.readdirSync(rebasingRoot).length === 0)
+            IModelJsFs.removeSync(rebasingRoot);
+    }
 }
 //# sourceMappingURL=BriefcaseManager.js.map