@fluidframework/container-loader 2.62.0 → 2.63.0-359286

package/dist/deltaManager.js

@@ -5,10 +5,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeltaManager = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const internal_2 = require("@fluidframework/driver-definitions/internal");
-const internal_3 = require("@fluidframework/driver-utils/internal");
-const internal_4 = require("@fluidframework/telemetry-utils/internal");
+const internal_1 = require("@fluidframework/core-interfaces/internal");
+const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_3 = require("@fluidframework/driver-definitions/internal");
+const internal_4 = require("@fluidframework/driver-utils/internal");
+const internal_5 = require("@fluidframework/telemetry-utils/internal");
 const uuid_1 = require("uuid");
 const deltaQueue_js_1 = require("./deltaQueue.js");
 const error_js_1 = require("./error.js");
@@ -16,15 +17,15 @@ const error_js_1 = require("./error.js");
  * Determines if message was sent by client, not service
  */
 function isClientMessage(message) {
-    if ((0, internal_3.isRuntimeMessage)(message)) {
+    if ((0, internal_4.isRuntimeMessage)(message)) {
         return true;
     }
     switch (message.type) {
-        case internal_2.MessageType.Propose:
-        case internal_2.MessageType.Reject:
-        case internal_2.MessageType.NoOp:
-        case internal_2.MessageType.Accept:
-        case internal_2.MessageType.Summarize: {
+        case internal_3.MessageType.Propose:
+        case internal_3.MessageType.Reject:
+        case internal_3.MessageType.NoOp:
+        case internal_3.MessageType.Accept:
+        case internal_3.MessageType.Summarize: {
             return true;
         }
         default: {
@@ -53,7 +54,7 @@ function logIfFalse(condition, logger, event) {
  * Manages the flow of both inbound and outbound messages. This class ensures that shared objects receive delta
  * messages in order regardless of possible network conditions or timings causing out of order delivery.
  */
-class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
+class DeltaManager extends internal_5.EventEmitterWithErrorHandling {
     get active() {
         return this._active();
     }
@@ -90,7 +91,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
      */
     get hasCheckpointSequenceNumber() {
         // Valid to be called only if we have active connection.
-        (0, internal_1.assert)(this.connectionManager.connected, 0x0df /* "Missing active connection" */);
+        (0, internal_2.assert)(this.connectionManager.connected, 0x0df /* "Missing active connection" */);
         return this._checkpointSequenceNumber !== undefined;
     }
     // Forwarding connection manager properties / IDeltaManager implementation
@@ -129,12 +130,12 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         if (message === undefined) {
             return -1;
         }
-        (0, internal_1.assert)(isClientMessage(message), 0x419 /* client sends non-client message */);
+        (0, internal_2.assert)(isClientMessage(message), 0x419 /* client sends non-client message */);
         if (contents !== undefined) {
             this.opsSize += contents.length;
         }
         this.messageBuffer.push(message);
-        if (message.type === internal_2.MessageType.NoOp) {
+        if (message.type === internal_3.MessageType.NoOp) {
             this.noOpCount++;
         }
         this.emit("submitOp", message);
@@ -155,14 +156,14 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         // The prepareFlush event allows listeners to append metadata to the batch prior to submission.
         this.emit("prepareSend", batch);
         if (batch.length === 1) {
-            (0, internal_1.assert)(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
+            (0, internal_2.assert)(batch[0].metadata?.batch === undefined, 0x3c9 /* no batch markup on single message */);
         }
         else {
-            (0, internal_1.assert)(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
-            (0, internal_1.assert)(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
+            (0, internal_2.assert)(batch[0].metadata?.batch === true, 0x3ca /* no start batch markup */);
+            (0, internal_2.assert)(batch[batch.length - 1].metadata?.batch === false, 0x3cb /* no end batch markup */);
         }
         this.connectionManager.sendMessages(batch);
-        (0, internal_1.assert)(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
+        (0, internal_2.assert)(this.messageBuffer.length === 0, 0x3cc /* reentrancy */);
     }
     get connectionProps() {
         return {
@@ -179,7 +180,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
      * @param event - Event to log.
      */
     logConnectionIssue(event) {
-        (0, internal_1.assert)(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
+        (0, internal_2.assert)(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
         const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
         this.logger.sendTelemetryEvent({
             ...event,
@@ -205,7 +206,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
                 eventName: "DeltaManagerEventHandlerException",
                 name: typeof name === "string" ? name : undefined,
             }, error);
-            this.close((0, internal_4.normalizeError)(error));
+            this.close((0, internal_5.normalizeError)(error));
         });
         this.serviceProvider = serviceProvider;
         this.logger = logger;
@@ -256,7 +257,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
                 }
                 catch (error) {
                     this.logger.sendErrorEvent({ eventName: "EnqueueMessages_Exception" }, error);
-                    this.close((0, internal_4.normalizeError)(error));
+                    this.close((0, internal_5.normalizeError)(error));
                 }
             },
             signalHandler: (signals) => {
@@ -270,7 +271,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             connectHandler: (connection) => this.connectHandler(connection),
             pongHandler: (latency) => this.emit("pong", latency),
             readonlyChangeHandler: (readonly, readonlyConnectionReason) => {
-                (0, internal_4.safeRaiseEvent)(this, this.logger, "readonly", readonly, readonlyConnectionReason);
+                (0, internal_5.safeRaiseEvent)(this, this.logger, "readonly", readonly, readonlyConnectionReason);
             },
             establishConnectionHandler: (reason) => this.establishingConnection(reason),
             cancelConnectionHandler: (reason) => this.cancelEstablishingConnection(reason),
@@ -280,7 +281,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             this.processInboundMessage(op);
         });
         this._inbound.on("error", (error) => {
-            this.close(internal_4.DataProcessingError.wrapIfUnrecognized(error, "deltaManagerInboundErrorHandler", this.lastMessage));
+            this.close(internal_5.DataProcessingError.wrapIfUnrecognized(error, "deltaManagerInboundErrorHandler", this.lastMessage));
         });
         // Inbound signal queue
         this._inboundSignal = new deltaQueue_js_1.DeltaQueue((message) => {
@@ -289,11 +290,11 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             }
             this.handler.processSignal({
                 ...message,
-                content: JSON.parse(message.content),
+                content: (0, internal_1.JsonParse)(message.content),
             });
         });
         this._inboundSignal.on("error", (error) => {
-            this.close((0, internal_4.normalizeError)(error));
+            this.close((0, internal_5.normalizeError)(error));
         });
         // Initially, all queues are created paused.
         // - outbound is flipped back and forth in setupNewSuccessfulConnection / disconnectFromDeltaStream
@@ -320,7 +321,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         // but it's safe to assume (until better design is put into place) that batches should not exist
         // across multiple connections. Right now we assume runtime will not submit any ops in disconnected
         // state. As requirements change, so should these checks.
-        (0, internal_1.assert)(this.messageBuffer.length === 0, 0x0e9 /* "messageBuffer is not empty on new connection" */);
+        (0, internal_2.assert)(this.messageBuffer.length === 0, 0x0e9 /* "messageBuffer is not empty on new connection" */);
         this.opsSize = 0;
         this.noOpCount = 0;
         this.emit("connect", connection, checkpointSequenceNumber === undefined
@@ -354,16 +355,16 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         this.lastQueuedSequenceNumber = lastProcessedSequenceNumber;
         this.lastObservedSeqNumber = lastProcessedSequenceNumber;
         // We will use same check in other places to make sure all the seq number above are set properly.
-        (0, internal_1.assert)(this.handler === undefined, 0x0e2 /* "DeltaManager already has attached op handler!" */);
+        (0, internal_2.assert)(this.handler === undefined, 0x0e2 /* "DeltaManager already has attached op handler!" */);
         this.handler = handler;
         // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        (0, internal_1.assert)(!!this.handler, 0x0e3 /* "Newly set op handler is null/undefined!" */);
+        (0, internal_2.assert)(!!this.handler, 0x0e3 /* "Newly set op handler is null/undefined!" */);
         // There should be no pending fetch!
         // This API is called right after attachOpHandler by Container.load().
         // We might have connection already and it might have called fetchMissingDeltas() from
         // setupNewSuccessfulConnection. But it should do nothing, because there is no way to fetch ops before
         // we know snapshot sequence number that is set in attachOpHandler. So all such calls should be noop.
-        (0, internal_1.assert)(this.fetchReason === undefined, 0x268 /* "There can't be pending fetch that early in boot sequence!" */);
+        (0, internal_2.assert)(this.fetchReason === undefined, 0x268 /* "There can't be pending fetch that early in boot sequence!" */);
         if (this._closed) {
             return;
         }
@@ -382,7 +383,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             }
         }
         // Ensure there is no need to call this.processPendingOps() at the end of boot sequence
-        (0, internal_1.assert)(this.fetchReason !== undefined || this.pending.length === 0, 0x269 /* "pending ops are not dropped" */);
+        (0, internal_2.assert)(this.fetchReason !== undefined || this.pending.length === 0, 0x269 /* "pending ops are not dropped" */);
     }
     connect(args) {
         const fetchOpsFromStorage = args.fetchOpsFromStorage ?? true;
@@ -445,7 +446,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         const controller = new AbortController();
         let opsFromFetch = false;
         const opListener = (op) => {
-            (0, internal_1.assert)(op.sequenceNumber === this.lastQueuedSequenceNumber, 0x23a /* "seq#'s" */);
+            (0, internal_2.assert)(op.sequenceNumber === this.lastQueuedSequenceNumber, 0x23a /* "seq#'s" */);
             // Ops that are coming from this request should not cancel itself.
             // This is useless for known ranges (to is defined) as it means request is over either way.
             // And it will cancel unbound request too early, not allowing us to learn where the end of the file is.
@@ -456,7 +457,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         };
         try {
             this._inbound.on("push", opListener);
-            (0, internal_1.assert)(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
+            (0, internal_2.assert)(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
             this.closeAbortController.signal.addEventListener("abort", () => controller.abort(this.closeAbortController.signal.reason));
             const stream = this.deltaStorage.fetchMessages(from, // inclusive
             to, // exclusive
@@ -488,7 +489,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             // eslint-disable-next-line unicorn/no-null, unicorn/prefer-add-event-listener
             this.closeAbortController.signal.onabort = null;
             this._inbound.off("push", opListener);
-            (0, internal_1.assert)(!opsFromFetch, 0x289 /* "logic error" */);
+            (0, internal_2.assert)(!opsFromFetch, 0x289 /* "logic error" */);
         }
     }
     /**
@@ -520,8 +521,8 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         if (this._disposed) {
             return;
         }
-        if (error !== undefined && !(0, internal_4.isFluidError)(error)) {
-            throw new internal_4.UsageError("Error must be a Fluid error");
+        if (error !== undefined && !(0, internal_5.isFluidError)(error)) {
+            throw new internal_5.UsageError("Error must be a Fluid error");
         }
         this._disposed = true;
         this._closed = true; // We consider "disposed" as a further state than "closed"
@@ -594,7 +595,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         // It's responsibility of
         // - attachOpHandler()
         // - fetchMissingDeltas() after it's done with querying storage
-        (0, internal_1.assert)(this.pending.length === 0 || this.fetchReason !== undefined, 0x1e9 /* "Pending ops" */);
+        (0, internal_2.assert)(this.pending.length === 0 || this.fetchReason !== undefined, 0x1e9 /* "Pending ops" */);
         if (messages.length === 0) {
             return;
         }
@@ -660,7 +661,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         }
         this.updateLatestKnownOpSeqNumber(messages[messages.length - 1].sequenceNumber);
         const n = this.previouslyProcessedMessage?.sequenceNumber;
-        (0, internal_1.assert)(n === undefined || n === this.lastQueuedSequenceNumber, 0x0ec /* "Unexpected value for previously processed message's sequence number" */);
+        (0, internal_2.assert)(n === undefined || n === this.lastQueuedSequenceNumber, 0x0ec /* "Unexpected value for previously processed message's sequence number" */);
         for (const message of messages) {
             // Check that the messages are arriving in the expected order
             if (message.sequenceNumber <= this.lastQueuedSequenceNumber) {
@@ -670,7 +671,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
                     const message1 = this.comparableMessagePayload(this.previouslyProcessedMessage);
                     const message2 = this.comparableMessagePayload(message);
                     if (message1 !== message2) {
-                        const error = new internal_3.NonRetryableError(
+                        const error = new internal_4.NonRetryableError(
                         // This looks like a data corruption but the culprit was that the file was overwritten
                         // in storage.  See PR #5882.
                         // Likely to be an issue with Fluid Services. Content does not match previous client
@@ -679,7 +680,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
                         // instances such that the same sequence number is reused for two different ops.
                         // pre-0.58 error message: twoMessagesWithSameSeqNumAndDifferentPayload
                         "Found two messages with the same sequenceNumber but different payloads. Likely to be a " +
-                            "service issue", internal_2.DriverErrorTypes.fileOverwrittenInStorage, {
+                            "service issue", internal_3.DriverErrorTypes.fileOverwrittenInStorage, {
                             clientId: this.connectionManager.clientId,
                             sequenceNumber: message.sequenceNumber,
                             message1,
@@ -707,18 +708,18 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
     }
     processInboundMessage(message) {
         const startTime = Date.now();
-        (0, internal_1.assert)(!this.currentlyProcessingOps, 0x3af /* Already processing ops. */);
+        (0, internal_2.assert)(!this.currentlyProcessingOps, 0x3af /* Already processing ops. */);
         this.currentlyProcessingOps = true;
         this.lastProcessedMessage = message;
         const isString = typeof message.clientId === "string";
-        (0, internal_1.assert)(message.clientId === null || isString, 0x41a /* undefined or string */);
+        (0, internal_2.assert)(message.clientId === null || isString, 0x41a /* undefined or string */);
         // All client messages are coming from some client, and should have clientId,
         // and non-client message should not have clientId. But, there are two exceptions:
         // 1. (Legacy) We can see message.type === "attach" or "chunkedOp" for legacy files before RTM
         // 2. Non-immediate noops (contents: null) can be sent by service without clientId
-        if (!isString && isClientMessage(message) && message.type !== internal_2.MessageType.NoOp) {
-            throw new internal_4.DataCorruptionError("Mismatch in clientId", {
-                ...(0, internal_4.extractSafePropertiesFromMessage)(message),
+        if (!isString && isClientMessage(message) && message.type !== internal_3.MessageType.NoOp) {
+            throw new internal_5.DataCorruptionError("Mismatch in clientId", {
+                ...(0, internal_5.extractSafePropertiesFromMessage)(message),
                 messageType: message.type,
             });
         }
@@ -726,7 +727,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         // If the count ends up negative, that means we have a real gap and throw error
         if (this.connectionManager.clientId !== undefined &&
             this.connectionManager.clientId === message.clientId) {
-            if (message.type === internal_2.MessageType.NoOp) {
+            if (message.type === internal_3.MessageType.NoOp) {
                 this.noOpCount--;
             }
             const clientSeqNumGap = message.clientSequenceNumber - this.lastClientSequenceNumber - 1;
@@ -746,7 +747,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
             // something has changed out from under the file on the server, such that the service lost some ops
             // which this client already processed - the very ops that made this _next_ op to appear invalid.
             // In this case, only this client will fail (and lose this recent data), but others will be able to connect and continue.
-            throw internal_4.DataProcessingError.create(
+            throw internal_5.DataProcessingError.create(
             // error message through v0.57: msnMovesBackwards
             // error message through v2.1: "Found a lower minimumSequenceNumber (msn) than previously recorded",
             "Invalid MinimumSequenceNumber from service - document may have been restored to previous state", "DeltaManager.processInboundMessage", message, {
@@ -758,19 +759,19 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         // System ops (when no clients are connected) are the only ops where equation is possible.
         const diff = message.sequenceNumber - message.minimumSequenceNumber;
         if (diff < 0 || (diff === 0 && message.clientId !== null)) {
-            throw new internal_4.DataCorruptionError("MSN has to be lower than sequence #", (0, internal_4.extractSafePropertiesFromMessage)(message));
+            throw new internal_5.DataCorruptionError("MSN has to be lower than sequence #", (0, internal_5.extractSafePropertiesFromMessage)(message));
         }
         this.minSequenceNumber = message.minimumSequenceNumber;
         if (message.sequenceNumber !== this.lastProcessedSequenceNumber + 1) {
             // pre-0.58 error message: nonSequentialSequenceNumber
-            throw new internal_4.DataCorruptionError("Found a non-Sequential sequenceNumber", {
-                ...(0, internal_4.extractSafePropertiesFromMessage)(message),
+            throw new internal_5.DataCorruptionError("Found a non-Sequential sequenceNumber", {
+                ...(0, internal_5.extractSafePropertiesFromMessage)(message),
                 clientId: this.connectionManager.clientId,
             });
         }
         this.lastProcessedSequenceNumber = message.sequenceNumber;
         // a bunch of code assumes that this is true
-        (0, internal_1.assert)(this.lastProcessedSequenceNumber <= this.lastObservedSeqNumber, 0x267 /* "lastObservedSeqNumber should be updated first" */);
+        (0, internal_2.assert)(this.lastProcessedSequenceNumber <= this.lastObservedSeqNumber, 0x267 /* "lastObservedSeqNumber should be updated first" */);
         if (this.handler === undefined) {
             throw new Error("Attempted to process an inbound message without a handler attached");
         }
@@ -806,7 +807,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         }
         if (this.handler === undefined) {
             // We do not poses yet any information
-            (0, internal_1.assert)(this.lastQueuedSequenceNumber === 0, 0x26b /* "initial state" */);
+            (0, internal_2.assert)(this.lastQueuedSequenceNumber === 0, 0x26b /* "initial state" */);
             return;
         }
         try {
@@ -818,8 +819,8 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
                 // Knowing about this mechanism, we could ask for op we already observed to increase validation.
                 // This is especially useful when coming out of offline mode or loading from
                 // very old cached (by client / driver) snapshot.
-                (0, internal_1.assert)(n === this.lastQueuedSequenceNumber, 0x0f2 /* "previouslyProcessedMessage" */);
-                (0, internal_1.assert)(from > 1, 0x0f3 /* "not positive" */);
+                (0, internal_2.assert)(n === this.lastQueuedSequenceNumber, 0x0f2 /* "previouslyProcessedMessage" */);
+                (0, internal_2.assert)(from > 1, 0x0f3 /* "not positive" */);
                 from--;
             }
             const fetchReason = `${reason}_fetch`;
@@ -831,7 +832,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         }
         catch (error) {
             this.logger.sendErrorEvent({ eventName: "GetDeltas_Exception" }, error);
-            this.close((0, internal_4.normalizeError)(error));
+            this.close((0, internal_5.normalizeError)(error));
         }
         finally {
             this.refreshDelayInfo(this.deltaStorageDelayId);
@@ -846,7 +847,7 @@ class DeltaManager extends internal_4.EventEmitterWithErrorHandling {
         if (this._closed) {
             return;
         }
-        (0, internal_1.assert)(this.handler !== undefined, 0x26c /* "handler should be installed" */);
+        (0, internal_2.assert)(this.handler !== undefined, 0x26c /* "handler should be installed" */);
         const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
         this.pending = [];
         // Given that we do not track where these ops came from any more, it's not very