@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/dist/{odspDocumentDeltaConnection.js → odspDocumentDeltaConnection.cjs}

@@ -5,51 +5,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OdspDocumentDeltaConnection = void 0;
-const common_utils_1 = require("@fluidframework/common-utils");
-const driver_base_1 = require("@fluidframework/driver-base");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const client_utils_1 = require("@fluid-internal/client-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const driver_base_1 = require("@fluidframework/driver-base");
 const uuid_1 = require("uuid");
-const odspError_1 = require("./odspError");
-const packageVersion_1 = require("./packageVersion");
+const driver_utils_1 = require("@fluidframework/driver-utils");
+const odspError_1 = require("./odspError.cjs");
+const socketModule_1 = require("./socketModule.cjs");
+const packageVersion_1 = require("./packageVersion.cjs");
 const protocolVersions = ["^0.4.0", "^0.3.0", "^0.2.0", "^0.1.0"];
 const feature_get_ops = "api_get_ops";
 const feature_flush_ops = "api_flush_ops";
+const feature_submit_signals_v2 = "submit_signals_v2";
 // How long to wait before disconnecting the socket after the last reference is removed
 // This allows reconnection after receiving a nack to be smooth
 const socketReferenceBufferTime = 2000;
-class SocketReference extends common_utils_1.TypedEventEmitter {
-    constructor(key, socket) {
-        super();
-        this.key = key;
-        this.references = 1;
-        // When making decisions about socket reuse, we do not reuse disconnected socket.
-        // But we want to differentiate the following case from disconnected case:
-        // Socket that never connected and never failed, it's in "attempting to connect" mode
-        // such sockets should be reused, despite socket.disconnected === true
-        this.isPendingInitialConnection = true;
-        this._socket = socket;
-        (0, common_utils_1.assert)(!SocketReference.socketIoSockets.has(key), 0x220 /* "socket key collision" */);
-        SocketReference.socketIoSockets.set(key, this);
-        // The server always closes the socket after sending this message
-        // fully remove the socket reference now
-        socket.on("server_disconnect", (socketError) => {
-            // Treat all errors as recoverable, and rely on joinSession / reconnection flow to
-            // filter out retryable vs. non-retryable cases.
-            const error = (0, odspError_1.errorObjectFromSocketError)(socketError, "server_disconnect");
-            error.canRetry = true;
-            // see comment in disconnected() getter
-            // Setting it here to ensure socket reuse does not happen if new request to connect
-            // comes in from "disconnect" listener below, before we close socket.
-            this.isPendingInitialConnection = false;
-            // Explicitly cast error to the specified event args type to ensure type compatibility
-            this.emit("server_disconnect", error);
-            this.closeSocket();
-        });
-    }
+class SocketReference extends client_utils_1.TypedEventEmitter {
     static find(key, logger) {
         const socketReference = SocketReference.socketIoSockets.get(key);
         // Verify the socket is healthy before reusing it
-        if (socketReference === null || socketReference === void 0 ? void 0 : socketReference.disconnected) {
+        if (socketReference?.disconnected) {
             // The socket is in a bad state. fully remove the reference
             socketReference.closeSocket();
             return undefined;
@@ -64,22 +40,20 @@ class SocketReference extends common_utils_1.TypedEventEmitter {
     /**
      * Removes a reference for the given key
      * Once the ref count hits 0, the socket is disconnected and removed
-     * @param key - socket reference key
-     * @param isFatalError - true if the socket reference should be removed immediately due to a fatal error
      */
-    removeSocketIoReference(isFatalError) {
-        (0, common_utils_1.assert)(this.references > 0, 0x09f /* "No more socketIO refs to remove!" */);
+    removeSocketIoReference() {
+        (0, core_utils_1.assert)(this.references > 0, 0x09f /* "No more socketIO refs to remove!" */);
         this.references--;
         // see comment in disconnected() getter
         this.isPendingInitialConnection = false;
-        if (isFatalError || this.disconnected) {
+        if (this.disconnected) {
             this.closeSocket();
             return;
         }
         if (this.references === 0 && this.delayDeleteTimeout === undefined) {
             this.delayDeleteTimeout = setTimeout(() => {
                 // We should not get here with active users.
-                (0, common_utils_1.assert)(this.references === 0, 0x0a0 /* "Unexpected socketIO references on timeout" */);
+                (0, core_utils_1.assert)(this.references === 0, 0x0a0 /* "Unexpected socketIO references on timeout" */);
                 this.closeSocket();
             }, socketReferenceBufferTime);
         }
@@ -90,27 +64,68 @@ class SocketReference extends common_utils_1.TypedEventEmitter {
         }
         return this._socket;
     }
+    constructor(key, socket) {
+        super();
+        this.key = key;
+        this.references = 1;
+        // When making decisions about socket reuse, we do not reuse disconnected socket.
+        // But we want to differentiate the following case from disconnected case:
+        // Socket that never connected and never failed, it's in "attempting to connect" mode
+        // such sockets should be reused, despite socket.disconnected === true
+        this.isPendingInitialConnection = true;
+        this.serverDisconnectEventHandler = (socketError, clientId) => {
+            // Treat all errors as recoverable, and rely on joinSession / reconnection flow to
+            // filter out retryable vs. non-retryable cases.
+            const error = (0, odspError_1.errorObjectFromSocketError)(socketError, "server_disconnect");
+            error.addTelemetryProperties({ disconnectClientId: clientId });
+            error.canRetry = true;
+            // see comment in disconnected() getter
+            // Setting it here to ensure socket reuse does not happen if new request to connect
+            // comes in from "disconnect" listener below, before we close socket.
+            this.isPendingInitialConnection = false;
+            if (clientId === undefined) {
+                // We could first raise "disconnect" event, but that may result in socket reuse due to
+                // new connection comming in. So, it's better to have more explicit flow to make it impossible.
+                this.closeSocket(error);
+            }
+            else {
+                this.emit("disconnect", error, clientId);
+            }
+        };
+        this._socket = socket;
+        (0, core_utils_1.assert)(!SocketReference.socketIoSockets.has(key), 0x220 /* "socket key collision" */);
+        SocketReference.socketIoSockets.set(key, this);
+        // Server sends this event when it wants to disconnect a particular client in which case the client id would
+        // be present or if it wants to disconnect all the clients. The server always closes the socket in case all
+        // clients needs to be disconnected. So fully remove the socket reference in this case.
+        socket.on("server_disconnect", this.serverDisconnectEventHandler);
+    }
     clearTimer() {
         if (this.delayDeleteTimeout !== undefined) {
             clearTimeout(this.delayDeleteTimeout);
             this.delayDeleteTimeout = undefined;
         }
     }
-    closeSocket() {
+    closeSocket(error) {
         if (!this._socket) {
             return;
         }
+        this._socket.off("server_disconnect", this.serverDisconnectEventHandler);
         this.clearTimer();
-        (0, common_utils_1.assert)(SocketReference.socketIoSockets.get(this.key) === this, 0x0a1 /* "Socket reference set unexpectedly does not point to this socket!" */);
+        (0, core_utils_1.assert)(SocketReference.socketIoSockets.get(this.key) === this, 0x0a1 /* "Socket reference set unexpectedly does not point to this socket!" */);
+        // First, remove socket to ensure no socket reuse is possible.
         SocketReference.socketIoSockets.delete(this.key);
+        // Block access to socket. From now on, calls like flush() or requestOps()
+        // Disconnect flow should be synchronous and result in system fully forgetting about this connection / socket.
         const socket = this._socket;
         this._socket = undefined;
-        // Delay closing socket, to make sure all users of socket observe the same event that causes
-        // this instance to close, and thus properly record reason for closure.
-        // All event raising is synchronous, so clients will have a chance to react before socket is
-        // closed without any extra data on why it was closed.
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        Promise.resolve().then(() => { socket.disconnect(); });
+        // Let all connections know they need to go through disconnect flow.
+        this.emit("disconnect", error ??
+            (0, driver_utils_1.createGenericNetworkError)("Socket closed without error", { canRetry: true }, { driverVersion: packageVersion_1.pkgVersion }), undefined /* clientId */);
+        // We should not have any users now, assuming synchronous disconnect flow in response to
+        // "disconnect" event
+        (0, core_utils_1.assert)(this.references === 0, 0x412 /* Nobody should be connected to this socket at this point! */);
+        socket.disconnect();
     }
     get disconnected() {
         if (this._socket === undefined) {
@@ -135,25 +150,6 @@ SocketReference.socketIoSockets = new Map();
  * Represents a connection to a stream of delta updates
  */
 class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection {
-    /**
-     * @param socket - websocket to be used
-     * @param documentId - ID of the document
-     * @param details - details of the websocket connection
-     * @param socketReferenceKey - socket reference key
-     * @param enableMultiplexing - If the websocket is multiplexing multiple documents
-     */
-    constructor(socket, documentId, socketReference, logger, enableMultiplexing) {
-        super(socket, documentId, logger);
-        this.enableMultiplexing = enableMultiplexing;
-        this.pushCallCounter = 0;
-        this.getOpsMap = new Map();
-        this.serverDisconnectHandler = (error) => {
-            this.logger.sendTelemetryEvent({ eventName: "ServerDisconnect", clientId: this.clientId }, error);
-            this.disposeCore(true, error);
-        };
-        this.socketReference = socketReference;
-        this.requestOpsNoncePrefix = `${(0, uuid_1.v4)()}-`;
-    }
     /**
      * Create a OdspDocumentDeltaConnection
      * If url #1 fails to connect, will try url #2 if applicable.
@@ -161,7 +157,6 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
      * @param tenantId - the ID of the tenant
      * @param documentId - document ID
      * @param token - authorization token for storage service
-     * @param io - websocket library
      * @param client - information about the client
      * @param mode - mode of the client
      * @param url - websocket URL
@@ -170,7 +165,9 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
      * @param epochTracker - track epoch changes
      * @param socketReferenceKeyPrefix - (optional) prefix to isolate socket reuse cache
      */
-    static async create(tenantId, documentId, token, io, client, url, telemetryLogger, timeoutMs, epochTracker, socketReferenceKeyPrefix) {
+    static async create(tenantId, documentId, 
+    // eslint-disable-next-line @rushstack/no-new-null
+    token, client, url, telemetryLogger, timeoutMs, epochTracker, socketReferenceKeyPrefix) {
         const mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetryLogger);
         // enable multiplexing when the websocket url does not include the tenant/document id
         const parsedUrl = new URL(url);
@@ -179,8 +176,9 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
         // this will allow multiple documents to share the same websocket connection
         const key = socketReferenceKeyPrefix ? `${socketReferenceKeyPrefix},${url}` : url;
         const socketReferenceKey = enableMultiplexing ? key : `${key},${tenantId},${documentId}`;
-        const socketReference = OdspDocumentDeltaConnection.getOrCreateSocketIoReference(io, timeoutMs, socketReferenceKey, url, enableMultiplexing, tenantId, documentId, telemetryLogger);
+        const socketReference = OdspDocumentDeltaConnection.getOrCreateSocketIoReference(timeoutMs, socketReferenceKey, url, enableMultiplexing, tenantId, documentId, telemetryLogger);
         const socket = socketReference.socket;
+        const connectionId = (0, uuid_1.v4)();
         const connectMessage = {
             client,
             id: documentId,
@@ -188,19 +186,22 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
             tenantId,
             token,
             versions: protocolVersions,
-            nonce: (0, uuid_1.v4)(),
+            driverVersion: packageVersion_1.pkgVersion,
+            nonce: connectionId,
             epoch: epochTracker.fluidEpoch,
             relayUserAgent: [client.details.environment, ` driverVersion:${packageVersion_1.pkgVersion}`].join(";"),
         };
+        connectMessage.supportedFeatures = {
+            [feature_submit_signals_v2]: true,
+        };
         // Reference to this client supporting get_ops flow.
-        connectMessage.supportedFeatures = {};
         if (mc.config.getBoolean("Fluid.Driver.Odsp.GetOpsEnabled") !== false) {
             connectMessage.supportedFeatures[feature_get_ops] = true;
         }
-        const deltaConnection = new OdspDocumentDeltaConnection(socket, documentId, socketReference, telemetryLogger, enableMultiplexing);
+        const deltaConnection = new OdspDocumentDeltaConnection(socket, documentId, socketReference, telemetryLogger, enableMultiplexing, connectionId);
         try {
             await deltaConnection.initialize(connectMessage, timeoutMs);
-            await epochTracker.validateEpochFromPush(deltaConnection.details);
+            await epochTracker.validateEpoch(deltaConnection.details.epoch, "push");
         }
         catch (errorObject) {
             if (errorObject !== null && typeof errorObject === "object") {
@@ -232,23 +233,20 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
         // Note: we suspect the incoming error object is either:
         // - a socketError: add it to the OdspError object for driver to be able to parse it and reason over it.
         // - anything else: let base class handle it
-        if (canRetry && Number.isInteger(error === null || error === void 0 ? void 0 : error.code) && typeof (error === null || error === void 0 ? void 0 : error.message) === "string") {
-            return (0, odspError_1.errorObjectFromSocketError)(error, handler);
-        }
-        else {
-            return super.createErrorObject(handler, error, canRetry);
-        }
+        return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
+            ? (0, odspError_1.errorObjectFromSocketError)(error, handler)
+            : super.createErrorObject(handler, error, canRetry);
     }
     /**
      * Gets or create a socket io connection for the given key
      */
-    static getOrCreateSocketIoReference(io, timeoutMs, key, url, enableMultiplexing, tenantId, documentId, logger) {
+    static getOrCreateSocketIoReference(timeoutMs, key, url, enableMultiplexing, tenantId, documentId, logger) {
         const existingSocketReference = SocketReference.find(key, logger);
         if (existingSocketReference) {
             return existingSocketReference;
         }
         const query = enableMultiplexing ? undefined : { documentId, tenantId };
-        const socket = io(url, {
+        const socket = (0, socketModule_1.SocketIOClientStatic)(url, {
             multiplex: false,
             query,
             reconnection: false,
@@ -257,6 +255,33 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
         });
         return new SocketReference(key, socket);
     }
+    /**
+     * @param socket - websocket to be used
+     * @param documentId - ID of the document
+     * @param details - details of the websocket connection
+     * @param socketReferenceKey - socket reference key
+     * @param enableMultiplexing - If the websocket is multiplexing multiple documents
+     */
+    constructor(socket, documentId, socketReference, logger, enableMultiplexing, connectionId) {
+        super(socket, documentId, logger, false, connectionId);
+        this.enableMultiplexing = enableMultiplexing;
+        this.pushCallCounter = 0;
+        this.getOpsMap = new Map();
+        this.disconnectHandler = (error, clientId) => {
+            if (clientId === undefined || clientId === this.clientId) {
+                this.logger.sendTelemetryEvent({
+                    eventName: "ServerDisconnect",
+                    driverVersion: packageVersion_1.pkgVersion,
+                    details: JSON.stringify({
+                        ...this.getConnectionDetailsProps(),
+                    }),
+                }, error);
+                this.disconnect(error);
+            }
+        };
+        this.socketReference = socketReference;
+        this.requestOpsNoncePrefix = `${(0, uuid_1.v4)()}-`;
+    }
     /**
      * Retrieves ops from PUSH
      * @param from - inclusive
@@ -264,17 +289,17 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
      * @returns ops retrieved
      */
     requestOps(from, to) {
-        var _a;
+        (0, core_utils_1.assert)(!this.socketReference?.disconnected, 0x413 /* non-active socket */);
         // Given that to is exclusive, we should be asking for at least something!
-        (0, common_utils_1.assert)(to > from, 0x272 /* "empty request" */);
+        (0, core_utils_1.assert)(to > from, 0x272 /* "empty request" */);
         // PUSH may disable this functionality
         // back-compat: remove cast to any once latest version of IConnected is consumed
-        if (((_a = this.details.supportedFeatures) === null || _a === void 0 ? void 0 : _a[feature_get_ops]) !== true) {
+        if (this.details.supportedFeatures?.[feature_get_ops] !== true) {
             return;
         }
         this.pushCallCounter++;
         const nonce = `${this.requestOpsNoncePrefix}${this.pushCallCounter}`;
-        const start = common_utils_1.performance.now();
+        const start = client_utils_1.performance.now();
         // We may keep keep accumulating memory for nothing, if we are not getting responses.
         // Note that we should not have overlapping requests, as DeltaManager allows only one
         // outstanding request to storage, and that's the only way to get here.
@@ -298,7 +323,7 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
                 from: payloadToDelete.from,
                 to: payloadToDelete.to,
                 length: payloadToDelete.to - payloadToDelete.from,
-                duration: common_utils_1.performance.now() - payloadToDelete.start,
+                duration: client_utils_1.performance.now() - payloadToDelete.start,
             });
             this.getOpsMap.delete(key);
         }
@@ -314,9 +339,9 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
         });
     }
     async flush() {
-        var _a;
+        (0, core_utils_1.assert)(!this.socketReference?.disconnected, 0x414 /* non-active socket */);
         // back-compat: remove cast to any once latest version of IConnected is consumed
-        if (((_a = this.details.supportedFeatures) === null || _a === void 0 ? void 0 : _a[feature_flush_ops]) !== true) {
+        if (this.details.supportedFeatures?.[feature_flush_ops] !== true) {
             // Once single-commit summary is enabled end-to-end, flush support is a must!
             // The only alternative is change in design where SPO fetches ops from PUSH OR
             // summary includes required ops and SPO has some validation mechanism to ensure
@@ -336,10 +361,11 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
         }
         this.socket.emit("flush_ops", this.clientId, { nonce });
         this.flushOpNonce = nonce;
-        this.flushDeferred = new common_utils_1.Deferred();
+        this.flushDeferred = new core_utils_1.Deferred();
         return this.flushDeferred.promise;
     }
     async initialize(connectMessage, timeout) {
+        (0, core_utils_1.assert)(!this.socketReference?.disconnected, 0x415 /* non-active socket */);
         if (this.enableMultiplexing) {
             // multiplex compatible early handlers
             this.earlyOpHandler = (messageDocumentId, msgs) => {
@@ -349,39 +375,52 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
             };
             this.earlySignalHandler = (msg, messageDocumentId) => {
                 if (messageDocumentId === undefined || messageDocumentId === this.documentId) {
-                    this.queuedSignals.push(msg);
+                    if (Array.isArray(msg)) {
+                        this.queuedSignals.push(...msg);
+                    }
+                    else {
+                        this.queuedSignals.push(msg);
+                    }
                 }
             };
         }
-        this.socketReference.on("server_disconnect", this.serverDisconnectHandler);
-        this.socket.on("get_ops_response", (result) => {
+        this.socketReference.on("disconnect", this.disconnectHandler);
+        this.addTrackedListener("get_ops_response", (result) => {
             const messages = result.messages;
             const data = this.getOpsMap.get(result.nonce);
             // Due to socket multiplexing, this client may not have asked for any data
             // If so, there it most likely does not need these ops (otherwise it already asked for them)
             // Also we may have deleted entry in this.getOpsMap due to too many requests and too slow response.
             // But not processing such result may push us into infinite loop of fast requests and dropping all responses
-            if (data !== undefined || result.nonce.indexOf(this.requestOpsNoncePrefix) === 0) {
+            if (data !== undefined || result.nonce.startsWith(this.requestOpsNoncePrefix)) {
                 this.getOpsMap.delete(result.nonce);
                 const common = {
                     eventName: "GetOps",
                     // We need nonce only to pair with GetOpsTooMany events, i.e. when record was deleted
                     nonce: data === undefined ? result.nonce : undefined,
                     code: result.code,
-                    from: data === null || data === void 0 ? void 0 : data.from,
-                    to: data === null || data === void 0 ? void 0 : data.to,
-                    duration: data === undefined ? undefined : common_utils_1.performance.now() - data.start,
+                    from: data?.from,
+                    to: data?.to,
+                    duration: data === undefined ? undefined : client_utils_1.performance.now() - data.start,
                 };
                 if (messages !== undefined && messages.length > 0) {
-                    this.logger.sendPerformanceEvent(Object.assign(Object.assign({}, common), { first: messages[0].sequenceNumber, last: messages[messages.length - 1].sequenceNumber, length: messages.length }));
+                    this.logger.sendPerformanceEvent({
+                        ...common,
+                        first: messages[0].sequenceNumber,
+                        last: messages[messages.length - 1].sequenceNumber,
+                        length: messages.length,
+                    });
                     this.emit("op", this.documentId, messages);
                 }
                 else {
-                    this.logger.sendPerformanceEvent(Object.assign(Object.assign({}, common), { length: 0 }));
+                    this.logger.sendPerformanceEvent({
+                        ...common,
+                        length: 0,
+                    });
                 }
             }
         });
-        this.socket.on("flush_ops_response", (result) => {
+        this.addTrackedListener("flush_ops_response", (result) => {
             if (this.flushOpNonce === result.nonce) {
                 const seq = result.lastPersistedSequenceNumber;
                 let category = "generic";
@@ -409,7 +448,12 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
                 this.flushOpNonce = undefined;
             }
         });
-        await super.initialize(connectMessage, timeout);
+        await super.initialize(connectMessage, timeout).finally(() => {
+            this.logger.sendTelemetryEvent({
+                eventName: "ConnectionAttemptInfo",
+                ...this.getConnectionDetailsProps(),
+            });
+        });
     }
     addTrackedListener(event, listener) {
         // override some event listeners in order to support multiple documents/clients over the same websocket
@@ -425,7 +469,9 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
             case "signal":
                 // per document signal handling
                 super.addTrackedListener(event, (msg, documentId) => {
-                    if (!this.enableMultiplexing || !documentId || documentId === this.documentId) {
+                    if (!this.enableMultiplexing ||
+                        !documentId ||
+                        documentId === this.documentId) {
                         listener(msg, documentId);
                     }
                 });
@@ -433,11 +479,11 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
             case "nack":
                 // per client / document nack handling
                 super.addTrackedListener(event, (clientIdOrDocumentId, nacks) => {
-                    var _a, _b;
                     const handle = clientIdOrDocumentId.length === 0 ||
                         clientIdOrDocumentId === this.documentId ||
-                        (clientIdOrDocumentId === this.clientId);
-                    const { code, type, message, retryAfter } = (_b = (_a = nacks[0]) === null || _a === void 0 ? void 0 : _a.content) !== null && _b !== void 0 ? _b : {};
+                        clientIdOrDocumentId === this.clientId;
+                    const { code, type, message, retryAfter } = nacks[0]?.content ?? {};
+                    const { clientSequenceNumber, referenceSequenceNumber } = nacks[0]?.operation ?? {};
                     this.logger.sendTelemetryEvent({
                         eventName: "ServerNack",
                         code,
@@ -446,6 +492,9 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
                         retryAfterSeconds: retryAfter,
                         clientId: this.clientId,
                         handle,
+                        clientSequenceNumber,
+                        referenceSequenceNumber,
+                        opType: nacks[0]?.operation?.type,
                     });
                     if (handle) {
                         this.emit("nack", clientIdOrDocumentId, nacks);
@@ -457,22 +506,84 @@ class OdspDocumentDeltaConnection extends driver_base_1.DocumentDeltaConnection
                 break;
         }
     }
+    get disposed() {
+        if (!(this._disposed || this.socket.connected)) {
+            // Send error event if this connection is not yet disposed after socket is disconnected for 15s.
+            if (this.connectionNotYetDisposedTimeout === undefined) {
+                this.connectionNotYetDisposedTimeout = setTimeout(() => {
+                    if (!this._disposed) {
+                        this.logger.sendErrorEvent({
+                            eventName: "ConnectionNotYetDisposed",
+                            driverVersion: packageVersion_1.pkgVersion,
+                            details: JSON.stringify({
+                                ...this.getConnectionDetailsProps(),
+                            }),
+                        });
+                    }
+                }, 15000);
+            }
+        }
+        return this._disposed;
+    }
+    /**
+     * Returns true in case the connection is not yet disposed and the socket is also connected. The expectation is
+     * that it will be called only after connection is fully established. i.e. there should no way to submit an op
+     * while we are connecting, as connection object is not exposed to Loader layer until connection is established.
+     */
+    get connected() {
+        return !this.disposed && this.socket.connected;
+    }
+    emitMessages(type, messages) {
+        // Only submit the op/signals if we are connected.
+        if (this.connected) {
+            this.socket.emit(type, this.clientId, messages);
+        }
+    }
+    /**
+     * Submits a new delta operation to the server
+     * @param message - delta operation to submit
+     */
+    submit(messages) {
+        this.emitMessages("submitOp", [messages]);
+    }
+    /**
+     * Submits a new signal to the server
+     *
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitSignal(content, targetClientId) {
+        const signal = {
+            content,
+            targetClientId,
+        };
+        // back-compat: the typing for this method and emitMessages is incorrect, will be fixed in a future PR
+        this.emitMessages("submitSignal", [signal]);
+    }
+    /**
+     * Critical path where we need to also close the socket for an error.
+     * @param error - Error causing the socket to close.
+     */
+    closeSocketCore(error) {
+        const socket = this.socketReference;
+        (0, core_utils_1.assert)(socket !== undefined, 0x416 /* reentrancy not supported in close socket */);
+        socket.closeSocket(error);
+        (0, core_utils_1.assert)(this.socketReference === undefined, 0x417 /* disconnect flow did not work correctly */);
+    }
     /**
      * Disconnect from the websocket
      */
-    disconnect(socketProtocolError, reason) {
-        var _a;
+    disconnectCore() {
         const socket = this.socketReference;
-        (0, common_utils_1.assert)(socket !== undefined, 0x0a2 /* "reentrancy not supported!" */);
-        (_a = this.socketReference) === null || _a === void 0 ? void 0 : _a.off("server_disconnect", this.serverDisconnectHandler);
+        (0, core_utils_1.assert)(socket !== undefined, 0x0a2 /* "reentrancy not supported!" */);
         this.socketReference = undefined;
-        if (!socketProtocolError && this.hasDetails) {
+        socket.off("disconnect", this.disconnectHandler);
+        if (this.hasDetails) {
             // tell the server we are disconnecting this client from the document
             this.socket.emit("disconnect_document", this.clientId, this.documentId);
         }
-        socket.removeSocketIoReference(socketProtocolError);
-        this.emit("disconnect", reason);
+        socket.removeSocketIoReference();
     }
 }
 exports.OdspDocumentDeltaConnection = OdspDocumentDeltaConnection;
-//# sourceMappingURL=odspDocumentDeltaConnection.js.map
+//# sourceMappingURL=odspDocumentDeltaConnection.cjs.map