@itwin/core-backend 5.9.0-dev.4 → 5.9.0-dev.5

package/lib/esm/test/imodel/IModel.test.js

@@ -59,6 +59,7 @@ import * as path from "path";
 import * as semver from "semver";
 import * as sinon from "sinon";
 import { DbResult, Guid, Id64, IModelStatus, Logger, OpenMode, ProcessDetector } from "@itwin/core-bentley";
+import { EditTxn, withEditTxn } from "../../EditTxn";
 import { BisCodeSpec, BriefcaseIdValue, Code, CodeScopeSpec, CodeSpec, ColorByName, ColorDef, DisplayStyleSettings, EcefLocation, FontMap, FontType, GeoCoordStatus, GeographicCRS, GeometryParams, GeometryStreamBuilder, ImageSourceFormat, IModel, IModelError, QueryBinder, RelatedElement, RenderMode, SchemaState, SubCategoryAppearance, TextureMapping, TextureMapUnits, ViewFlags, } from "@itwin/core-common";
 import { Geometry, LineString3d, Loop, Matrix4d, Point3d, PolyfaceBuilder, Range3d, StrokeOptions, Transform, YawPitchRollAngles, } from "@itwin/core-geometry";
 import { V2CheckpointManager } from "../../CheckpointManager";
@@ -92,8 +93,7 @@ async function generateTestSnapshot(targetFileName, seedAssetName) {
     const snapshotFile = IModelTestUtils.prepareOutputFile("IModel", targetFileName);
     const imodel = IModelTestUtils.createSnapshotFromSeed(snapshotFile, seedFile);
     const schemaPathname = path.join(KnownTestLocations.assetsDir, "TestBim.ecschema.xml");
-    await imodel.importSchemas([schemaPathname]); // will throw an exception if import fails
-    imodel.saveChanges();
+    await imodel.importSchemas([schemaPathname]);
     return imodel;
 }
 describe("iModel", () => {
@@ -272,30 +272,33 @@ describe("iModel", () => {
         assert.notEqual(a2, el3);
         assert.equal(a2.id, el3.id);
         roundtripThroughJson(el3);
+        const txn = new EditTxn(imodel2, "code scope mutation test");
+        txn.start();
         const newEl = el3.toJSON();
         newEl.federationGuid = undefined;
         newEl.code = { scope: "bad scope", spec: "0x10", value: "new code" };
-        expect(() => imodel2.elements.insertElement(newEl)).throws("invalid code scope").to.have.property("metadata");
+        expect(() => txn.insertElement(newEl)).throws("invalid code scope").to.have.property("metadata");
         newEl.code.scope = "0x34322"; // valid id, but element doesn't exist
-        expect(() => imodel2.elements.insertElement(newEl)).throws("invalid code scope").to.have.property("metadata");
+        expect(() => txn.insertElement(newEl)).throws("invalid code scope").to.have.property("metadata");
         newEl.code.scope = el3.federationGuid;
-        const newId = imodel2.elements.insertElement(newEl); // code scope from FederationGuid should get converted to ElementId
+        const newId = txn.insertElement(newEl); // code scope from FederationGuid should get converted to ElementId
         const a4 = imodel2.elements.getElementProps(newId);
         expect(a4.code.scope).equal(el3.id);
         a4.code.scope = "0x13343";
-        expect(() => imodel2.elements.updateElement(a4)).throws("invalid code scope").to.have.property("metadata");
+        expect(() => txn.updateElement(a4)).throws("invalid code scope").to.have.property("metadata");
         a4.code.scope = "0x1";
-        imodel2.elements.updateElement(a4); // should change the code scope to new element
+        txn.updateElement(a4); // should change the code scope to new element
         let a5 = imodel2.elements.getElementProps(newId);
         expect(a5.code.scope).equal("0x1");
         // only pass minimum, but expect model and classFullName to be added.
         const newProps = { id: a4.id, code: a4.code, classFullName: undefined, model: undefined };
         newProps.code.scope = el3.federationGuid; // should convert FederationGuid to ElementId
-        imodel2.elements.updateElement(newProps);
+        txn.updateElement(newProps);
         expect(newProps.classFullName).eq(a4.classFullName);
         expect(newProps.model).eq(a4.model);
         a5 = imodel2.elements.getElementProps(newId);
         expect(a5.code.scope).equal(el3.id);
+        txn.end();
     });
     it("should optionally detect class mismatches", () => {
         // tryGetElement
@@ -342,20 +345,22 @@ describe("iModel", () => {
         const seedElement = imodel2.elements.getElement("0x1d");
         assert.exists(seedElement);
         assert.isTrue(seedElement.federationGuid === "18eb4650-b074-414f-b961-d9cfaa6c8746");
-        for (let i = 0; i < 25; i++) {
-            const elementProps = {
-                classFullName: "Generic:PhysicalObject",
-                model: seedElement.model,
-                category: seedElement.category,
-                code: Code.createEmpty(),
-                federationGuid: Guid.createValue(),
-                userLabel: `UserLabel-${i}`,
-            };
-            const element = imodel2.elements.createElement(elementProps);
-            element.setUserProperties("performanceTest", { s: `String-${i}`, n: i });
-            const elementId = imodel2.elements.insertElement(element.toJSON());
-            assert.isTrue(Id64.isValidId64(elementId));
-        }
+        withEditTxn(imodel2, (txn) => {
+            for (let i = 0; i < 25; i++) {
+                const elementProps = {
+                    classFullName: "Generic:PhysicalObject",
+                    model: seedElement.model,
+                    category: seedElement.category,
+                    code: Code.createEmpty(),
+                    federationGuid: Guid.createValue(),
+                    userLabel: `UserLabel-${i}`,
+                };
+                const element = imodel2.elements.createElement(elementProps);
+                element.setUserProperties("performanceTest", { s: `String-${i}`, n: i });
+                const elementId = txn.insertElement(element.toJSON());
+                assert.isTrue(Id64.isValidId64(elementId));
+            }
+        });
     });
     it("should insert a RenderMaterial", () => {
         const model = imodel2.models.getModel(IModel.dictionaryId);
@@ -397,7 +402,7 @@ describe("iModel", () => {
             reflectColor,
             patternMap: textureMapProps,
         };
-        const renderMaterialId = RenderMaterialElement.insert(imodel2, IModel.dictionaryId, testMaterialName, renderMaterialParams);
+        const renderMaterialId = withEditTxn(imodel2, (txn) => RenderMaterialElement.insert(txn, IModel.dictionaryId, testMaterialName, renderMaterialParams));
         const renderMaterial = imodel2.elements.getElement(renderMaterialId);
         assert((renderMaterial instanceof RenderMaterialElement) === true, "did not retrieve an instance of RenderMaterial");
         expect(renderMaterial.paletteName).to.equal(testPaletteName);
@@ -435,9 +440,11 @@ describe("iModel", () => {
         const testTextureName = "fake texture name";
         const testTextureFormat = ImageSourceFormat.Png;
         const testTextureDescription = "empty description";
-        const texId = Texture.insertTexture(imodel5, IModel.dictionaryId, testTextureName, testTextureFormat, samplePngTexture.base64, testTextureDescription);
+        const txn = new EditTxn(imodel5, "apply material to new element");
+        txn.start();
+        const texId = Texture.insertTexture(txn, IModel.dictionaryId, testTextureName, testTextureFormat, samplePngTexture.base64, testTextureDescription);
         /* eslint-disable @typescript-eslint/naming-convention */
-        const matId = RenderMaterialElement.insert(imodel5, IModel.dictionaryId, "test material name", {
+        const matId = RenderMaterialElement.insert(txn, IModel.dictionaryId, "test material name", {
             paletteName: "TestPaletteName",
             patternMap: {
                 TextureId: texId,
@@ -474,8 +481,8 @@ describe("iModel", () => {
                 Point3d.create(0, 0, 0),
             ]));
         }
-        const modelId = PhysicalModel.insert(imodel5, IModelDb.rootSubjectId, "test_render_material_model_name");
-        const categoryId = SpatialCategory.insert(imodel5, IModel.dictionaryId, "GeoJSON Feature", { color: ColorDef.white.toJSON() });
+        const modelId = PhysicalModel.insert(txn, IModelDb.rootSubjectId, "test_render_material_model_name");
+        const categoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "GeoJSON Feature", { color: ColorDef.white.toJSON() });
         /** generate a geometry stream containing the polyface */
         const gsBuilder = new GeometryStreamBuilder();
         const params = new GeometryParams(categoryId);
@@ -492,8 +499,8 @@ describe("iModel", () => {
             category: categoryId,
             geom: geometry,
         };
-        imodel5.elements.insertElement(props);
-        imodel5.saveChanges();
+        txn.insertElement(props);
+        txn.end();
     });
     it("should insert a DisplayStyle", () => {
         const model = imodel2.models.getModel(IModel.dictionaryId);
@@ -513,7 +520,9 @@ describe("iModel", () => {
                 styles: settings,
             },
         };
-        const styleId = imodel2.elements.insertElement(props);
+        const txn = new EditTxn(imodel2, "insert and update DisplayStyle");
+        txn.start();
+        const styleId = txn.insertElement(props);
         let style = imodel2.elements.getElement(styleId);
         expect(style instanceof DisplayStyle3d).to.be.true;
         expect(style.code.spec).equal(imodel2.codeSpecs.getByName(BisCodeSpec.displayStyle).id);
@@ -524,7 +533,8 @@ describe("iModel", () => {
         style.settings.backgroundColor = ColorDef.red;
         style.settings.monochromeColor = ColorDef.green;
         expect(style.jsonProperties.styles.viewflags.renderMode).to.equal(RenderMode.SmoothShade);
-        imodel2.elements.updateElement(style.toJSON());
+        txn.updateElement(style.toJSON());
+        txn.end();
         style = imodel2.elements.getElement(styleId);
         expect(style instanceof DisplayStyle3d).to.be.true;
         expect(style.settings.viewFlags.renderMode).to.equal(RenderMode.SmoothShade);
@@ -565,25 +575,27 @@ describe("iModel", () => {
             [{ backgroundColor: ColorDef.from(1, 2, 3, 4).tbgr }, defaultViewFlags, false],
         ];
         let suffix = 123;
-        for (const test of testCases) {
-            const expected = test[0] ?? {};
-            const styleId = DisplayStyle3d.insert(imodel2, IModel.dictionaryId, `TestStyle${suffix++}`, expected);
-            const style = imodel2.elements.getElement(styleId).toJSON();
-            expect(style.jsonProperties.styles).not.to.be.undefined;
-            expect(style.jsonProperties).not.to.be.undefined;
-            expect(style.jsonProperties.styles).not.to.be.undefined;
-            const actual = style.jsonProperties.styles;
-            expect(actual.viewflags).not.to.be.undefined;
-            const expectedVf = ViewFlags.fromJSON(test[1]);
-            const actualVf = ViewFlags.fromJSON(actual.viewflags);
-            expect(actualVf.toJSON()).to.deep.equal(expectedVf.toJSON());
-            const expectedBGColor = expected.backgroundColor instanceof ColorDef ? expected.backgroundColor.toJSON() : expected.backgroundColor;
-            expect(actual.backgroundColor).to.equal(expectedBGColor);
-            // DisplayStyleSettings constructor always initializes json.mapImagery.
-            expect(actual.mapImagery).to.deep.equal(expected.mapImagery ?? defaultMapImagery);
-            expect(actual.excludedElements).to.deep.equal(expected.excludedElements);
-            expect(actual.timePoint).to.deep.equal(expected.timePoint);
-        }
+        withEditTxn(imodel2, (txn) => {
+            for (const test of testCases) {
+                const expected = test[0] ?? {};
+                const styleId = DisplayStyle3d.insert(txn, IModel.dictionaryId, `TestStyle${suffix++}`, expected);
+                const style = imodel2.elements.getElement(styleId).toJSON();
+                expect(style.jsonProperties.styles).not.to.be.undefined;
+                expect(style.jsonProperties).not.to.be.undefined;
+                expect(style.jsonProperties.styles).not.to.be.undefined;
+                const actual = style.jsonProperties.styles;
+                expect(actual.viewflags).not.to.be.undefined;
+                const expectedVf = ViewFlags.fromJSON(test[1]);
+                const actualVf = ViewFlags.fromJSON(actual.viewflags);
+                expect(actualVf.toJSON()).to.deep.equal(expectedVf.toJSON());
+                const expectedBGColor = expected.backgroundColor instanceof ColorDef ? expected.backgroundColor.toJSON() : expected.backgroundColor;
+                expect(actual.backgroundColor).to.equal(expectedBGColor);
+                // DisplayStyleSettings constructor always initializes json.mapImagery.
+                expect(actual.mapImagery).to.deep.equal(expected.mapImagery ?? defaultMapImagery);
+                expect(actual.excludedElements).to.deep.equal(expected.excludedElements);
+                expect(actual.timePoint).to.deep.equal(expected.timePoint);
+            }
+        });
     });
     it("should have a valid root subject element", () => {
         const rootSubject = imodel1.elements.getRootSubject();
@@ -906,7 +918,9 @@ describe("iModel", () => {
         newTestElem.asAny.arrayOfStructs = arrayOfStructs;
         newTestElem.asAny.dtUtc = new Date("2015-03-25");
         newTestElem.asAny.p3d = new Point3d(1, 2, 3);
-        const newTestElemId = imodel4.elements.insertElement(newTestElem.toJSON());
+        const txn = new EditTxn(imodel4, "insert and update auto-handled properties");
+        txn.start();
+        const newTestElemId = txn.insertElement(newTestElem.toJSON());
         assert.isTrue(Id64.isValidId64(newTestElemId), "insert worked");
         const newTestElemFetched = imodel4.elements.getElement(newTestElemId);
         assert.isDefined(newTestElemFetched);
@@ -925,7 +939,7 @@ describe("iModel", () => {
         const editElem = newTestElemFetched;
         editElem.asAny.location = loc2;
         try {
-            imodel4.elements.updateElement(editElem.toJSON());
+            txn.updateElement(editElem.toJSON());
         }
         catch {
             assert.fail("Element.update failed");
@@ -937,46 +951,50 @@ describe("iModel", () => {
         // Make array shorter
         assert.equal(afterUpdateElemFetched.asAny.arrayOfInt.length, 300);
         afterUpdateElemFetched.asAny.arrayOfInt = [99, 3];
-        imodel4.elements.updateElement(afterUpdateElemFetched.toJSON());
+        txn.updateElement(afterUpdateElemFetched.toJSON());
         const afterShortenArray = imodel4.elements.getElement(afterUpdateElemFetched.id);
         assert.equal(afterUpdateElemFetched.asAny.arrayOfInt.length, 2);
         assert.deepEqual(afterShortenArray.asAny.arrayOfInt, [99, 3]);
         // Make array longer
         afterShortenArray.asAny.arrayOfInt = [1, 2, 3];
-        imodel4.elements.updateElement(afterShortenArray.toJSON());
+        txn.updateElement(afterShortenArray.toJSON());
         const afterLengthenArray = imodel4.elements.getElement(afterShortenArray.id);
         assert.equal(afterLengthenArray.asAny.arrayOfInt.length, 3);
         assert.deepEqual(afterLengthenArray.asAny.arrayOfInt, [1, 2, 3]);
         // ------------ delete -----------------
         const elid = afterUpdateElemFetched.id;
-        imodel4.elements.deleteElement(elid);
+        txn.deleteElement(elid);
         assert.throws(() => imodel4.elements.getElement(elid), IModelError);
+        txn.end();
     });
     it("should handle parent and child deletion properly", () => {
-        const categoryId = SpatialCategory.insert(imodel4, IModel.dictionaryId, "MyTestCategory", new SubCategoryAppearance());
+        const txn = new EditTxn(imodel4, "handle parent and child deletion");
+        txn.start();
+        const categoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "MyTestCategory", new SubCategoryAppearance());
         const category = imodel4.elements.getElement(categoryId);
         const subCategory = imodel4.elements.getElement(category.myDefaultSubCategoryId());
-        expect(() => imodel4.elements.deleteElement(categoryId)).throws("error deleting element").to.have.property("metadata");
+        expect(() => txn.deleteElement(categoryId)).throws("error deleting element").to.have.property("metadata");
         assert.exists(imodel4.elements.getElement(categoryId), "Category deletes should be blocked in native code");
         assert.exists(imodel4.elements.getElement(subCategory.id), "Children should not be deleted if parent delete is blocked");
-        const modelId = PhysicalModel.insert(imodel4, IModel.rootSubjectId, "MyTestPhysicalModel");
+        const modelId = PhysicalModel.insert(txn, IModel.rootSubjectId, "MyTestPhysicalModel");
         const elementProps = {
             classFullName: PhysicalObject.classFullName,
             model: modelId,
             category: categoryId,
             code: Code.createEmpty(),
         };
-        const parentId = imodel4.elements.insertElement(elementProps);
+        const parentId = txn.insertElement(elementProps);
         elementProps.parent = new ElementOwnsChildElements(parentId);
-        const childId1 = imodel4.elements.insertElement(elementProps);
-        const childId2 = imodel4.elements.insertElement(elementProps);
+        const childId1 = txn.insertElement(elementProps);
+        const childId2 = txn.insertElement(elementProps);
         assert.exists(imodel4.elements.getElement(parentId));
         assert.exists(imodel4.elements.getElement(childId1));
         assert.exists(imodel4.elements.getElement(childId2));
-        imodel4.elements.deleteElement(parentId);
+        txn.deleteElement(parentId);
         assert.throws(() => imodel4.elements.getElement(parentId), IModelError);
         assert.throws(() => imodel4.elements.getElement(childId1), IModelError);
         assert.throws(() => imodel4.elements.getElement(childId2), IModelError);
+        txn.end();
     });
     function checkElementMetaData(entityClass) {
         assert.isNotNull(entityClass);
@@ -1002,29 +1020,31 @@ describe("iModel", () => {
     it("should get metadata for a relationship", async () => {
         const imodelPath = IModelTestUtils.prepareOutputFile("IModel", "relationshipMetadata.bim");
         const imodel = SnapshotDb.createEmpty(imodelPath, { rootSubject: { name: "relationshipMetadata" } });
-        const partitionId = imodel.elements.insertElement({
-            classFullName: "BisCore:PhysicalPartition",
-            model: IModel.repositoryModelId,
-            parent: {
-                relClassName: "BisCore:SubjectOwnsPartitionElements",
-                id: IModel.rootSubjectId,
-            },
-            code: new Code({
-                spec: imodel.codeSpecs.getByName(BisCodeSpec.informationPartitionElement).id,
-                scope: IModel.rootSubjectId,
-                value: "physical model",
-            }),
-        });
-        for await (const row of imodel.createQueryReader(`SELECT * FROM bis.Element LIMIT ${1}`)) {
-            const relId = imodel.relationships.insertInstance({
-                classFullName: "BisCore:ElementHasLinks",
-                sourceId: partitionId,
-                targetId: row.ECInstanceId,
+        await withEditTxn(imodel, async (txn) => {
+            const partitionId = txn.insertElement({
+                classFullName: "BisCore:PhysicalPartition",
+                model: IModel.repositoryModelId,
+                parent: {
+                    relClassName: "BisCore:SubjectOwnsPartitionElements",
+                    id: IModel.rootSubjectId,
+                },
+                code: new Code({
+                    spec: imodel.codeSpecs.getByName(BisCodeSpec.informationPartitionElement).id,
+                    scope: IModel.rootSubjectId,
+                    value: "physical model",
+                }),
             });
-            const relationship = imodel.relationships.getInstance("BisCore:ElementHasLinks", relId);
-            const metadata = await relationship.getMetaData();
-            assert.isDefined(metadata, "metadata should be defined");
-        }
+            for await (const row of imodel.createQueryReader(`SELECT * FROM bis.Element LIMIT ${1}`)) {
+                const relId = txn.insertRelationship({
+                    classFullName: "BisCore:ElementHasLinks",
+                    sourceId: partitionId,
+                    targetId: row.ECInstanceId,
+                });
+                const relationship = imodel.relationships.getInstance("BisCore:ElementHasLinks", relId);
+                const metadata = await relationship.getMetaData();
+                assert.isDefined(metadata, "metadata should be defined");
+            }
+        });
         imodel.close();
     });
     it("should get metadata for class", () => {
@@ -1036,31 +1056,33 @@ describe("iModel", () => {
     it("should iterate through metadata for a relationship", async () => {
         const imodelPath = IModelTestUtils.prepareOutputFile("IModel", "relationshipMetadata.bim");
         const imodel = SnapshotDb.createEmpty(imodelPath, { rootSubject: { name: "relationshipMetadata" } });
-        const partitionId = imodel.elements.insertElement({
-            classFullName: "BisCore:PhysicalPartition",
-            model: IModel.repositoryModelId,
-            parent: {
-                relClassName: "BisCore:SubjectOwnsPartitionElements",
-                id: IModel.rootSubjectId,
-            },
-            code: new Code({
-                spec: imodel.codeSpecs.getByName(BisCodeSpec.informationPartitionElement).id,
-                scope: IModel.rootSubjectId,
-                value: "physical model",
-            }),
-        });
-        for await (const row of imodel.createQueryReader(`SELECT * FROM bis.Element LIMIT ${1}`)) {
-            const relId = imodel.relationships.insertInstance({
-                classFullName: "BisCore:ElementHasLinks",
-                sourceId: partitionId,
-                targetId: row.ECInstanceId,
-            });
-            const relationship = imodel.relationships.getInstance("BisCore:ElementHasLinks", relId);
-            relationship.forEach((propName, propMeta) => {
-                assert.isDefined(propName, "Property name should be defined");
-                assert.isDefined(propMeta, "Property metadata should be defined");
+        await withEditTxn(imodel, async (txn) => {
+            const partitionId = txn.insertElement({
+                classFullName: "BisCore:PhysicalPartition",
+                model: IModel.repositoryModelId,
+                parent: {
+                    relClassName: "BisCore:SubjectOwnsPartitionElements",
+                    id: IModel.rootSubjectId,
+                },
+                code: new Code({
+                    spec: imodel.codeSpecs.getByName(BisCodeSpec.informationPartitionElement).id,
+                    scope: IModel.rootSubjectId,
+                    value: "physical model",
+                }),
             });
-        }
+            for await (const row of imodel.createQueryReader(`SELECT * FROM bis.Element LIMIT ${1}`)) {
+                const relId = txn.insertRelationship({
+                    classFullName: "BisCore:ElementHasLinks",
+                    sourceId: partitionId,
+                    targetId: row.ECInstanceId,
+                });
+                const relationship = imodel.relationships.getInstance("BisCore:ElementHasLinks", relId);
+                relationship.forEach((propName, propMeta) => {
+                    assert.isDefined(propName, "Property name should be defined");
+                    assert.isDefined(propMeta, "Property metadata should be defined");
+                });
+            }
+        });
         imodel.close();
     });
     it("update the project extents", async () => {
@@ -1072,7 +1094,7 @@ describe("iModel", () => {
         newExtents.high.x += 1087;
         newExtents.high.y += 19;
         newExtents.high.z += .001;
-        imodel1.updateProjectExtents(newExtents);
+        await withEditTxn(imodel1, async (txn) => txn.updateProjectExtents(newExtents));
         const updatedProps = imodel1[_nativeDb].getIModelProps();
         assert.isTrue(updatedProps.hasOwnProperty("projectExtents"), "Returned property JSON object has project extents");
         const updatedExtents = Range3d.fromJSON(updatedProps.projectExtents);
@@ -1264,26 +1286,28 @@ describe("iModel", () => {
     });
     it("should create and insert CodeSpecs", () => {
         const testImodel = imodel2;
+        const txn = new EditTxn(testImodel, "create and insert CodeSpecs");
+        txn.start();
         const codeSpec = CodeSpec.create(testImodel, "CodeSpec1", CodeScopeSpec.Type.Model);
-        const codeSpecId = testImodel.codeSpecs.insert(codeSpec); // throws in case of error
+        const codeSpecId = testImodel.codeSpecs.insert(txn, codeSpec); // throws in case of error
         assert.deepEqual(codeSpecId, codeSpec.id);
         assert.equal(codeSpec.scopeType, CodeScopeSpec.Type.Model);
         assert.equal(codeSpec.scopeReq, CodeScopeSpec.ScopeRequirement.ElementId);
         // Should not be able to insert a duplicate.
         const codeSpecDup = CodeSpec.create(testImodel, "CodeSpec1", CodeScopeSpec.Type.Model);
-        assert.throws(() => testImodel.codeSpecs.insert(codeSpecDup), "CodeSpec already exists");
+        assert.throws(() => testImodel.codeSpecs.insert(txn, codeSpecDup), "CodeSpec already exists");
         // We should be able to insert another CodeSpec with a different name.
         const codeSpec2 = CodeSpec.create(testImodel, "CodeSpec2", CodeScopeSpec.Type.Model, CodeScopeSpec.ScopeRequirement.FederationGuid);
-        const codeSpec2Id = testImodel.codeSpecs.insert(codeSpec2); // throws in case of error
+        const codeSpec2Id = testImodel.codeSpecs.insert(txn, codeSpec2); // throws in case of error
         assert.deepEqual(codeSpec2Id, codeSpec2.id);
         assert.notDeepEqual(codeSpec2Id, codeSpecId);
         // make sure CodeScopeSpec.Type.Repository works
         const codeSpec3 = CodeSpec.create(testImodel, "CodeSpec3", CodeScopeSpec.Type.Repository, CodeScopeSpec.ScopeRequirement.FederationGuid);
-        const codeSpec3Id = testImodel.codeSpecs.insert(codeSpec3); // throws in case of error
+        const codeSpec3Id = testImodel.codeSpecs.insert(txn, codeSpec3); // throws in case of error
         assert.notDeepEqual(codeSpec2Id, codeSpec3Id);
         const codeSpec4 = testImodel.codeSpecs.getById(codeSpec3Id);
         codeSpec4.name = "CodeSpec4";
-        const codeSpec4Id = testImodel.codeSpecs.insert(codeSpec4); // throws in case of error
+        const codeSpec4Id = testImodel.codeSpecs.insert(txn, codeSpec4); // throws in case of error
         assert.notDeepEqual(codeSpec3Id, codeSpec4Id);
         assert.equal(codeSpec4.scopeType, CodeScopeSpec.Type.Repository);
         assert.equal(codeSpec4.scopeReq, CodeScopeSpec.ScopeRequirement.FederationGuid);
@@ -1299,6 +1323,7 @@ describe("iModel", () => {
         assert.isTrue(testImodel.codeSpecs.hasId(codeSpec3.id));
         assert.isTrue(testImodel.codeSpecs.hasId(codeSpec4.id));
         assert.isFalse(testImodel.codeSpecs.hasId(Id64.invalid));
+        txn.end();
     });
     it("validate CodeSpec properties", async () => {
         const iModelFileName = IModelTestUtils.prepareOutputFile("IModel", "ReadWriteCodeSpec.bim");
@@ -1307,13 +1332,12 @@ describe("iModel", () => {
         if (true) {
             const iModelDb = IModelTestUtils.createSnapshotFromSeed(iModelFileName, IModelTestUtils.resolveAssetFile("CompatibilityTestSeed.bim"));
             const codeSpec = CodeSpec.create(iModelDb, codeSpecName, CodeScopeSpec.Type.Model, CodeScopeSpec.ScopeRequirement.FederationGuid);
-            const codeSpecId = iModelDb.codeSpecs.insert(codeSpec);
+            const codeSpecId = withEditTxn(iModelDb, (txn) => iModelDb.codeSpecs.insert(txn, codeSpec));
             assert.isTrue(Id64.isValidId64(codeSpec.id));
             assert.equal(codeSpec.id, codeSpecId);
             assert.equal(codeSpec.name, codeSpecName);
             assert.equal(codeSpec.scopeType, CodeScopeSpec.Type.Model);
             assert.equal(codeSpec.scopeReq, CodeScopeSpec.ScopeRequirement.FederationGuid);
-            iModelDb.saveChanges();
             iModelDb.close();
         }
         // Reopen iModel (ensure CodeSpec cache is cleared) and reconfirm CodeSpec properties
@@ -1344,7 +1368,9 @@ describe("iModel", () => {
     });
     it("should do CRUD on models", () => {
         const testImodel = imodel2;
-        const [modeledElementId, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(testImodel, Code.createEmpty(), true);
+        const txn = new EditTxn(testImodel, "CRUD on models");
+        txn.start();
+        const [modeledElementId, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txn, Code.createEmpty(), true);
         const newModelPersist = testImodel.models.getModel(newModelId);
         // Check that it has the properties that we set.
         assert.equal(newModelPersist.classFullName, PhysicalModel.classFullName);
@@ -1352,15 +1378,15 @@ describe("iModel", () => {
         assert.deepEqual(newModelPersist.modeledElement.id, modeledElementId);
         // Update the model
         newModelPersist.isPrivate = false;
-        testImodel.models.updateModel(newModelPersist.toJSON());
+        txn.updateModel(newModelPersist.toJSON());
         //  ... and check that it updated the model in the db
         const newModelPersist2 = testImodel.models.getModel(newModelId);
         assert.isFalse(newModelPersist2.isPrivate);
         // Delete the model
-        testImodel.models.deleteModel(newModelId);
+        txn.deleteModel(newModelId);
         // Test insertModel error handling
         try {
-            testImodel.models.insertModel({
+            txn.insertModel({
                 classFullName: DefinitionModel.classFullName,
                 modeledElement: { id: "0x10000000bad" },
             });
@@ -1368,26 +1394,22 @@ describe("iModel", () => {
         catch (error) {
             assert.isTrue(error instanceof IModelError || error.iTwinErrorId !== undefined);
         }
+        txn.end();
     });
     it("should create model with custom relationship to modeled element", async () => {
         const testImodel = imodel1;
+        const txn = new EditTxn(testImodel, "custom relationship to modeled element");
         assert.doesNotThrow(() => testImodel.schemaContext.getSchemaItemSync("TestBim:TestModelModelsElement", EntityClass), "TestModelModelsElement is expected to be defined in TestBim.ecschema.xml");
-        let newModelId1;
-        let newModelId2;
-        let relClassName1;
-        let relClassName2;
-        if (true) {
-            const newPartition1 = IModelTestUtils.createAndInsertPhysicalPartition(testImodel, Code.createEmpty());
-            relClassName1 = "TestBim:TestModelModelsElement";
-            const modeledElementRef = new RelatedElement({ id: newPartition1, relClassName: relClassName1 });
-            newModelId1 = IModelTestUtils.createAndInsertPhysicalModel(testImodel, modeledElementRef);
-            assert.isTrue(Id64.isValidId64(newModelId1));
-        }
-        if (true) {
-            [, newModelId2] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(testImodel, Code.createEmpty());
-            const newModel2 = testImodel.models.getModel(newModelId2);
-            relClassName2 = newModel2.modeledElement.relClassName;
-        }
+        txn.start();
+        const newPartition1 = IModelTestUtils.createAndInsertPhysicalPartition(txn, Code.createEmpty());
+        const relClassName1 = "TestBim:TestModelModelsElement";
+        const modeledElementRef = new RelatedElement({ id: newPartition1, relClassName: relClassName1 });
+        const newModelId1 = IModelTestUtils.createAndInsertPhysicalModel(txn, modeledElementRef);
+        assert.isTrue(Id64.isValidId64(newModelId1));
+        const [, newModelId2] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txn, Code.createEmpty());
+        txn.end();
+        const newModel2 = testImodel.models.getModel(newModelId2);
+        const relClassName2 = newModel2.modeledElement.relClassName;
         const model1 = testImodel.models.getModel(newModelId1);
         const model2 = testImodel.models.getModel(newModelId2);
         const foundRelClassName1 = model1.modeledElement.relClassName;
@@ -1398,11 +1420,12 @@ describe("iModel", () => {
     it("should create link table relationship instances", () => {
         const snapshotFile2 = IModelTestUtils.prepareOutputFile("IModel", "CreateLinkTable.bim");
         const testImodel = StandaloneDb.createEmpty(snapshotFile2, { rootSubject: { name: "test1" }, enableTransactions: true });
-        const elements = testImodel.elements;
+        const txn = new EditTxn(testImodel, "link table relationship instances");
+        txn.start();
         // Create a new physical model
-        const newModelId = PhysicalModel.insert(testImodel, IModel.rootSubjectId, "TestModel");
+        const newModelId = PhysicalModel.insert(txn, IModel.rootSubjectId, "TestModel");
         // create a SpatialCategory
-        const spatialCategoryId = SpatialCategory.insert(testImodel, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorByName.darkRed }));
+        const spatialCategoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorByName.darkRed }));
         // Create a couple of physical elements.
         const elementProps = {
             classFullName: PhysicalObject.classFullName,
@@ -1410,16 +1433,16 @@ describe("iModel", () => {
             category: spatialCategoryId,
             code: Code.createEmpty(),
         };
-        const id0 = elements.insertElement(elementProps);
-        const id1 = elements.insertElement(elementProps);
-        const id2 = elements.insertElement(elementProps);
+        const id0 = txn.insertElement(elementProps);
+        const id1 = txn.insertElement(elementProps);
+        const id2 = txn.insertElement(elementProps);
         const geometricModel = testImodel.models.getModel(newModelId);
         assert.throws(() => geometricModel.queryExtents()); // no geometry
         // Create grouping relationships from 0 to 1 and from 0 to 2
         const r1 = ElementGroupsMembers.create(testImodel, id0, id1, 1);
-        r1.insert();
+        r1.id = txn.insertRelationship(r1.toJSON());
         const r2 = ElementGroupsMembers.create(testImodel, id0, id2);
-        r2.insert();
+        r2.id = txn.insertRelationship(r2.toJSON());
         // Look up by id
         const g1 = ElementGroupsMembers.getInstance(testImodel, r1.id);
         const g2 = ElementGroupsMembers.getInstance(testImodel, r2.id);
@@ -1434,53 +1457,57 @@ describe("iModel", () => {
         assert.deepEqual(g1byst, g1);
         // Update relationship instance property
         r1.asAny.memberPriority = 2;
-        r1.update();
+        txn.updateRelationship(r1.toJSON());
         const g11 = ElementGroupsMembers.getInstance(testImodel, r1.id);
         assert.equal(g11.memberPriority, 2, "g11.memberPriority");
-        testImodel.saveChanges("step 1");
+        txn.saveChanges("step 1");
         // Delete relationship instance property
-        g11.delete();
-        testImodel.saveChanges("step 2");
+        txn.deleteRelationship(g11.toJSON());
+        txn.saveChanges("step 2");
         assert.throws(() => ElementGroupsMembers.getInstance(testImodel, r1.id), IModelError);
-        const d0 = elements.insertElement(elementProps);
-        const d1 = elements.insertElement(elementProps);
+        const d0 = txn.insertElement(elementProps);
+        const d1 = txn.insertElement(elementProps);
         const ede1 = ElementDrivesElement.create(testImodel, d0, d1, 0);
-        ede1.insert();
-        testImodel.saveChanges("step 3");
-        ede1.delete();
-        testImodel.saveChanges("step 4");
+        ede1.id = txn.insertRelationship(ede1.toJSON());
+        txn.saveChanges("step 3");
+        txn.deleteRelationship(ede1.toJSON());
+        txn.end("save", "step 4");
         testImodel.close();
     });
     it("should insert DefinitionSets", () => {
         const iModelFileName = IModelTestUtils.prepareOutputFile("IModel", "DefinitionSets.bim");
         const iModelDb = SnapshotDb.createEmpty(iModelFileName, { rootSubject: { name: "DefinitionSets" }, createClassViews: true });
-        const definitionContainerId = DefinitionContainer.insert(iModelDb, IModel.dictionaryId, Code.createEmpty());
+        const txn = new EditTxn(iModelDb, "definition sets");
+        txn.start();
+        const definitionContainerId = DefinitionContainer.insert(txn, IModel.dictionaryId, Code.createEmpty());
         assert.exists(iModelDb.elements.getElement(definitionContainerId));
         assert.exists(iModelDb.models.getModel(definitionContainerId));
-        const categoryId1 = SpatialCategory.insert(iModelDb, definitionContainerId, "Category1", new SubCategoryAppearance());
-        const categoryId2 = SpatialCategory.insert(iModelDb, definitionContainerId, "Category2", new SubCategoryAppearance());
-        const categoryId3 = SpatialCategory.insert(iModelDb, definitionContainerId, "Category3", new SubCategoryAppearance());
-        const definitionGroupId = DefinitionGroup.create(iModelDb, definitionContainerId, Code.createEmpty()).insert();
-        DefinitionGroupGroupsDefinitions.insert(iModelDb, definitionGroupId, categoryId1);
-        DefinitionGroupGroupsDefinitions.insert(iModelDb, definitionGroupId, categoryId2);
-        DefinitionGroupGroupsDefinitions.insert(iModelDb, definitionGroupId, categoryId3);
+        const categoryId1 = SpatialCategory.insert(txn, definitionContainerId, "Category1", new SubCategoryAppearance());
+        const categoryId2 = SpatialCategory.insert(txn, definitionContainerId, "Category2", new SubCategoryAppearance());
+        const categoryId3 = SpatialCategory.insert(txn, definitionContainerId, "Category3", new SubCategoryAppearance());
+        const definitionGroupId = DefinitionGroup.create(iModelDb, definitionContainerId, Code.createEmpty()).insert(txn);
+        DefinitionGroupGroupsDefinitions.insert(txn, definitionGroupId, categoryId1);
+        DefinitionGroupGroupsDefinitions.insert(txn, definitionGroupId, categoryId2);
+        DefinitionGroupGroupsDefinitions.insert(txn, definitionGroupId, categoryId3);
         // eslint-disable-next-line @typescript-eslint/no-deprecated
         const numMembers = iModelDb.withPreparedStatement(`SELECT COUNT(*) FROM ${DefinitionGroupGroupsDefinitions.classFullName}`, (statement) => {
             return statement.step() === DbResult.BE_SQLITE_ROW ? statement.getValue(0).getInteger() : 0;
         });
         assert.equal(numMembers, 3);
-        iModelDb.saveChanges();
+        txn.end();
         iModelDb.close();
     });
     it("should set EC properties of various types", async () => {
         const testImodel = imodel1;
         assert.doesNotThrow(() => testImodel.schemaContext.getSchemaItemSync("TestBim:TestPhysicalObject", EntityClass), "TestPhysicalObject is expected to be defined in TestBim.ecschema.xml");
+        const txn = new EditTxn(testImodel, "set EC properties of various types");
+        txn.start();
         // Create a new physical model
-        const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(testImodel, Code.createEmpty(), true);
+        const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txn, Code.createEmpty(), true);
         // Find or create a SpatialCategory
         let spatialCategoryId = SpatialCategory.queryCategoryIdByName(testImodel, IModel.dictionaryId, "MySpatialCategory");
         if (undefined === spatialCategoryId) {
-            spatialCategoryId = SpatialCategory.insert(testImodel, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance());
+            spatialCategoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance());
         }
         const trelClassName = "TestBim:TestPhysicalObjectRelatedToTestPhysicalObject";
         let id1;
@@ -1493,14 +1520,14 @@ describe("iModel", () => {
                 category: spatialCategoryId,
                 code: Code.createEmpty(),
             };
-            id1 = testImodel.elements.insertElement(testImodel.elements.createElement(elementProps).toJSON());
+            id1 = txn.insertElement(testImodel.elements.createElement(elementProps).toJSON());
             assert.isTrue(Id64.isValidId64(id1));
             // The second one should point to the first.
             elementProps.id = Id64.invalid;
             elementProps.relatedElement = { id: id1, relClassName: trelClassName };
             elementProps.parent = { id: id1, relClassName: trelClassName };
             elementProps.longProp = 4294967295; // make sure that we can save values in the range 0 ... UINT_MAX
-            id2 = testImodel.elements.insertElement(testImodel.elements.createElement(elementProps).toJSON());
+            id2 = txn.insertElement(testImodel.elements.createElement(elementProps).toJSON());
             assert.isTrue(Id64.isValidId64(id2));
         }
         if (true) {
@@ -1519,7 +1546,7 @@ describe("iModel", () => {
             // Change el2 to point to itself.
             const el2Modified = testImodel.elements.getElement(id2);
             el2Modified.asAny.relatedElement = { id: id2, relClassName: trelClassName };
-            testImodel.elements.updateElement(el2Modified.toJSON());
+            txn.updateElement(el2Modified.toJSON());
             // Test that el2 points to itself.
             const el2after = testImodel.elements.getElement(id2);
             assert.deepEqual(el2after.asAny.relatedElement.id, id2);
@@ -1529,11 +1556,12 @@ describe("iModel", () => {
             // Test that we can null out the navigation property
             const el2Modified = testImodel.elements.getElement(id2);
             el2Modified.asAny.relatedElement = null;
-            testImodel.elements.updateElement(el2Modified.toJSON());
+            txn.updateElement(el2Modified.toJSON());
             // Test that el2 has no relatedElement property value
             const el2after = testImodel.elements.getElement(id2);
             assert.isUndefined(el2after.asAny.relatedElement);
         }
+        txn.end();
     });
     it("should be able to create a snapshot IModel", async () => {
         const args = {
@@ -1559,23 +1587,25 @@ describe("iModel", () => {
         assert.equal(dbguid.byteLength, 16, "query guid property");
         const myPropsStr = { name: "MyProp", namespace: "test1", id: 1, subId: 1 };
         const myStrVal = "this is a test";
-        iModel.saveFileProperty(myPropsStr, myStrVal);
-        const readFromDb = iModel.queryFilePropertyString(myPropsStr);
-        assert.equal(readFromDb, myStrVal, "query string after save");
         const myPropsBlob = { name: "MyBlob", namespace: "test1", id: 10 };
         const testRange = new Uint8Array(500);
         testRange.fill(11);
-        iModel.saveFileProperty(myPropsBlob, undefined, testRange);
-        const blobFromDb = iModel.queryFilePropertyBlob(myPropsBlob);
-        assert.deepEqual(blobFromDb, testRange, "query blob after save");
-        let next = iModel.queryNextAvailableFileProperty(myPropsBlob);
-        assert.equal(11, next, "queryNextAvailableFileProperty blob");
-        next = iModel.queryNextAvailableFileProperty(myPropsStr);
-        assert.equal(2, next, "queryNextAvailableFileProperty str");
-        iModel.deleteFileProperty(myPropsStr);
-        assert.isUndefined(iModel.queryFilePropertyString(myPropsStr), "property was deleted");
-        next = iModel.queryNextAvailableFileProperty(myPropsStr);
-        assert.equal(0, next, "queryNextAvailableFileProperty, should return 0 when none present");
+        withEditTxn(iModel, (txn) => {
+            txn.saveFileProperty(myPropsStr, myStrVal);
+            const readFromDb = iModel.queryFilePropertyString(myPropsStr);
+            assert.equal(readFromDb, myStrVal, "query string after save");
+            txn.saveFileProperty(myPropsBlob, undefined, testRange);
+            const blobFromDb = iModel.queryFilePropertyBlob(myPropsBlob);
+            assert.deepEqual(blobFromDb, testRange, "query blob after save");
+            let next = iModel.queryNextAvailableFileProperty(myPropsBlob);
+            assert.equal(11, next, "queryNextAvailableFileProperty blob");
+            next = iModel.queryNextAvailableFileProperty(myPropsStr);
+            assert.equal(2, next, "queryNextAvailableFileProperty str");
+            txn.deleteFileProperty(myPropsStr);
+            assert.isUndefined(iModel.queryFilePropertyString(myPropsStr), "property was deleted");
+            next = iModel.queryNextAvailableFileProperty(myPropsStr);
+            assert.equal(0, next, "queryNextAvailableFileProperty, should return 0 when none present");
+        });
         const testLocal = "TestLocal";
         const testValue = "this is a test";
         const nativeDb = iModel[_nativeDb];
@@ -1638,8 +1668,9 @@ describe("iModel", () => {
         assert.isFalse(eventListenedTo);
         iModel.geographicCoordinateSystem = gcs;
         assert.isTrue(eventListenedTo);
-        iModel.updateIModelProps();
-        iModel.saveChanges();
+        withEditTxn(iModel, (txn) => {
+            txn.updateIModelProps();
+        });
         iModel.close();
         const iModel2 = SnapshotDb.openFile(testFile);
         assert.isTrue(iModel2.geographicCoordinateSystem !== undefined);
@@ -1710,9 +1741,10 @@ describe("iModel", () => {
                     datumOrGCS = datum;
                 const testFile = IModelTestUtils.prepareOutputFile("IModel", fileName);
                 const iModel = SnapshotDb.createEmpty(testFile, args);
-                iModel.setGeographicCoordinateSystem(fileGCS);
-                iModel.updateIModelProps();
-                iModel.saveChanges();
+                withEditTxn(iModel, (txn) => {
+                    iModel.setGeographicCoordinateSystem(fileGCS);
+                    txn.updateIModelProps();
+                });
                 const testPoint1 = [];
                 testPoint1.push(inputCoord);
                 const requestProps1 = { target: datumOrGCS, iModelCoords: testPoint1 };
@@ -1969,8 +2001,9 @@ describe("iModel", () => {
         const iModel = SnapshotDb.createEmpty(testFile, args);
         assert.isTrue(iModel.ecefLocation === undefined);
         iModel.ecefLocation = ecef;
-        iModel.updateIModelProps();
-        iModel.saveChanges();
+        withEditTxn(iModel, (txn) => {
+            txn.updateIModelProps();
+        });
         iModel.close();
         const iModel2 = SnapshotDb.openFile(testFile);
         assert.isTrue(iModel2.ecefLocation !== undefined);
@@ -1993,8 +2026,9 @@ describe("iModel", () => {
         const iModel = SnapshotDb.createEmpty(testFile, args);
         assert.isTrue(iModel.ecefLocation === undefined);
         iModel.ecefLocation = ecef;
-        iModel.updateIModelProps();
-        iModel.saveChanges();
+        withEditTxn(iModel, (txn) => {
+            txn.updateIModelProps();
+        });
         iModel.close();
         const iModel2 = SnapshotDb.openFile(testFile);
         assert.isTrue(iModel2.ecefLocation !== undefined);
@@ -2048,16 +2082,18 @@ describe("iModel", () => {
         const testFile = IModelTestUtils.prepareOutputFile("IModel", "TestSnapshot4.bim");
         const iModel = SnapshotDb.createEmpty(testFile, args);
         iModel.ecefLocation = ecef;
-        iModel.updateIModelProps();
-        iModel.saveChanges();
+        withEditTxn(iModel, (txn) => {
+            txn.updateIModelProps();
+        });
         iModel.close();
         const iModel2 = SnapshotDb.openForApplyChangesets(testFile);
         assert.isTrue(iModel2.ecefLocation !== undefined);
         assert.isTrue(iModel2.ecefLocation.isAlmostEqual(ecef));
         assert.isTrue(iModel2.geographicCoordinateSystem === undefined);
         iModel2.geographicCoordinateSystem = gcs;
-        iModel2.updateIModelProps();
-        iModel2.saveChanges();
+        withEditTxn(iModel2, (txn) => {
+            txn.updateIModelProps();
+        });
         iModel2.close();
         const iModel3 = SnapshotDb.openFile(testFile);
         assert.isTrue(iModel3.geographicCoordinateSystem !== undefined);
@@ -2078,6 +2114,7 @@ describe("iModel", () => {
             getIModelId: () => iModelId,
             getITwinId: () => iTwinId,
             getCurrentChangeset: () => changeset,
+            hasUnsavedChanges: () => false,
             setIModelDb: () => { },
             closeFile: () => { },
             clearECDbCache: () => { },
@@ -2164,20 +2201,22 @@ describe("iModel", () => {
         };
         const seconds = (s) => s * 1000;
         const db = StandaloneDb.createEmpty(standaloneFile, { rootSubject: { name: "Standalone" } });
-        db.saveChanges();
+        const txn = new EditTxn(db, "busy timeout test");
+        txn.start();
         // lock db so another connection cannot write to it.
-        db.saveFileProperty({ name: "test", namespace: "test" }, "");
+        txn.saveFileProperty({ name: "test", namespace: "test" }, "");
         assert.isAtMost(tryOpen(standaloneFile, { busyTimeout: seconds(0) }), seconds(1), "open should fail with busy error instantly");
         assert.isAtLeast(tryOpen(standaloneFile, { busyTimeout: seconds(1) }), seconds(1), "open should fail with atleast 1 sec delay due to retry");
         assert.isAtLeast(tryOpen(standaloneFile, { busyTimeout: seconds(2) }), seconds(2), "open should fail with atleast 2 sec delay due to retry");
         assert.isAtLeast(tryOpen(standaloneFile, { busyTimeout: seconds(3) }), seconds(3), "open should fail with atleast 3 sec delay due to retry");
-        db.abandonChanges();
+        txn.end("abandon");
         db.close();
     });
     it("Cache cleared on abandonChanges", () => {
         const standaloneFile = IModelTestUtils.prepareOutputFile("IModel", "StandaloneReadWrite.bim");
         const db = StandaloneDb.createEmpty(standaloneFile, { rootSubject: { name: "Standalone" } });
-        db.saveChanges();
+        const txn = new EditTxn(db, "cache cleared on abandonChanges");
+        txn.start();
         const code = Code.createEmpty();
         code.value = "foo";
         const props = {
@@ -2185,29 +2224,32 @@ describe("iModel", () => {
             model: IModel.dictionaryId,
             code,
         };
-        const id = db.elements.insertElement(props);
+        const id = txn.insertElement(props);
         const element1 = db.elements.getElementProps(id);
-        db.abandonChanges();
+        txn.end("abandon");
         code.value = "bar";
         const props2 = {
             classFullName: GenericGraphicalType2d.classFullName,
             model: IModel.dictionaryId,
             code,
         };
-        const id2 = db.elements.insertElement(props2);
+        const retryTxn = new EditTxn(db, "cache cleared on abandonChanges retry");
+        retryTxn.start();
+        const id2 = retryTxn.insertElement(props2);
         expect(id2).to.equal(id);
         const element2 = db.elements.getElementProps(id2);
         expect(element2).to.not.equal(element1);
         // Make sure that the statement caches are not cleared
         expect(db._sqliteStatementCache.size).to.be.greaterThan(0);
         expect(db._statementCache.size).to.be.greaterThan(0);
-        db.abandonChanges();
+        retryTxn.end("abandon");
         db.close();
     });
     it("Only instance caches should be cleared with clearCaches instanceCachesOnly parameter", () => {
         const standaloneFile = IModelTestUtils.prepareOutputFile("IModel", "StandaloneReadWrite.bim");
         const db = StandaloneDb.createEmpty(standaloneFile, { rootSubject: { name: "Standalone" } });
-        db.saveChanges();
+        const txn = new EditTxn(db, "clearCaches instanceCachesOnly");
+        txn.start();
         const code = Code.createEmpty();
         code.value = "foo";
         const props = {
@@ -2215,7 +2257,7 @@ describe("iModel", () => {
             model: IModel.dictionaryId,
             code,
         };
-        const id = db.elements.insertElement(props);
+        const id = txn.insertElement(props);
         db.elements.getElementProps(id);
         db.models.getModelProps(IModel.dictionaryId);
         expect(db.elements[_cache].size).to.be.greaterThan(0);
@@ -2230,7 +2272,7 @@ describe("iModel", () => {
         // Make sure that the statement caches are not cleared
         expect(db._sqliteStatementCache.size).to.be.greaterThan(0);
         expect(db._statementCache.size).to.be.greaterThan(0);
-        db.abandonChanges();
+        txn.end("abandon");
         db.close();
     });
     it("Standalone iModel properties", () => {
@@ -2371,28 +2413,29 @@ describe("iModel", () => {
         iModel.close();
     });
     it("Run plain SQL", () => {
-        imodel1.withPreparedSqliteStatement("CREATE TABLE Test(Id INTEGER PRIMARY KEY, Name TEXT NOT NULL, Code INTEGER)", (stmt) => {
-            assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
-        });
-        imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(?,?)", (stmt) => {
-            stmt.bindValue(1, "Dummy 1");
-            stmt.bindValue(2, 100);
-            assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
-        });
-        imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(?,?)", (stmt) => {
-            stmt.bindValues(["Dummy 2", 200]);
-            assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
-        });
-        imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(:p1,:p2)", (stmt) => {
-            stmt.bindValue(":p1", "Dummy 3");
-            stmt.bindValue(":p2", 300);
-            assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
-        });
-        imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(:p1,:p2)", (stmt) => {
-            stmt.bindValues({ ":p1": "Dummy 4", ":p2": 400 });
-            assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+        withEditTxn(imodel1, () => {
+            imodel1.withPreparedSqliteStatement("CREATE TABLE Test(Id INTEGER PRIMARY KEY, Name TEXT NOT NULL, Code INTEGER)", (stmt) => {
+                assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+            });
+            imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(?,?)", (stmt) => {
+                stmt.bindValue(1, "Dummy 1");
+                stmt.bindValue(2, 100);
+                assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+            });
+            imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(?,?)", (stmt) => {
+                stmt.bindValues(["Dummy 2", 200]);
+                assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+            });
+            imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(:p1,:p2)", (stmt) => {
+                stmt.bindValue(":p1", "Dummy 3");
+                stmt.bindValue(":p2", 300);
+                assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+            });
+            imodel1.withPreparedSqliteStatement("INSERT INTO Test(Name,Code) VALUES(:p1,:p2)", (stmt) => {
+                stmt.bindValues({ ":p1": "Dummy 4", ":p2": 400 });
+                assert.equal(stmt.step(), DbResult.BE_SQLITE_DONE);
+            });
         });
-        imodel1.saveChanges();
         imodel1.withPreparedSqliteStatement("SELECT Id,Name,Code FROM Test ORDER BY Id", (stmt) => {
             for (let i = 1; i <= 4; i++) {
                 assert.equal(stmt.step(), DbResult.BE_SQLITE_ROW);
@@ -2501,7 +2544,9 @@ describe("iModel", () => {
         assert.isFalse(imodel1.containsClass("InvalidSchemaName:Element"));
     });
     it("should update Element code", () => {
-        const elementId = imodel4.elements.insertElement({
+        const txn = new EditTxn(imodel4, "update element code");
+        txn.start();
+        const elementId = txn.insertElement({
             classFullName: "DgnPlatformTest:TestInformationRecord",
             model: IModel.repositoryModelId,
             code: Code.createEmpty(),
@@ -2509,16 +2554,19 @@ describe("iModel", () => {
         let element = imodel4.elements.getElement(elementId, InformationRecordElement);
         assert.isTrue(Code.isValid(element.code));
         assert.isTrue(Code.isEmpty(element.code));
-        const codeSpecId = imodel4.codeSpecs.insert("TestCodeSpec", CodeScopeSpec.Type.Model);
+        const codeSpecId = imodel4.codeSpecs.insert(txn, "TestCodeSpec", CodeScopeSpec.Type.Model);
         const codeValue = `${element.className}-1`;
         element.code = new Code({ spec: codeSpecId, scope: IModel.repositoryModelId, value: codeValue });
-        element.update();
+        element.update(txn);
+        txn.end();
         element = imodel4.elements.getElement(elementId, InformationRecordElement);
         assert.isTrue(Code.isValid(element.code));
         assert.isFalse(Code.isEmpty(element.code));
         assert.equal(element.code.value, codeValue);
     });
     it("should update UserLabel", () => {
+        const txn = new EditTxn(imodel1, "update user label");
+        txn.start();
         // type coercion reminder!
         const s = "";
         assert.isTrue(s === "");
@@ -2529,16 +2577,16 @@ describe("iModel", () => {
             model: IModel.dictionaryId,
             code: SpatialCategory.createCode(imodel1, IModel.dictionaryId, "TestCategoryForClearUserLabel"),
         };
-        const elementId = imodel1.elements.insertElement(elementProps);
+        const elementId = txn.insertElement(elementProps);
         let element = imodel1.elements.getElement(elementId);
         assert.isUndefined(element.userLabel);
         // update element with a defined userLabel
         element.userLabel = "UserLabel";
-        element.update();
+        element.update(txn);
         element = imodel1.elements.getElement(elementId);
         assert.equal(element.userLabel, "UserLabel");
         // make sure userLabel is not updated when not part of the specified ElementProps
-        imodel1.elements.updateElement({
+        txn.updateElement({
             id: element.id,
             classFullName: element.classFullName,
             model: element.model,
@@ -2558,11 +2606,14 @@ describe("iModel", () => {
         expect(elProps.isInstanceOfEntity).undefined;
         // remove userlabel by setting it to the blank string
         element.userLabel = "";
-        element.update();
+        element.update(txn);
+        txn.end();
         element = imodel1.elements.getElement(elementId);
         assert.isUndefined(element.userLabel); // NOTE: userLabel is cleared when the empty string is specified
     });
     it("should update FederationGuid", () => {
+        const txn = new EditTxn(imodel1, "update federation guid");
+        txn.start();
         // insert element with an undefined FederationGuid
         const elementProps = {
             classFullName: SpatialCategory.classFullName,
@@ -2570,7 +2621,7 @@ describe("iModel", () => {
             federationGuid: Guid.empty,
             code: SpatialCategory.createCode(imodel1, IModel.dictionaryId, "TestCategoryForClearFederationGuid"),
         };
-        const elementId = imodel1.elements.insertElement(elementProps);
+        const elementId = txn.insertElement(elementProps);
         let element = imodel1.elements.getElement(elementId);
         assert.isUndefined(element.federationGuid);
         assert.isFalse(element.isPrivate);
@@ -2578,12 +2629,12 @@ describe("iModel", () => {
         const federationGuid = Guid.createValue();
         element.federationGuid = federationGuid;
         element.isPrivate = true;
-        element.update();
+        element.update(txn);
         element = imodel1.elements.getElement(elementId);
         assert.equal(element.federationGuid, federationGuid);
         assert.isTrue(element.isPrivate);
         // make sure FederationGuid is not updated when not part of the specified ElementProps
-        imodel1.elements.updateElement({
+        txn.updateElement({
             id: element.id,
             classFullName: element.classFullName,
             model: element.model,
@@ -2595,20 +2646,23 @@ describe("iModel", () => {
         // remove federationGuid by setting it to undefined in ElementProps
         const elProps = element.toJSON();
         elProps.federationGuid = undefined;
-        imodel1.elements.updateElement(elProps);
+        txn.updateElement(elProps);
         element = imodel1.elements.getElement(elementId);
         assert.isUndefined(element.federationGuid);
         // ensure that update doesn't change federationGuid from an element immediately after insert (toJSON should remove undefined value)
         const subject5 = Subject.create(imodel1, IModel.rootSubjectId, "Subject5");
-        const s5Id = subject5.insert();
+        const s5Id = subject5.insert(txn);
         const s5pre = imodel1.elements.getElement(s5Id);
         subject5.description = "new descr";
-        subject5.update();
+        subject5.update(txn);
+        txn.end();
         const s5post = imodel1.elements.getElement(s5Id);
         expect(s5pre.federationGuid).equal(s5post.federationGuid);
         expect(s5post.description).equal(subject5.description);
     });
     it("should support partial update", () => {
+        const txn = new EditTxn(imodel1, "partial element update");
+        txn.start();
         // Insert Subject elements - initializing Description and UserLabel to similar values
         let subject1 = Subject.create(imodel1, IModel.rootSubjectId, "Subject1", "Description1");
         let subject2 = Subject.create(imodel1, IModel.rootSubjectId, "Subject2", "Description2");
@@ -2624,10 +2678,10 @@ describe("iModel", () => {
         subject2.federationGuid = federationGuid2;
         subject3.federationGuid = "";
         subject4.federationGuid = Guid.empty;
-        const subjectId1 = subject1.insert();
-        const subjectId2 = subject2.insert();
-        const subjectId3 = subject3.insert();
-        const subjectId4 = subject4.insert();
+        const subjectId1 = subject1.insert(txn);
+        const subjectId2 = subject2.insert(txn);
+        const subjectId3 = subject3.insert(txn);
+        const subjectId4 = subject4.insert(txn);
         subject1 = imodel1.elements.getElement(subjectId1, Subject);
         subject2 = imodel1.elements.getElement(subjectId2, Subject);
         subject3 = imodel1.elements.getElement(subjectId3, Subject);
@@ -2652,7 +2706,7 @@ describe("iModel", () => {
         assert.equal(subject2.federationGuid, federationGuid2);
         assert.isUndefined(subject4.federationGuid);
         // test partial update of Description (auto-handled)
-        imodel1.elements.updateElement({ id: subject1.id, description: "Description1-Updated" });
+        txn.updateElement({ id: subject1.id, description: "Description1-Updated" });
         subject1 = imodel1.elements.getElement(subjectId1, Subject);
         assert.equal(subject1.description, "Description1-Updated"); // should have been updated
         assert.isDefined(subject1.model);
@@ -2661,7 +2715,7 @@ describe("iModel", () => {
         assert.equal(subject1.userLabel, "UserLabel1"); // should not have changed
         assert.equal(subject1.federationGuid, federationGuid1); // should not have changed
         // test partial update of UserLabel (custom-handled)
-        imodel1.elements.updateElement({ id: subject2.id, userLabel: "UserLabel2-Updated" });
+        txn.updateElement({ id: subject2.id, userLabel: "UserLabel2-Updated" });
         subject2 = imodel1.elements.getElement(subjectId2, Subject);
         assert.isDefined(subject2.model);
         assert.isDefined(subject2.parent);
@@ -2677,10 +2731,10 @@ describe("iModel", () => {
         subject2.userLabel = "";
         subject3.userLabel = "UserLabel3";
         subject4.userLabel = "UserLabel4";
-        subject1.update();
-        subject2.update();
-        subject3.update();
-        subject4.update();
+        subject1.update(txn);
+        subject2.update(txn);
+        subject3.update(txn);
+        subject4.update(txn);
         subject1 = imodel1.elements.getElement(subjectId1, Subject);
         subject2 = imodel1.elements.getElement(subjectId2, Subject);
         subject3 = imodel1.elements.getElement(subjectId3, Subject);
@@ -2696,7 +2750,7 @@ describe("iModel", () => {
         assert.equal(subject4.userLabel, "UserLabel4");
         // test partial update of Description to undefined
         const s3Fed = subject3.federationGuid;
-        imodel1.elements.updateElement({ id: subject3.id, description: undefined });
+        txn.updateElement({ id: subject3.id, description: undefined });
         subject3 = imodel1.elements.getElement(subjectId3, Subject);
         assert.isUndefined(subject3.description); // should have been updated
         assert.isDefined(subject3.model);
@@ -2705,7 +2759,8 @@ describe("iModel", () => {
         assert.equal(subject3.userLabel, "UserLabel3"); // should not have changed
         assert.equal(subject3.federationGuid, s3Fed); // should not have changed
         // test partial update of UserLabel to undefined
-        imodel1.elements.updateElement({ id: subject4.id, userLabel: undefined });
+        txn.updateElement({ id: subject4.id, userLabel: undefined });
+        txn.end();
         subject4 = imodel1.elements.getElement(subjectId4, Subject);
         assert.isDefined(subject4.model);
         assert.isDefined(subject4.parent);
@@ -2717,6 +2772,8 @@ describe("iModel", () => {
     it('should allow untrimmed codes when using "exact" codeValueBehavior', () => {
         const imodelPath = IModelTestUtils.prepareOutputFile("IModel", "codeValueBehavior.bim");
         const imodel = SnapshotDb.createEmpty(imodelPath, { rootSubject: { name: "codeValueBehaviors" } });
+        const txn = new EditTxn(imodel, "codeValueBehavior");
+        txn.start();
         const getNumberedCodeValAndProps = (n) => {
             const trimmedCodeVal = `CodeValue${n}`;
             const untrimmedCodeVal = `${trimmedCodeVal}\xa0`;
@@ -2731,22 +2788,25 @@ describe("iModel", () => {
         };
         expect(imodel.codeValueBehavior).to.equal("trim-unicode-whitespace");
         const code1 = getNumberedCodeValAndProps(1);
-        const categ1Id = imodel.elements.insertElement(code1.props);
+        const categ1Id = txn.insertElement(code1.props);
         const categ1 = imodel.elements.getElementProps({ id: categ1Id });
         expect(categ1.code.value).to.equal(code1.trimmedCodeVal);
         imodel.codeValueBehavior = "exact";
         const code2 = getNumberedCodeValAndProps(2);
-        const categ2Id = imodel.elements.insertElement(code2.props);
+        const categ2Id = txn.insertElement(code2.props);
         const categ2 = imodel.elements.getElementProps({ id: categ2Id });
         expect(categ2.code.value).to.equal(code2.untrimmedCodeVal);
         imodel.codeValueBehavior = "trim-unicode-whitespace";
         const code3 = getNumberedCodeValAndProps(3);
-        const categ3Id = imodel.elements.insertElement(code3.props);
+        const categ3Id = txn.insertElement(code3.props);
         const categ3 = imodel.elements.getElement({ id: categ3Id });
         expect(categ3.code.value).to.equal(code3.trimmedCodeVal);
+        txn.end();
         imodel.close();
     });
     it("should throw iTwinErrors on element CRUD opertion fails", async () => {
+        const txn = new EditTxn(imodel1, "element CRUD failure cases");
+        txn.start();
         const code = Code.createEmpty();
         code.value = "foo";
         const props = {
@@ -2754,23 +2814,24 @@ describe("iModel", () => {
             model: IModel.dictionaryId,
             code,
         };
-        imodel1.elements.insertElement(props);
-        expect(() => imodel1.elements.insertElement(props)).throws("Error inserting element [duplicate code]").to.have.property("iTwinErrorId");
+        txn.insertElement(props);
+        expect(() => txn.insertElement(props)).throws("Error inserting element [duplicate code]").to.have.property("iTwinErrorId");
         const updateProps = {
             id: Id64.fromString("0x111111"),
             classFullName: GenericGraphicalType2d.classFullName,
             model: IModel.dictionaryId,
             code,
         };
-        expect(() => imodel1.elements.updateElement(updateProps)).throws(`Error updating element [missing id], id: ${updateProps.id}`).to.have.property("iTwinErrorId");
-        expect(() => imodel1.elements.deleteElement(updateProps.id)).throws(`Error deleting element [missing id], id: ${updateProps.id}`).to.have.property("iTwinErrorId");
-        expect(() => imodel1.models.insertModel({ classFullName: DefinitionModel.classFullName, modeledElement: { id: "0x10000000bad" } })).throws("Error inserting model [error=10004], class=BisCore:DefinitionModel").to.have.property("iTwinErrorId");
-        expect(() => imodel1.models.updateModel({
+        expect(() => txn.updateElement(updateProps)).throws(`Error updating element [missing id], id: ${updateProps.id}`).to.have.property("iTwinErrorId");
+        expect(() => txn.deleteElement(updateProps.id)).throws(`Error deleting element [missing id], id: ${updateProps.id}`).to.have.property("iTwinErrorId");
+        expect(() => txn.insertModel({ classFullName: DefinitionModel.classFullName, modeledElement: { id: "0x10000000bad" } })).throws("Error inserting model [error=10004], class=BisCore:DefinitionModel").to.have.property("iTwinErrorId");
+        expect(() => txn.updateModel({
             id: Id64.fromString("0x111111"),
             modeledElement: { id: Id64.fromString("0x111111") },
             classFullName: ""
         })).throws(`Error updating model [missing id], id: ${Id64.fromString("0x111111")}`).to.have.property("iTwinErrorId");
-        expect(() => imodel1.models.deleteModel(Id64.fromString("0x111111"))).throws(`Error deleting model [missing id], id: ${Id64.fromString("0x111111")}`).to.have.property("iTwinErrorId");
+        expect(() => txn.deleteModel(Id64.fromString("0x111111"))).throws(`Error deleting model [missing id], id: ${Id64.fromString("0x111111")}`).to.have.property("iTwinErrorId");
+        txn.end("abandon");
     });
     it("throws NotFound when attempting to access element props after closing the iModel", () => {
         const imodelPath = IModelTestUtils.prepareOutputFile("IModel", "accessAfterClose.bim");
@@ -2783,11 +2844,12 @@ describe("iModel", () => {
     it("should throw \"constraint failed (BE_SQLITE_CONSTRAINT_UNIQUE)\" when inserting a relationsip instance with the same prop twice", () => {
         const imodelPath = IModelTestUtils.prepareOutputFile("IModel", "insertDuplicateInstance.bim");
         const imodel = SnapshotDb.createEmpty(imodelPath, { rootSubject: { name: "insertDuplicateInstance" } });
-        const elements = imodel.elements;
+        const txn = new EditTxn(imodel, "insert duplicate relationship instance");
+        txn.start();
         // Create a new physical model
-        const newModelId = PhysicalModel.insert(imodel, IModel.rootSubjectId, "TestModel");
+        const newModelId = PhysicalModel.insert(txn, IModel.rootSubjectId, "TestModel");
         // create a SpatialCategory
-        const spatialCategoryId = SpatialCategory.insert(imodel, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorByName.darkRed }));
+        const spatialCategoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorByName.darkRed }));
         // Create a couple of physical elements.
         const elementProps = {
             classFullName: PhysicalObject.classFullName,
@@ -2795,16 +2857,17 @@ describe("iModel", () => {
             category: spatialCategoryId,
             code: Code.createEmpty(),
         };
-        const id0 = elements.insertElement(elementProps);
-        const id1 = elements.insertElement(elementProps);
+        const id0 = txn.insertElement(elementProps);
+        const id1 = txn.insertElement(elementProps);
         const props = {
             classFullName: "BisCore:ElementGroupsMembers",
             sourceId: id0,
             targetId: id1,
             memberPriority: 1,
         };
-        imodel.relationships.insertInstance(props);
-        expect(() => imodel.relationships.insertInstance(props)).to.throw(`Failed to insert relationship [${imodelPath}]: rc=2067, constraint failed (BE_SQLITE_CONSTRAINT_UNIQUE)`);
+        txn.insertRelationship(props);
+        expect(() => txn.insertRelationship(props)).to.throw(`Failed to insert relationship [${imodelPath}]: rc=2067, constraint failed (BE_SQLITE_CONSTRAINT_UNIQUE)`);
+        txn.end("abandon");
         imodel.close();
     });
     function createElemProps(_imodel, modId, catId, className) {
@@ -2817,11 +2880,11 @@ describe("iModel", () => {
         };
         return elementProps;
     }
-    function insertElement(imodel, mId, cId, cName, propName) {
+    function insertElement(imodel, mId, cId, cName, propName, txn) {
         const elementProps = createElemProps(imodel, mId, cId, cName);
         const geomElement = imodel.elements.createElement(elementProps);
         geomElement.name = propName; // Add a custom property to the element
-        const id = imodel.elements.insertElement(geomElement.toJSON());
+        const id = txn.insertElement(geomElement.toJSON());
         assert.isTrue(Id64.isValidId64(id), "insert failed");
         return id;
     }
@@ -2893,15 +2956,14 @@ describe("iModel", () => {
         // Ensure ADrivesB table is empty before test
         validateADrivesBRowCount(testImodel, 0);
         // Create a physical model and spatial category if needed
-        const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(testImodel, Code.createEmpty(), true);
-        let spatialCategoryId = SpatialCategory.queryCategoryIdByName(testImodel, IModel.dictionaryId, "MySpatialCategory");
-        if (!spatialCategoryId) {
-            spatialCategoryId = SpatialCategory.insert(testImodel, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorDef.fromString("rgb(255,0,0)").toJSON() }));
-        }
-        // Insert a ChildB element to be referenced by ChildA
-        const idB = insertElement(testImodel, newModelId, spatialCategoryId, "TestRelationSchema:ChildB", "ChildBElement");
+        const setupTxn = new EditTxn(testImodel, "setup invalid relationship class test");
+        setupTxn.start();
+        const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(setupTxn, Code.createEmpty(), true);
+        const spatialCategoryId = SpatialCategory.queryCategoryIdByName(testImodel, IModel.dictionaryId, "MySpatialCategory")
+            ?? SpatialCategory.insert(setupTxn, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance({ color: ColorDef.fromString("rgb(255,0,0)").toJSON() }));
+        const idB = insertElement(testImodel, newModelId, spatialCategoryId, "TestRelationSchema:ChildB", "ChildBElement", setupTxn);
+        setupTxn.end();
         assert.isTrue(Id64.isValidId64(idB), "Insert ChildBElement failed");
-        testImodel.saveChanges();
         // Prepare base props for ChildA
         const elementProps = createElemProps(testImodel, newModelId, spatialCategoryId, "TestRelationSchema:ChildA");
         // Test various relationship class names for navigation property
@@ -2913,52 +2975,57 @@ describe("iModel", () => {
             { name: "trs:CIsRelatedToD", shouldSucceed: false, expectedRows: 0 },
         ];
         for (const { name, shouldSucceed, expectedRows } of testCases) {
-            const elemRef = new RelatedElement({ id: idB, relClassName: name });
-            elementProps.navPropChildB = elemRef;
-            elementProps.name = "ChildAElement";
-            const geomElement = testImodel.elements.createElement(elementProps);
-            let idA;
+            const txn = new EditTxn(testImodel, `invalid relationship class ${name}`);
+            txn.start();
             try {
-                idA = testImodel.elements.insertElement(geomElement.toJSON());
-                if (shouldSucceed)
-                    assert.isTrue(Id64.isValidId64(idA), `Insert should have succeeded for ${name}.`);
-                else
-                    assert.fail(`Insert should have failed for ${name}.`);
-            }
-            catch (err) {
-                if (shouldSucceed)
-                    assert.fail(`Insert should have succeeded for ${name}. Error: ${err.message}`);
-                // If should not succeed, error is expected
-            }
-            // Validate row count in ADrivesB table
-            validateADrivesBRowCount(testImodel, expectedRows);
-            // If insert succeeded, test update and delete scenarios
-            if (expectedRows === 1 && idA !== undefined) {
-                validateNavProp(testImodel, { id: idB, relClassName: "TestRelationSchema.ADrivesB" });
-                const editElem = testImodel.elements.getElement(idA);
-                editElem.navPropChildB = new RelatedElement({ id: idB, relClassName: "trs.FakeClass" });
-                editElem.name = "ChildAElementUpdated";
-                testImodel.elements.updateElement(editElem);
-                validateADrivesBRowCount(testImodel, 1);
-                validateNavProp(testImodel, { id: idB, relClassName: "TestRelationSchema.ADrivesB" });
-                const editedElem = testImodel.elements.getElement(idA);
-                assert.equal(editedElem.name, "ChildAElementUpdated", `Expected name to be "ChildAElementUpdated" after update, but got "${editedElem.name}"`);
-                assert.strictEqual(editedElem.navPropChildB.relClassName, "TestRelationSchema.ADrivesB", `Expected navPropChildB to be "TestRelationSchema.ADrivesB" after update, but got "${editedElem.navPropChildB}"`);
-                // Set the nav prop value to null
-                editElem.name = "ChildAElementNulled";
-                editElem.navPropChildB = null;
-                testImodel.elements.updateElement(editElem);
-                validateADrivesBRowCount(testImodel, 0);
-                const nulledElem = testImodel.elements.getElement(idA);
-                assert.equal(nulledElem.name, "ChildAElementNulled", `Expected name to be "ChildAElementNulled" after nulling, but got "${nulledElem.name}"`);
-                assert.isUndefined(nulledElem.navPropChildB, `Expected navPropChildB to be undefined after nulling, but got "${nulledElem.navPropChildB}"`);
-                if (shouldSucceed) {
-                    // Delete the element
-                    testImodel.elements.deleteElement(idA);
-                    assert.isUndefined(testImodel.elements.tryGetElement(idA), `Expected element with id ${idA} to be deleted, but it still exists.`);
+                const elemRef = new RelatedElement({ id: idB, relClassName: name });
+                elementProps.navPropChildB = elemRef;
+                elementProps.name = "ChildAElement";
+                const geomElement = testImodel.elements.createElement(elementProps);
+                let idA;
+                try {
+                    idA = txn.insertElement(geomElement.toJSON());
+                    if (shouldSucceed)
+                        assert.isTrue(Id64.isValidId64(idA), `Insert should have succeeded for ${name}.`);
+                    else
+                        assert.fail(`Insert should have failed for ${name}.`);
                 }
+                catch (err) {
+                    if (shouldSucceed)
+                        assert.fail(`Insert should have succeeded for ${name}. Error: ${err.message}`);
+                    // If should not succeed, error is expected
+                }
+                // Validate row count in ADrivesB table
+                validateADrivesBRowCount(testImodel, expectedRows);
+                // If insert succeeded, test update and delete scenarios
+                if (expectedRows === 1 && idA !== undefined) {
+                    validateNavProp(testImodel, { id: idB, relClassName: "TestRelationSchema.ADrivesB" });
+                    const editElem = testImodel.elements.getElement(idA);
+                    editElem.navPropChildB = new RelatedElement({ id: idB, relClassName: "trs.FakeClass" });
+                    editElem.name = "ChildAElementUpdated";
+                    txn.updateElement(editElem);
+                    validateADrivesBRowCount(testImodel, 1);
+                    validateNavProp(testImodel, { id: idB, relClassName: "TestRelationSchema.ADrivesB" });
+                    const editedElem = testImodel.elements.getElement(idA);
+                    assert.equal(editedElem.name, "ChildAElementUpdated", `Expected name to be "ChildAElementUpdated" after update, but got "${editedElem.name}"`);
+                    assert.strictEqual(editedElem.navPropChildB.relClassName, "TestRelationSchema.ADrivesB", `Expected navPropChildB to be "TestRelationSchema.ADrivesB" after update, but got "${editedElem.navPropChildB}"`);
+                    // Set the nav prop value to null
+                    editElem.name = "ChildAElementNulled";
+                    editElem.navPropChildB = null;
+                    txn.updateElement(editElem);
+                    validateADrivesBRowCount(testImodel, 0);
+                    const nulledElem = testImodel.elements.getElement(idA);
+                    assert.equal(nulledElem.name, "ChildAElementNulled", `Expected name to be "ChildAElementNulled" after nulling, but got "${nulledElem.name}"`);
+                    assert.isUndefined(nulledElem.navPropChildB, `Expected navPropChildB to be undefined after nulling, but got "${nulledElem.navPropChildB}"`);
+                    if (shouldSucceed) {
+                        txn.deleteElement(idA);
+                        assert.isUndefined(testImodel.elements.tryGetElement(idA), `Expected element with id ${idA} to be deleted, but it still exists.`);
+                    }
+                }
+            }
+            finally {
+                txn.end("abandon");
             }
-            testImodel.abandonChanges();
         }
         testImodel.close();
     });
@@ -2971,18 +3038,20 @@ describe("iModel", () => {
         let categoryB = SpatialCategory.create(imodelDb, IModel.dictionaryId, "B");
         categoryA.userLabel = "A";
         categoryB.userLabel = "B";
-        categoryA.insert();
-        categoryB.insert();
-        imodelDb.saveChanges();
+        const txn = new EditTxn(imodelDb, "change codeValues");
+        txn.start();
+        categoryA.insert(txn);
+        categoryB.insert(txn);
+        txn.saveChanges();
         categoryA = imodelDb.elements.getElement(SpatialCategory.createCode(imodelDb, IModel.dictionaryId, "A"));
         categoryB = imodelDb.elements.getElement(SpatialCategory.createCode(imodelDb, IModel.dictionaryId, "B"));
         categoryA.code.value = "temp";
-        categoryA.update();
+        categoryA.update(txn);
         categoryB.code.value = "A";
-        categoryB.update();
+        categoryB.update(txn);
         categoryA.code.value = "B";
-        categoryA.update();
-        imodelDb.saveChanges();
+        categoryA.update(txn);
+        txn.end();
         categoryA = imodelDb.elements.getElement(SpatialCategory.createCode(imodelDb, IModel.dictionaryId, "A"));
         categoryB = imodelDb.elements.getElement(SpatialCategory.createCode(imodelDb, IModel.dictionaryId, "B"));
         expect(categoryA.userLabel).to.equal("B", `categoryA.userLabel mismatch in ${imodelDb.name}`);
@@ -3025,17 +3094,19 @@ describe("iModel", () => {
         function setupRelationships(numOfRelationships, multipleClasses = false) {
             testImodel = SnapshotDb.createEmpty(IModelTestUtils.prepareOutputFile("IModel", "DeleteRelationshipInstances.bim"), { rootSubject: { name: "DeleteRelationshipInstances" } });
             assert.isTrue(testImodel.isOpen);
-            const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(testImodel, Code.createEmpty(), true);
+            const txn = new EditTxn(testImodel, "setup delete relationships");
+            txn.start();
+            const [, newModelId] = IModelTestUtils.createAndInsertPhysicalPartitionAndModel(txn, Code.createEmpty(), true);
             let spatialCategoryId = SpatialCategory.queryCategoryIdByName(testImodel, IModel.dictionaryId, "MySpatialCategory");
             if (!spatialCategoryId) {
-                spatialCategoryId = SpatialCategory.insert(testImodel, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance());
+                spatialCategoryId = SpatialCategory.insert(txn, IModel.dictionaryId, "MySpatialCategory", new SubCategoryAppearance());
             }
             const relationships = [];
             for (let i = 0; i < numOfRelationships; ++i) {
                 const sourceProps = createElemProps(testImodel, newModelId, spatialCategoryId, "Generic:PhysicalObject");
-                const sourceId = testImodel.elements.insertElement(sourceProps);
+                const sourceId = txn.insertElement(sourceProps);
                 const targetProps = createElemProps(testImodel, newModelId, spatialCategoryId, "Generic:PhysicalObject");
-                const targetId = testImodel.elements.insertElement(targetProps);
+                const targetId = txn.insertElement(targetProps);
                 let relationshipClass = "BisCore:ElementGroupsMembers";
                 if (multipleClasses)
                     relationshipClass = relationshipClasses[i % relationshipClasses.length];
@@ -3044,10 +3115,10 @@ describe("iModel", () => {
                     sourceId,
                     targetId,
                 };
-                relationshipProps.id = testImodel.relationships.insertInstance(relationshipProps);
+                relationshipProps.id = txn.insertRelationship(relationshipProps);
                 relationships.push(relationshipProps);
             }
-            testImodel.saveChanges();
+            txn.end();
             return relationships;
         }
         async function getRelationshipCount(iModel, relationshipClass) {
@@ -3058,16 +3129,18 @@ describe("iModel", () => {
         it("deleteInstances with an empty array", async () => {
             const relationships = setupRelationships(10);
             assert.equal(relationships.length, await getRelationshipCount(testImodel, "BisCore.ElementGroupsMembers"));
-            testImodel.relationships.deleteInstances([]);
-            testImodel.saveChanges();
+            withEditTxn(testImodel, (txn) => {
+                txn.deleteRelationships([]);
+            });
             assert.equal(relationships.length, await getRelationshipCount(testImodel, "BisCore.ElementGroupsMembers"));
         });
         it("deleteInstances with a single relationship instance", async () => {
             const relationships = setupRelationships(10);
             assert.equal(relationships.length, await getRelationshipCount(testImodel, "BisCore.ElementGroupsMembers"), "Should delete exactly one relationship");
             // Delete just one relationship using deleteInstances method
-            testImodel.relationships.deleteInstances([relationships[0]]);
-            testImodel.saveChanges();
+            withEditTxn(testImodel, (txn) => {
+                txn.deleteRelationships([relationships[0]]);
+            });
             const remainingCount = await getRelationshipCount(testImodel, "BisCore.ElementGroupsMembers");
             assert.equal(remainingCount, relationships.length - 1, "Should delete exactly one relationship");
         });
@@ -3078,8 +3151,9 @@ describe("iModel", () => {
             assert.isTrue(await getRelationshipCount(testImodel, "BisCore.ElementDrivesElement") >= Math.floor(relationships.length / 3));
             assert.isTrue(await getRelationshipCount(testImodel, "BisCore.ElementRefersToDocuments") >= Math.floor(relationships.length / 3));
             // Test deleteInstances with mixed relationship classes
-            testImodel.relationships.deleteInstances(relationships);
-            testImodel.saveChanges();
+            withEditTxn(testImodel, (txn) => {
+                txn.deleteRelationships(relationships);
+            });
             // Verify all relationships were deleted regardless of their class
             assert.equal(0, await getRelationshipCount(testImodel, "BisCore.ElementGroupsMembers"), "All ElementGroupsMembers relationships should be deleted");
             assert.equal(0, await getRelationshipCount(testImodel, "BisCore.ElementDrivesElement"), "All ElementDrivesElement relationships should be deleted");
@@ -3096,8 +3170,9 @@ describe("iModel", () => {
             for (let i = 0; i < 250; ++i) {
                 relationshipsToDelete.push(relationships[Math.floor(Math.random() * relationships.length)]);
             }
-            testImodel.relationships.deleteInstances(relationshipsToDelete);
-            testImodel.saveChanges();
+            withEditTxn(testImodel, (txn) => {
+                txn.deleteRelationships(relationshipsToDelete);
+            });
             // Verify all relationships were deleted
             for (const relClass of relationshipsToDelete) {
                 const reader = testImodel.createQueryReader(`SELECT ECInstanceId FROM ${relClass.classFullName} WHERE SourceECInstanceId=? AND TargetECInstanceId=?`, new QueryBinder().bindId(1, relClass.sourceId).bindId(2, relClass.targetId));