@itwin/core-backend 5.10.0-dev.5 → 5.10.0-dev.7

package/lib/cjs/TxnManager.js

@@ -6,6 +6,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;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxnManager = exports.RebaseManager = void 0;
 exports.setMaxEntitiesPerEvent = setMaxEntitiesPerEvent;
@@ -17,6 +69,8 @@ const IpcHost_1 = require("./IpcHost");
 const Symbols_1 = require("./internal/Symbols");
 const ChangesetConflictArgs_1 = require("./internal/ChangesetConflictArgs");
 const BriefcaseManager_1 = require("./BriefcaseManager");
+const ChangesetReader_1 = require("./ChangesetReader");
+const PartialChangeUnifier_1 = require("./PartialChangeUnifier");
 /** Strictly for tests. @internal */
 function setMaxEntitiesPerEvent(max) {
     const prevMax = ChangedEntitiesProc.maxPerEvent;
@@ -518,16 +572,15 @@ class RebaseManager {
             if (!BriefcaseManager_1.BriefcaseManager.semanticRebaseDataFolderExists(this._iModel, txnProps.id)) {
                 throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Local folder does not exist for transaction ${txnProps.id}`);
             }
-            const changedInstances = BriefcaseManager_1.BriefcaseManager.getChangedInstancesDataForTxn(this._iModel, txnProps.id);
-            changedInstances.forEach((instance) => {
-                if (instance.isIndirect) {
+            for await (const instance of BriefcaseManager_1.BriefcaseManager.getChangedInstancesDataForTxn(this._iModel, txnProps.id)) {
+                if (instance.$meta.isIndirectChange) {
                     this._iModel.txns.withIndirectTxnMode(() => {
                         this.applyInstancePatch(instance);
                     });
-                    return;
+                    continue;
                 }
                 this.applyInstancePatch(instance);
-            });
+            }
             BriefcaseManager_1.BriefcaseManager.deleteTxnDataFolder(this._iModel, txnProps.id); // delete the folder after importing
         }
         else {
@@ -541,27 +594,34 @@ class RebaseManager {
      */
     applyInstancePatch(instance) {
         const nativeDb = this._iModel[Symbols_1._nativeDb];
-        switch (instance.op) {
+        const { $meta, ...props } = instance;
+        switch ($meta.op) {
             case "Inserted": {
-                if (!instance.props)
+                if (!props)
                     throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "InstancePatch with op 'Inserted' must have props");
                 const options = { forceUseId: true, useJsNames: true };
-                nativeDb.insertInstance(instance.props, options);
+                const id = nativeDb.insertInstance(props, options);
+                if (!core_bentley_1.Id64.isValidId64(id))
+                    throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Failed to insert instance with id ${props.id}`);
                 break;
             }
             case "Updated": {
-                if (!instance.props)
+                if (!props)
                     throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, "InstancePatch with op 'Updated' must have props");
-                nativeDb.updateInstance(instance.props, { useJsNames: true });
+                const isSuccess = nativeDb.updateInstance(props, { useJsNames: true });
+                if (!isSuccess)
+                    throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Failed to update instance with id ${props.id}`);
                 break;
             }
             case "Deleted": {
-                const key = { id: instance.key.id, classFullName: instance.key.classFullName };
-                nativeDb.deleteInstance(key, { useJsNames: true });
+                const key = { id: props.id, classFullName: props.className };
+                const isSuccess = nativeDb.deleteInstance(key, { useJsNames: true });
+                if (!isSuccess)
+                    throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Failed to delete instance with id ${props.id}`);
                 break;
             }
             default:
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Unknown InstancePatch op '${instance.op}'`);
+                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadRequest, `Unknown InstancePatch op '${$meta.op}'`);
         }
     }
     /**
@@ -805,6 +865,28 @@ class TxnManager {
         this.onEndValidation.raiseEvent();
         // TODO: if (this.validationErrors.length !== 0) throw new IModelError(validation ...)
     }
+    /** Called by native code during semantic rebase while reversing local changes to create instance patches to be used for reinstating changes.
+     * @internal */
+    _captureInstanceChanges(id) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            if (BriefcaseManager_1.BriefcaseManager.semanticRebaseDataFolderExists(this._iModel, id))
+                return; // if folder already exists that means we have already captured the changes for this txn during this rebase so we can skip capturing again
+            const reader = __addDisposableResource(env_1, ChangesetReader_1.ChangesetReader.openTxn({ db: this._iModel, txnId: id, rowOptions: { useJsName: true, abbreviateBlobs: false } }), false);
+            const pcu = __addDisposableResource(env_1, new PartialChangeUnifier_1.PartialChangeUnifier(PartialChangeUnifier_1.ChangeUnifierCache.createSqliteBackedCache()), false);
+            while (reader.step()) {
+                pcu.appendFrom(reader);
+            }
+            BriefcaseManager_1.BriefcaseManager.storeChangedInstancesForSemanticRebase(this._iModel, id, pcu.instances);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
     /** @internal */
     _onGeometryChanged(modelProps) {
         this.onGeometryChanged.raiseEvent(modelProps);