@fluidframework/container-runtime 2.43.0-343119 → 2.43.0

package/lib/containerRuntime.js

@@ -621,15 +621,15 @@ export class ContainerRuntime extends TypedEventEmitter {
         // eslint-disable-next-line import/no-deprecated
         this.enterStagingMode = () => {
             if (this.stageControls !== undefined) {
-                throw new UsageError("already in staging mode");
+                throw new UsageError("Already in staging mode");
             }
             if (this.attachState === AttachState.Detached) {
-                throw new UsageError("cannot enter staging mode while detached");
+                throw new UsageError("Cannot enter staging mode while Detached");
             }
             // Make sure Outbox is empty before entering staging mode,
             // since we mark whole batches as "staged" or not to indicate whether to submit them.
             this.flush();
-            const exitStagingMode = (discardOrCommit) => () => {
+            const exitStagingMode = (discardOrCommit) => {
                 try {
                     // Final flush of any last staged changes
                     // NOTE: We can't use this.flush() here, because orderSequentially uses StagingMode and in the rollback case we'll hit assert 0x24c
@@ -649,22 +649,23 @@ export class ContainerRuntime extends TypedEventEmitter {
             };
             // eslint-disable-next-line import/no-deprecated
             const stageControls = {
-                discardChanges: exitStagingMode(() => {
+                discardChanges: () => exitStagingMode(() => {
                     // Pop all staged batches from the PSM and roll them back in LIFO order
                     this.pendingStateManager.popStagedBatches(({ runtimeOp, localOpMetadata }) => {
-                        assert(runtimeOp !== undefined, 0xb82 /* Staged batches expected to have runtimeOp defined */);
-                        this.rollbackStagedChanges(runtimeOp, localOpMetadata);
+                        this.rollbackStagedChange(runtimeOp, localOpMetadata);
                     });
                     this.updateDocumentDirtyState();
                 }),
-                commitChanges: (optionsParam) => {
-                    const options = { ...defaultStagingCommitOptions, ...optionsParam };
-                    return exitStagingMode(() => {
+                commitChanges: (options) => {
+                    const { squash } = { ...defaultStagingCommitOptions, ...options };
+                    exitStagingMode(() => {
+                        // Replay all staged batches in typical FIFO order.
+                        // We'll be out of staging mode so they'll be sent to the service finally.
                         this.pendingStateManager.replayPendingStates({
-                            onlyStagedBatches: true,
-                            squash: options.squash ?? false,
+                            committingStagedBatches: true,
+                            squash,
                         });
-                    })();
+                    });
                 },
             };
             this.stageControls = stageControls;
@@ -2076,7 +2077,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     try {
                         checkpoint.rollback((message) => 
                         // These changes are staged since we entered staging mode above
-                        this.rollbackStagedChanges(message.runtimeOp, message.localOpMetadata));
+                        this.rollbackStagedChange(message.runtimeOp, message.localOpMetadata));
                         this.updateDocumentDirtyState();
                         stageControls?.discardChanges();
                         stageControls = undefined;
@@ -3055,7 +3056,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     /**
      * Rollback the given op which was only staged but not yet submitted.
      */
-    rollbackStagedChanges({ type, contents }, localOpMetadata) {
+    rollbackStagedChange({ type, contents }, localOpMetadata) {
         assert(canStageMessageOfType(type), 0xbbc /* Unexpected message type to be rolled back */);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp: {