@itwin/core-backend 5.6.0-dev.8 → 5.7.0-dev.2

package/lib/esm/test/hubaccess/Rebase.test.js

@@ -3,15 +3,16 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 import { DbResult, Guid } from "@itwin/core-bentley";
-import { Code, IModel, QueryBinder, SubCategoryAppearance } from "@itwin/core-common";
+import { Code, GeometryStreamBuilder, IModel, QueryBinder, SubCategoryAppearance } from "@itwin/core-common";
 import * as chai from "chai";
 import * as chaiAsPromised from "chai-as-promised";
 import { HubWrappers, IModelTestUtils, KnownTestLocations } from "..";
-import { BriefcaseManager, ChangesetECAdaptor, ChannelControl, DrawingCategory, ElementGroupsMembers, IModelHost, SqliteChangesetReader } from "../../core-backend";
+import { _nativeDb, BriefcaseManager, ChangesetECAdaptor, ChannelControl, DrawingCategory, ElementGroupsMembers, IModelHost, SqliteChangesetReader } from "../../core-backend";
 import { HubMock } from "../../internal/HubMock";
 import { StashManager } from "../../StashManager";
 import { existsSync, unlinkSync, writeFileSync } from "fs";
 import * as path from "path";
+import { LineSegment3d, Point3d } from "@itwin/core-geometry";
 chai.use(chaiAsPromised);
 class TestIModel {
     iModelId = "";
@@ -33,6 +34,10 @@ class TestIModel {
             <BaseClass>bis:GraphicalElement2d</BaseClass>
             <ECProperty propertyName="prop1" typeName="string" />
         </ECEntityClass>
+        <ECEntityClass typeName="A1Recipe2d">
+            <BaseClass>bis:TemplateRecipe2d</BaseClass>
+            <ECProperty propertyName="prop1" typeName="string" />
+        </ECEntityClass>
         <ECRelationshipClass typeName="A1OwnsA1" modifier="None" strength="embedding">
             <BaseClass>bis:ElementOwnsChildElements</BaseClass>
             <Source multiplicity="(0..1)" roleLabel="owns" polymorphic="true">
@@ -65,31 +70,73 @@ class TestIModel {
         this.briefcases.push(b);
         return b;
     }
+    async insertRecipe2d(b, markAsIndirect) {
+        await b.locks.acquireLocks({ shared: [IModel.dictionaryId] });
+        const baseProps = {
+            classFullName: "TestDomain:A1Recipe2d",
+            model: IModel.dictionaryId,
+            code: Code.createEmpty(),
+        };
+        let id = "";
+        if (markAsIndirect) {
+            b.txns.withIndirectTxnMode(() => {
+                id = b.elements.insertElement({ ...baseProps, prop1: `${this._data++}` });
+            });
+            return id;
+        }
+        return b.elements.insertElement({ ...baseProps, prop1: `${this._data++}` });
+    }
+    async updateRecipe2d(b, id, markAsIndirect) {
+        await b.locks.acquireLocks({ shared: [IModel.dictionaryId], exclusive: [id] });
+        const elProps = b.elements.getElementProps(id);
+        if (markAsIndirect) {
+            b.txns.withIndirectTxnMode(() => {
+                b.elements.updateElement({ ...elProps, prop1: `${this._data++}` });
+            });
+        }
+        else {
+            b.elements.updateElement({ ...elProps, prop1: `${this._data++}` });
+        }
+    }
     async insertElement(b, markAsIndirect) {
         await b.locks.acquireLocks({ shared: [this.drawingModelId] });
+        const builder = new GeometryStreamBuilder();
+        const p1 = Point3d.createZero();
+        const p2 = Point3d.createFrom({ x: Math.random() * 10.0 + 5.0, y: 0.0, z: 0.0 });
+        const circle = LineSegment3d.create(p1, p2);
+        builder.appendGeometry(circle);
         const baseProps = {
             classFullName: "TestDomain:a1",
             model: this.drawingModelId,
             category: this.drawingCategoryId,
             code: Code.createEmpty(),
+            geom: builder.geometryStream,
+            prop1: `${this._data++}`,
         };
         let id = "";
         if (markAsIndirect) {
             b.txns.withIndirectTxnMode(() => {
-                id = b.elements.insertElement({ ...baseProps, prop1: `${this._data++}` });
+                id = b.elements.insertElement(baseProps);
             });
             return id;
         }
-        return b.elements.insertElement({ ...baseProps, prop1: `${this._data++}` });
+        baseProps.prop1 = `${this._data++}`;
+        return b.elements.insertElement(baseProps);
     }
-    async insertElement2(b, args) {
+    async insertElementEx(b, args) {
         await b.locks.acquireLocks({ shared: [this.drawingModelId] });
+        const builder = new GeometryStreamBuilder();
+        const p1 = Point3d.createZero();
+        const p2 = Point3d.createFrom({ x: Math.random() * 10.0 + 5.0, y: 0.0, z: 0.0 });
+        const circle = LineSegment3d.create(p1, p2);
+        builder.appendGeometry(circle);
         const props = {
             classFullName: "TestDomain:a1",
             model: this.drawingModelId,
             category: this.drawingCategoryId,
             code: Code.createEmpty(),
             parent: args?.parent,
+            geom: builder.geometryStream,
             prop1: args?.prop1 ?? `${this._data++}`
         };
         let id = "";
@@ -101,9 +148,17 @@ class TestIModel {
         }
         return b.elements.insertElement(props);
     }
-    async updateElement(b, id, markAsIndirect) {
+    async updateElement(b, id, markAsIndirect, updateGeom) {
         await b.locks.acquireLocks({ shared: [this.drawingModelId], exclusive: [id] });
         const elProps = b.elements.getElementProps(id);
+        if (updateGeom) {
+            const builder = new GeometryStreamBuilder();
+            const p1 = Point3d.createZero();
+            const p2 = Point3d.createFrom({ x: Math.random() * 10.0 + 10.0, y: 0.0, z: 0.0 });
+            const circle = LineSegment3d.create(p1, p2);
+            builder.appendGeometry(circle);
+            elProps.geom = builder.geometryStream;
+        }
         if (markAsIndirect) {
             b.txns.withIndirectTxnMode(() => {
                 b.elements.updateElement({ ...elProps, prop1: `${this._data++}` });
@@ -129,6 +184,18 @@ class TestIModel {
         HubMock.shutdown();
     }
 }
+const removePropertyRecursive = (obj, prop) => {
+    if (obj && typeof obj === "object") {
+        Object.keys(obj).forEach((key) => {
+            if (key === prop) {
+                delete obj[key];
+            }
+            else {
+                removePropertyRecursive(obj[key], prop);
+            }
+        });
+    }
+};
 describe("rebase changes & stashing api", function () {
     let testIModel;
     before(async () => {
@@ -428,7 +495,7 @@ describe("rebase changes & stashing api", function () {
         b1.saveChanges();
         await chai.expect(b1.txns.withIndirectTxnModeAsync(async () => {
             await b1.pushChanges({ description: "test" });
-        })).to.be.rejectedWith("Cannot push changeset while in an indirect change scope");
+        })).to.be.rejectedWith("Cannot pull and apply changeset while in an indirect change scope");
         await b1.pushChanges({ description: "test" });
     });
     it("should fail to saveFileProperty/deleteFileProperty in indirect scope", async () => {
@@ -669,11 +736,11 @@ describe("rebase changes & stashing api", function () {
         await b2.pullChanges();
         chai.expect(b2.changeset.index).to.equals(4);
         const elBefore = b2.elements.tryGetElementProps(e1);
-        chai.expect(elBefore.prop1).to.equals("2");
+        chai.expect(elBefore.prop1).to.equals("3");
         // restore stash should succeed as now it can obtain lock
         await StashManager.restore({ db: b2, stash: b2Stash1 });
         const elAfter = b2.elements.tryGetElementProps(e1);
-        chai.expect(elAfter.prop1).to.equals("1");
+        chai.expect(elAfter.prop1).to.equals("2");
         await b2.pushChanges({ description: `${e1} updated` });
     });
     it("schema change should not be stashed", async () => {
@@ -686,6 +753,10 @@ describe("rebase changes & stashing api", function () {
                 <ECProperty propertyName="prop1" typeName="string" />
                 <ECProperty propertyName="prop2" typeName="string" />
             </ECEntityClass>
+            <ECEntityClass typeName="A1Recipe2d">
+                <BaseClass>bis:TemplateRecipe2d</BaseClass>
+                <ECProperty propertyName="prop1" typeName="string" />
+            </ECEntityClass>
             <ECRelationshipClass typeName="A1OwnsA1" modifier="None" strength="embedding">
                 <BaseClass>bis:ElementOwnsChildElements</BaseClass>
                 <Source multiplicity="(0..1)" roleLabel="owns" polymorphic="true">
@@ -783,7 +854,7 @@ describe("rebase changes & stashing api", function () {
         const b1 = await testIModel.openBriefcase();
         const b2 = await testIModel.openBriefcase();
         const parentId = await testIModel.insertElement(b1);
-        const childId = await testIModel.insertElement2(b1, { parent: { id: parentId, relClassName: "TestDomain:A1OwnsA1" } });
+        const childId = await testIModel.insertElementEx(b1, { parent: { id: parentId, relClassName: "TestDomain:A1OwnsA1" } });
         b1.saveChanges("insert parent and child");
         await b1.pushChanges({ description: `inserted parent ${parentId} and child ${childId}` });
         await b2.pullChanges();
@@ -791,7 +862,7 @@ describe("rebase changes & stashing api", function () {
         await testIModel.deleteElement(b1, childId);
         b1.saveChanges("delete child");
         // no exclusive lock required on child1
-        const grandChildId = await testIModel.insertElement2(b2, { parent: { id: childId, relClassName: "TestDomain:A1OwnsA1" }, markAsIndirect: true });
+        const grandChildId = await testIModel.insertElementEx(b2, { parent: { id: childId, relClassName: "TestDomain:A1OwnsA1" }, markAsIndirect: true });
         b2.saveChanges("delete child and insert grandchild");
         await b1.pushChanges({ description: `deleted child ${childId}` });
         // should fail to pull and rebase changes.
@@ -919,7 +990,7 @@ describe("rebase changes & stashing api", function () {
             onRebase: {
                 beginCount: 0,
                 endCount: 0,
-                beginIds: [],
+                beginTxns: [],
             },
             onRebaseTxn: {
                 beginTxns: [],
@@ -928,44 +999,174 @@ describe("rebase changes & stashing api", function () {
             rebaseHandler: {
                 shouldReinstate: [],
                 recompute: [],
-            }
+            },
+            pullMerge: {
+                beginCount: 0,
+                endCount: 0,
+                beginChangeset: [],
+                endChangeset: [],
+            },
+            applyIncomingChanges: {
+                beginCount: 0,
+                endCount: 0,
+                beginChangesets: [],
+                endChangesets: [],
+            },
+            reverseLocalChanges: {
+                beginCount: 0,
+                endCount: 0,
+                txns: [],
+            },
+            downloadChangesets: {
+                beginCount: 0,
+                endCount: 0,
+            },
         };
         const resetEvent = () => {
             events.onRebase.beginCount = 0;
             events.onRebase.endCount = 0;
-            events.onRebase.beginIds = [];
+            events.onRebase.beginTxns = [];
             events.onRebaseTxn.beginTxns = [];
             events.onRebaseTxn.endTxns = [];
             events.rebaseHandler.shouldReinstate = [];
             events.rebaseHandler.recompute = [];
+            events.pullMerge.beginCount = 0;
+            events.pullMerge.endCount = 0;
+            events.pullMerge.beginChangeset = [];
+            events.pullMerge.endChangeset = [];
+            events.applyIncomingChanges.beginCount = 0;
+            events.applyIncomingChanges.endCount = 0;
+            events.applyIncomingChanges.beginChangesets = [];
+            events.applyIncomingChanges.endChangesets = [];
+            events.reverseLocalChanges.beginCount = 0;
+            events.reverseLocalChanges.endCount = 0;
+            events.reverseLocalChanges.txns = [];
+            events.downloadChangesets.beginCount = 0;
+            events.downloadChangesets.endCount = 0;
         };
-        b2.txns.onRebaseBegin.addListener((ids) => {
+        // onPullMergeXXXX
+        b2.txns.rebaser.onPullMergeBegin.addListener((changeset) => {
+            events.pullMerge.beginCount++;
+            events.pullMerge.beginChangeset.push(changeset);
+        });
+        b2.txns.rebaser.onPullMergeEnd.addListener((changeset) => {
+            events.pullMerge.endCount++;
+            events.pullMerge.endChangeset.push(changeset);
+        });
+        // onApplyIncomingChangesXXXX
+        b2.txns.rebaser.onApplyIncomingChangesBegin.addListener((changesets) => {
+            events.applyIncomingChanges.beginCount++;
+            events.applyIncomingChanges.beginChangesets.push(...changesets);
+        });
+        b2.txns.rebaser.onApplyIncomingChangesEnd.addListener((changesets) => {
+            events.applyIncomingChanges.endCount++;
+            events.applyIncomingChanges.endChangesets.push(...changesets);
+        });
+        // onReverseLocalChangesXXXX
+        b2.txns.rebaser.onReverseLocalChangesBegin.addListener(() => {
+            events.reverseLocalChanges.beginCount++;
+        });
+        b2.txns.rebaser.onReverseLocalChangesEnd.addListener((txns) => {
+            events.reverseLocalChanges.endCount++;
+            removePropertyRecursive(txns, "timestamp"); // it changes on each run, so remove it for comparison
+            events.reverseLocalChanges.txns.push(...txns);
+        });
+        // onDownloadChangesetsXXXX
+        b2.txns.rebaser.onDownloadChangesetsBegin.addListener(() => {
+            events.downloadChangesets.beginCount++;
+        });
+        b2.txns.rebaser.onDownloadChangesetsEnd.addListener(() => {
+            events.downloadChangesets.endCount++;
+        });
+        // onRebaseXXXX
+        b2.txns.rebaser.onRebaseBegin.addListener((txns) => {
             events.onRebase.beginCount++;
-            events.onRebase.beginIds.push(...ids);
+            removePropertyRecursive(txns, "timestamp"); // it changes on each run, so remove it for comparison
+            events.onRebase.beginTxns.push(...txns);
         });
-        b2.txns.onRebaseEnd.addListener(() => {
+        b2.txns.rebaser.onRebaseEnd.addListener(() => {
             events.onRebase.endCount++;
         });
-        b2.txns.onRebaseTxnBegin.addListener((txn) => {
+        // onRebaseTxnXXXX
+        b2.txns.rebaser.onRebaseTxnBegin.addListener((txn) => {
+            removePropertyRecursive(txn, "timestamp"); // it changes on each run, so remove it for comparison
             events.onRebaseTxn.beginTxns.push(txn);
         });
-        b2.txns.onRebaseTxnEnd.addListener((txn) => {
+        b2.txns.rebaser.onRebaseTxnEnd.addListener((txn) => {
+            removePropertyRecursive(txn, "timestamp"); // it changes on each run, so remove it for comparison
             events.onRebaseTxn.endTxns.push(txn);
         });
         b2.txns.rebaser.setCustomHandler({
             shouldReinstate: (_txn) => {
+                // shouldReinstate
+                removePropertyRecursive(_txn, "timestamp"); // it changes on each run, so remove it for comparison
                 events.rebaseHandler.shouldReinstate.push(_txn);
                 return true;
             },
             recompute: async (_txn) => {
+                // recompute
+                removePropertyRecursive(_txn, "timestamp"); // it changes on each run, so remove it for comparison
                 events.rebaseHandler.recompute.push(_txn);
             },
         });
         resetEvent();
         await b2.pullChanges();
+        // pullMerge events
+        chai.expect(events.pullMerge.beginCount).to.equal(1);
+        chai.expect(events.pullMerge.endCount).to.equal(1);
+        chai.expect((events.pullMerge.beginChangeset[0].index)).to.equal(3);
+        chai.expect((events.pullMerge.endChangeset[0].index)).to.equal(4);
+        // applyIncomingChanges events
+        chai.expect(events.applyIncomingChanges.beginCount).to.equal(1);
+        chai.expect(events.applyIncomingChanges.endCount).to.equal(1);
+        chai.expect(events.applyIncomingChanges.beginChangesets.map((cs) => cs.index)).to.deep.equal([4]);
+        chai.expect(events.applyIncomingChanges.endChangesets.map((cs) => cs.index)).to.deep.equal([4]);
+        // downloadChangesets events
+        chai.expect(events.downloadChangesets.beginCount).to.equal(1);
+        chai.expect(events.downloadChangesets.endCount).to.equal(1);
+        // reverseLocalChanges events
+        chai.expect(events.reverseLocalChanges.beginCount).to.equal(1);
+        chai.expect(events.reverseLocalChanges.endCount).to.equal(1);
+        chai.expect(events.reverseLocalChanges.txns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        // rebase events
         chai.expect(events.onRebase.beginCount).to.equal(1);
         chai.expect(events.onRebase.endCount).to.equal(1);
-        chai.expect(events.onRebase.beginIds).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
+        chai.expect(events.onRebase.beginTxns).to.deep.equal([
+            {
+                grouped: false,
+                id: "0x100000000",
+                nextId: "0x100000001",
+                props: {
+                    description: "first change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            },
+            {
+                grouped: false,
+                id: "0x100000001",
+                nextId: "0x100000002",
+                prevId: "0x100000000",
+                props: {
+                    description: "second change",
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            },
+            {
+                grouped: false,
+                id: "0x100000002",
+                prevId: "0x100000001",
+                props: {
+                    description: "third change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            }
+        ]);
         chai.expect(events.onRebaseTxn.beginTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
         chai.expect(events.onRebaseTxn.endTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
         chai.expect(events.rebaseHandler.shouldReinstate.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002"]);
@@ -976,17 +1177,243 @@ describe("rebase changes & stashing api", function () {
         await b1.pushChanges({ description: "update element 1 direct and 1 indirect" });
         await testIModel.insertElement(b2);
         await testIModel.insertElement(b2, true);
-        b2.saveChanges("forth change");
+        b2.saveChanges("fourth change");
         resetEvent();
         await b2.pullChanges();
         chai.expect(events.onRebase.beginCount).to.equal(1);
         chai.expect(events.onRebase.endCount).to.equal(1);
-        chai.expect(events.onRebase.beginIds).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
+        chai.expect(events.onRebase.beginTxns).to.deep.equal([
+            {
+                grouped: false,
+                id: "0x100000000",
+                nextId: "0x100000001",
+                props: {
+                    description: "first change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            },
+            {
+                grouped: false,
+                id: "0x100000001",
+                nextId: "0x100000002",
+                prevId: "0x100000000",
+                props: {
+                    description: "second change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            },
+            {
+                grouped: false,
+                id: "0x100000002",
+                nextId: "0x100000003",
+                prevId: "0x100000001",
+                props: {
+                    description: "third change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            },
+            {
+                grouped: false,
+                id: "0x100000003",
+                prevId: "0x100000002",
+                props: {
+                    description: "fourth change"
+                },
+                reversed: true,
+                sessionId: 1,
+                type: "Data"
+            }
+        ]);
         chai.expect(events.onRebaseTxn.beginTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
         chai.expect(events.onRebaseTxn.endTxns.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
         chai.expect(events.rebaseHandler.shouldReinstate.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
         chai.expect(events.rebaseHandler.recompute.map((txn) => txn.id)).to.deep.equal(["0x100000000", "0x100000001", "0x100000002", "0x100000003"]);
     });
+    it("onModelGeometryChanged() not fired during rebase/pullMerge with no local change", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const pushChangeFromB2 = async () => {
+            await b2.pullChanges();
+            await testIModel.insertElement(b2);
+            b2.saveChanges();
+            await b2.pushChanges({ description: "insert element on b2" });
+        };
+        const events = {
+            modelGeometryChanged: [],
+        };
+        const getGeometryGuidFromB1 = (modelId) => {
+            const modelProps = b1.models.tryGetModelProps(modelId);
+            return modelProps?.geometryGuid;
+        };
+        const clearEvents = () => {
+            events.modelGeometryChanged = [];
+        };
+        b1.txns.onModelGeometryChanged.addListener((changes) => {
+            events.modelGeometryChanged.push(changes);
+        });
+        clearEvents();
+        b1.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                return true;
+            },
+            recompute: async (_txn) => {
+            },
+        });
+        await pushChangeFromB2();
+        clearEvents();
+        const geomGuidBeforePull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidBeforePull).is.undefined;
+        await b1.pushChanges({ description: "push changes on b1" });
+        const geomGuidAfterPull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidAfterPull).is.undefined;
+        chai.expect(events.modelGeometryChanged.length).to.equal(0);
+    });
+    it("onModelGeometryChanged() fired during rebase with geometric local change", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const pushChangeFromB2 = async () => {
+            await b2.pullChanges();
+            await testIModel.insertElement(b2);
+            b2.saveChanges();
+            await b2.pushChanges({ description: "insert element on b2" });
+        };
+        const events = {
+            modelGeometryChanged: [],
+            onGeometryChanged: [],
+        };
+        const getGeometryGuidFromB1 = (modelId) => {
+            const modelProps = b1.models.tryGetModelProps(modelId);
+            return modelProps?.geometryGuid;
+        };
+        const clearEvents = () => {
+            events.modelGeometryChanged = [];
+            events.onGeometryChanged = [];
+        };
+        b1.txns.onModelGeometryChanged.addListener((changes) => {
+            events.modelGeometryChanged.push(changes);
+        });
+        b1.txns.onGeometryChanged.addListener((changes) => {
+            events.onGeometryChanged.push(changes);
+        });
+        clearEvents();
+        const e1 = await testIModel.insertElement(b1);
+        const e2 = await testIModel.insertElement(b1, true);
+        chai.expect(e1).to.exist;
+        chai.expect(e2).to.exist;
+        b1.saveChanges(`insert element ${e1} and ${e2}`);
+        chai.expect(events.modelGeometryChanged.length).to.equal(1);
+        chai.expect(events.modelGeometryChanged[0].length).to.equal(1);
+        chai.expect(events.modelGeometryChanged[0][0].id).to.equal("0x20000000001");
+        chai.assert(Guid.isGuid(events.modelGeometryChanged[0][0].guid));
+        b1.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                return true;
+            },
+            recompute: async (_txn) => {
+                await testIModel.updateElement(b1, e1);
+                await testIModel.updateElement(b1, e2);
+            },
+        });
+        await pushChangeFromB2();
+        clearEvents();
+        const geomGuidBeforePull = getGeometryGuidFromB1("0x20000000001");
+        await b1.pushChanges({ description: "push changes on b1" });
+        const geomGuidAfterPull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidBeforePull).to.not.equal(geomGuidAfterPull);
+        chai.expect(events.modelGeometryChanged.length).to.equal(4);
+    });
+    it("onModelGeometryChanged() fired during rebase with non-geometric local change", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const pushChangeFromB2 = async () => {
+            await b2.pullChanges();
+            await testIModel.insertElement(b2);
+            b2.saveChanges();
+            await b2.pushChanges({ description: "insert element on b2" });
+        };
+        const events = {
+            modelGeometryChanged: [],
+        };
+        const getGeometryGuidFromB1 = (modelId) => {
+            const modelProps = b1.models.tryGetModelProps(modelId);
+            return modelProps?.geometryGuid;
+        };
+        const clearEvents = () => {
+            events.modelGeometryChanged = [];
+        };
+        b1.txns.onModelGeometryChanged.addListener((changes) => {
+            events.modelGeometryChanged.push(changes);
+        });
+        clearEvents();
+        b1.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                return true;
+            },
+            recompute: async (_txn) => {
+            },
+        });
+        await pushChangeFromB2();
+        await testIModel.insertRecipe2d(b1);
+        b1.saveChanges();
+        clearEvents();
+        const geomGuidBeforePull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidBeforePull).is.undefined;
+        await b1.pushChanges({ description: "push changes on b1" });
+        const geomGuidAfterPull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidAfterPull).to.exist;
+        chai.expect(events.modelGeometryChanged.length).to.equal(1);
+    });
+    it("onModelGeometryChanged() fired during rebase with geometric local change", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const pushChangeFromB2 = async () => {
+            await b2.pullChanges();
+            await testIModel.insertRecipe2d(b2);
+            b2.saveChanges();
+            await b2.pushChanges({ description: "insert element on b2" });
+        };
+        const events = {
+            modelGeometryChanged: [],
+            onGeometryChanged: [],
+        };
+        const getGeometryGuidFromB1 = (modelId) => {
+            const modelProps = b1.models.tryGetModelProps(modelId);
+            return modelProps?.geometryGuid;
+        };
+        const clearEvents = () => {
+            events.modelGeometryChanged = [];
+            events.onGeometryChanged = [];
+        };
+        b1.txns.onModelGeometryChanged.addListener((changes) => {
+            events.modelGeometryChanged.push(changes);
+        });
+        b1.txns.onGeometryChanged.addListener((changes) => {
+            events.onGeometryChanged.push(changes);
+        });
+        clearEvents();
+        b1.txns.rebaser.setCustomHandler({
+            shouldReinstate: (_txn) => {
+                return true;
+            },
+            recompute: async (_txn) => {
+                await testIModel.insertElement(b1);
+            },
+        });
+        await pushChangeFromB2();
+        clearEvents();
+        const geomGuidBeforePull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidBeforePull).is.undefined;
+        await b1.pushChanges({ description: "push changes on b1" });
+        const geomGuidAfterPull = getGeometryGuidFromB1("0x20000000001");
+        chai.expect(geomGuidAfterPull).is.undefined;
+        chai.expect(events.modelGeometryChanged.length).to.equal(0);
+    });
     it("rebase multi txn", async () => {
         const b1 = await testIModel.openBriefcase();
         const b2 = await testIModel.openBriefcase();
@@ -1349,5 +1776,102 @@ describe("rebase changes & stashing api", function () {
         chai.expect(b1.elements.tryGetElementProps(e4)).to.exist;
         chai.expect(b1.elements.tryGetElementProps(e7)).to.exist;
     });
+    it("changeset DDL error are ignored and ec_* tables are used to reconstruct the sqlite tables", async () => {
+        const b1 = await testIModel.openBriefcase();
+        const b2 = await testIModel.openBriefcase();
+        const iModelId = testIModel.iModelId;
+        const targetDir = path.join(KnownTestLocations.outputDir, iModelId, "changesets");
+        let ver = 0;
+        let props = 0;
+        const tblGeom2d = "bis_GeometricElement2d";
+        const geom2dBaseColumnList = [
+            "ElementId",
+            "ECClassId",
+            "CategoryId",
+            "Origin_X",
+            "Origin_Y",
+            "Rotation",
+            "BBoxLow_X",
+            "BBoxLow_Y",
+            "BBoxHigh_X",
+            "BBoxHigh_Y",
+            "GeometryStream",
+            "TypeDefinitionId",
+            "TypeDefinitionRelECClassId",
+            "js1",
+            "js2",
+        ];
+        const generateSchema = (noOfNewPropsToAdd) => {
+            props += noOfNewPropsToAdd;
+            return `<?xml version="1.0" encoding="UTF-8"?>
+        <ECSchema schemaName="TestDomain1" alias="ts1" version="01.00.${ver++}" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.2">
+            <ECSchemaReference name="BisCore" version="01.00.00" alias="bis"/>
+            <ECEntityClass typeName="test">
+                <BaseClass>bis:GraphicalElement2d</BaseClass>
+                <ECProperty propertyName="prop1" typeName="string" />
+                ${Array.from({ length: props - 1 }, (_, i) => `<ECProperty propertyName="prop${i + 2}" typeName="string" />`).join("\n                ")}
+            </ECEntityClass>
+        </ECSchema>`;
+        };
+        const getColumnNames = (b, tableName) => {
+            return b.withSqliteStatement(`PRAGMA table_info(${tableName})`, (stmt) => {
+                const columnNames = [];
+                while (stmt.step() === DbResult.BE_SQLITE_ROW) {
+                    columnNames.push(stmt.getValue(1).getString());
+                }
+                return columnNames;
+            });
+        };
+        const withLatestChangeset = async (cb) => {
+            const csInfo = await HubMock.getLatestChangeset({ iModelId });
+            const info = await HubMock.downloadChangeset({
+                iModelId,
+                changeset: { id: csInfo.id },
+                targetDir,
+            });
+            const reader = SqliteChangesetReader.openFile({ db: b1, fileName: info.pathname });
+            try {
+                await cb(reader);
+            }
+            finally {
+                reader.close();
+            }
+        };
+        // Verify initial columns
+        chai.expect(getColumnNames(b1, tblGeom2d)).deep.equals(geom2dBaseColumnList);
+        chai.expect(getColumnNames(b2, tblGeom2d)).deep.equals(geom2dBaseColumnList);
+        // Import schema that add 5 new properties that should add 3 new shared columns
+        await b1.importSchemaStrings([generateSchema(5)]);
+        await b1.pushChanges({ description: `imported schema version 1.0.${ver - 1}` });
+        // Verify columns after schema import
+        chai.expect(getColumnNames(b1, tblGeom2d)).deep.equals([...geom2dBaseColumnList, "js3", "js4", "js5"]);
+        //verify changeset has schema changes
+        await withLatestChangeset(async (reader) => {
+            const schemaChanges = reader.getDdlChanges()?.split(";");
+            chai.expect(schemaChanges).to.include("ALTER TABLE [bis_GeometricElement2d] ADD COLUMN [js3] BLOB");
+            chai.expect(schemaChanges).to.include("ALTER TABLE [bis_GeometricElement2d] ADD COLUMN [js4] BLOB");
+            chai.expect(schemaChanges).to.include("ALTER TABLE [bis_GeometricElement2d] ADD COLUMN [js5] BLOB");
+        });
+        await b2.pullChanges();
+        chai.expect(getColumnNames(b2, "bis_GeometricElement2d")).deep.equals([...geom2dBaseColumnList, "js3", "js4", "js5"]);
+        // Import schema that add 5 new properties that should add 3 new shared columns
+        await b1.importSchemaStrings([generateSchema(1)]);
+        await b1.pushChanges({ description: `imported schema version 1.0.${ver - 1}` });
+        // Verify columns after schema import
+        chai.expect(getColumnNames(b1, tblGeom2d)).deep.equals([...geom2dBaseColumnList, "js3", "js4", "js5", "js6"]);
+        //verify changeset has schema changes
+        await withLatestChangeset(async (reader) => {
+            const schemaChanges = reader.getDdlChanges()?.split(";");
+            chai.expect(schemaChanges).to.include("ALTER TABLE [bis_GeometricElement2d] ADD COLUMN [js6] BLOB");
+        });
+        // delete the table so DDL apply should fail
+        b2[_nativeDb].executeSql(`DROP TABLE ${tblGeom2d}`);
+        // this would fail before this PR but should succeed as DDL error are ignored and table reconstruction is attempted using ec_* tables
+        await b2.pullChanges();
+        // Verify columns after schema import
+        chai.expect(getColumnNames(b2, tblGeom2d)).deep.equals([...geom2dBaseColumnList, "js3", "js4", "js5", "js6"]);
+        b1.close();
+        b2.close();
+    });
 });
 //# sourceMappingURL=Rebase.test.js.map