@replit/river 0.23.8 → 0.23.10

package/dist/transport/impls/ws/client.cjs

@@ -162,11 +162,13 @@ var createLogProxy = (log) => ({
 var ProtocolError = {
   RetriesExceeded: "conn_retry_exceeded",
   HandshakeFailed: "handshake_failed",
-  UseAfterDestroy: "use_after_destroy",
   MessageOrderingViolated: "message_ordering_violated"
 };
 var EventDispatcher = class {
   eventListeners = {};
+  removeAllListeners() {
+    this.eventListeners = {};
+  }
   numberOfListeners(eventType) {
     return this.eventListeners[eventType]?.size ?? 0;
   }
@@ -185,7 +187,8 @@ var EventDispatcher = class {
   dispatchEvent(eventType, event) {
     const handlers = this.eventListeners[eventType];
     if (handlers) {
-      for (const handler of handlers) {
+      const copy = [...handlers];
+      for (const handler of copy) {
         handler(event);
       }
     }
@@ -199,7 +202,7 @@ var import_nanoid2 = require("nanoid");
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.8";
+var version = "0.23.10";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -258,7 +261,7 @@ var Connection = class {
   get loggingMetadata() {
     const metadata = { connId: this.id };
     const spanContext = this.telemetry?.span.spanContext();
-    if (spanContext) {
+    if (this.telemetry?.span.isRecording() && spanContext) {
       metadata.telemetry = {
         traceId: spanContext.traceId,
         spanId: spanContext.spanId
@@ -279,6 +282,11 @@ var Session = class {
    * The active connection associated with this session
    */
   connection;
+  /**
+   * A connection that is currently undergoing handshaking. Used to distinguish between the active
+   * connection, but still be able to close it if needed.
+   */
+  handshakingConnection;
   from;
   to;
   /**
@@ -458,23 +466,60 @@ var Session = class {
     this.cancelGrace();
     this.sendBufferedMessages(newConn);
     this.connection = newConn;
+    this.handshakingConnection = void 0;
+  }
+  replaceWithNewHandshakingConnection(newConn) {
+    this.handshakingConnection = newConn;
   }
   beginGrace(cb) {
     this.log?.info(
       `starting ${this.options.sessionDisconnectGraceMs}ms grace period until session to ${this.to} is closed`,
       this.loggingMetadata
     );
+    this.cancelGrace({ keepHeartbeatMisses: true });
     this.disconnectionGrace = setTimeout(() => {
-      this.close();
+      if (this.connection !== void 0) {
+        this.log?.warn(
+          `grace period for ${this.to} elapsed while connected. not calling callback`,
+          {
+            ...this.loggingMetadata,
+            connId: this.connection.id,
+            tags: ["invariant-violation"]
+          }
+        );
+        return;
+      }
+      this.log?.info(
+        `grace period for ${this.to} elapsed`,
+        this.loggingMetadata
+      );
       cb();
     }, this.options.sessionDisconnectGraceMs);
   }
   // called on reconnect of the underlying session
-  cancelGrace() {
-    this.heartbeatMisses = 0;
+  cancelGrace({ keepHeartbeatMisses } = {
+    keepHeartbeatMisses: false
+  }) {
+    if (!keepHeartbeatMisses) {
+      this.heartbeatMisses = 0;
+    }
+    if (this.disconnectionGrace === void 0)
+      return;
     clearTimeout(this.disconnectionGrace);
     this.disconnectionGrace = void 0;
   }
+  /**
+   * Used to close the handshaking connection, if set.
+   */
+  closeHandshakingConnection(expectedHandshakingConn) {
+    if (this.handshakingConnection === void 0)
+      return;
+    if (expectedHandshakingConn !== void 0 && this.handshakingConnection === expectedHandshakingConn) {
+      return;
+    }
+    this.handshakingConnection.close();
+    this.handshakingConnection = void 0;
+  }
   // closed when we want to discard the whole session
   // (i.e. shutdown or session disconnect)
   close() {
@@ -662,10 +707,9 @@ var defaultServerTransportOptions = {
 };
 var Transport = class {
   /**
-   * A flag indicating whether the transport has been destroyed.
-   * A destroyed transport will not attempt to reconnect and cannot be used again.
+   * The status of the transport.
    */
-  state;
+  status;
   /**
    * The {@link Codec} used to encode and decode messages.
    */
@@ -707,7 +751,7 @@ var Transport = class {
     this.sessions = /* @__PURE__ */ new Map();
     this.codec = this.options.codec;
     this.clientId = clientId;
-    this.state = "open";
+    this.status = "open";
   }
   bindLogger(fn, level) {
     if (typeof fn === "function") {
@@ -755,7 +799,13 @@ var Transport = class {
     });
     return session;
   }
-  getOrCreateSession(to, conn, sessionId, propagationCtx) {
+  getOrCreateSession({
+    to,
+    conn,
+    handshakingConn,
+    sessionId,
+    propagationCtx
+  }) {
     let session = this.sessions.get(to);
     let isReconnect = session !== void 0;
     if (session?.advertisedSessionId !== void 0 && sessionId !== void 0 && session.advertisedSessionId !== sessionId) {
@@ -763,7 +813,11 @@ var Transport = class {
         `session for ${to} already exists but has a different session id (expected: ${session.advertisedSessionId}, got: ${sessionId}), creating a new one`,
         session.loggingMetadata
       );
-      this.deleteSession(session);
+      this.deleteSession({
+        session,
+        closeHandshakingConnection: handshakingConn !== void 0,
+        handshakingConn
+      });
       isReconnect = false;
       session = void 0;
     }
@@ -777,9 +831,19 @@ var Transport = class {
     if (sessionId !== void 0) {
       session.advertisedSessionId = sessionId;
     }
+    if (handshakingConn !== void 0) {
+      session.replaceWithNewHandshakingConnection(handshakingConn);
+    }
     return { session, isReconnect };
   }
-  deleteSession(session) {
+  deleteSession({
+    session,
+    closeHandshakingConnection,
+    handshakingConn
+  }) {
+    if (closeHandshakingConnection) {
+      session.closeHandshakingConnection(handshakingConn);
+    }
     session.close();
     session.telemetry.span.end();
     this.sessions.delete(session.to);
@@ -806,7 +870,11 @@ var Transport = class {
     session.connection = void 0;
     session.beginGrace(() => {
       session.telemetry.span.addEvent("session grace period expired");
-      this.deleteSession(session);
+      this.deleteSession({
+        session,
+        closeHandshakingConnection: true,
+        handshakingConn: conn
+      });
     });
   }
   /**
@@ -845,7 +913,7 @@ var Transport = class {
    * @param msg The received message.
    */
   handleMsg(msg, conn) {
-    if (this.state !== "open")
+    if (this.getStatus() !== "open")
       return;
     const session = this.sessions.get(msg.from);
     if (!session) {
@@ -886,7 +954,7 @@ var Transport = class {
           code: import_api3.SpanStatusCode.ERROR,
           message: "message order violated"
         });
-        session.close();
+        this.deleteSession({ session, closeHandshakingConnection: true });
       }
       return;
     }
@@ -924,23 +992,16 @@ var Transport = class {
    * @returns The ID of the sent message or undefined if it wasn't sent
    */
   send(to, msg) {
-    if (this.state === "destroyed") {
-      const err = "transport is destroyed, cant send";
+    if (this.getStatus() === "closed") {
+      const err = "transport is closed, cant send";
       this.log?.error(err, {
         clientId: this.clientId,
         transportMessage: msg,
         tags: ["invariant-violation"]
       });
-      this.protocolError(ProtocolError.UseAfterDestroy, err);
-      return void 0;
-    } else if (this.state === "closed") {
-      this.log?.info(`transport closed when sending, discarding`, {
-        clientId: this.clientId,
-        transportMessage: msg
-      });
-      return void 0;
+      throw new Error(err);
     }
-    return this.getOrCreateSession(to).session.send(msg);
+    return this.getOrCreateSession({ to }).session.send(msg);
   }
   // control helpers
   sendCloseStream(to, streamId) {
@@ -961,23 +1022,18 @@ var Transport = class {
    * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
    */
   close() {
-    this.state = "closed";
+    this.status = "closed";
     for (const session of this.sessions.values()) {
-      this.deleteSession(session);
+      this.deleteSession({ session, closeHandshakingConnection: true });
     }
+    this.eventDispatcher.dispatchEvent("transportStatus", {
+      status: this.status
+    });
+    this.eventDispatcher.removeAllListeners();
     this.log?.info(`manually closed transport`, { clientId: this.clientId });
   }
-  /**
-   * Default destroy implementation for transports. You should override this in the downstream
-   * implementation if you need to do any additional cleanup and call super.destroy() at the end.
-   * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
-   */
-  destroy() {
-    this.state = "destroyed";
-    for (const session of this.sessions.values()) {
-      this.deleteSession(session);
-    }
-    this.log?.info(`manually destroyed transport`, { clientId: this.clientId });
+  getStatus() {
+    return this.status;
   }
 };
 var ClientTransport = class extends Transport {
@@ -1014,26 +1070,26 @@ var ClientTransport = class extends Transport {
     this.handshakeExtensions = options;
   }
   handleConnection(conn, to) {
-    if (this.state !== "open")
+    if (this.getStatus() !== "open")
       return;
     let session = void 0;
     const handshakeTimeout = setTimeout(() => {
-      if (!session) {
-        this.log?.warn(
-          `connection to ${to} timed out waiting for handshake, closing`,
-          { ...conn.loggingMetadata, clientId: this.clientId, connectedTo: to }
-        );
-        conn.close();
-      }
+      if (session)
+        return;
+      this.log?.warn(
+        `connection to ${to} timed out waiting for handshake, closing`,
+        { ...conn.loggingMetadata, clientId: this.clientId, connectedTo: to }
+      );
+      conn.close();
     }, this.options.sessionDisconnectGraceMs);
     const handshakeHandler = (data) => {
       const maybeSession = this.receiveHandshakeResponseMessage(data, conn);
+      clearTimeout(handshakeTimeout);
       if (!maybeSession) {
         conn.close();
         return;
       } else {
         session = maybeSession;
-        clearTimeout(handshakeTimeout);
       }
       conn.removeDataListener(handshakeHandler);
       conn.addDataListener((data2) => {
@@ -1140,11 +1196,11 @@ var ClientTransport = class extends Transport {
       connectedTo: parsed.from,
       transportMessage: parsed
     });
-    const { session, isReconnect } = this.getOrCreateSession(
-      parsed.from,
+    const { session, isReconnect } = this.getOrCreateSession({
+      to: parsed.from,
       conn,
-      parsed.payload.status.sessionId
-    );
+      sessionId: parsed.payload.status.sessionId
+    });
     this.onConnect(conn, parsed.from, session, isReconnect);
     this.retryBudget.startRestoringBudget(parsed.from);
     return session;
@@ -1154,7 +1210,7 @@ var ClientTransport = class extends Transport {
    * @param to The client ID of the node to connect to.
    */
   async connect(to) {
-    const canProceedWithConnection = () => this.state === "open";
+    const canProceedWithConnection = () => this.getStatus() === "open";
     if (!canProceedWithConnection()) {
       this.log?.info(
         `transport state is no longer open, cancelling attempt to connect to ${to}`,
@@ -1250,9 +1306,17 @@ var ClientTransport = class extends Transport {
       }
     }
   }
-  deleteSession(session) {
+  deleteSession({
+    session,
+    closeHandshakingConnection,
+    handshakingConn
+  }) {
     this.inflightConnectionPromises.delete(session.to);
-    super.deleteSession(session);
+    super.deleteSession({
+      session,
+      closeHandshakingConnection,
+      handshakingConn
+    });
   }
   async sendHandshake(to, conn) {
     let metadata = void 0;
@@ -1279,7 +1343,7 @@ var ClientTransport = class extends Transport {
         return false;
       }
     }
-    const { session } = this.getOrCreateSession(to);
+    const { session } = this.getOrCreateSession({ to, handshakingConn: conn });
     const requestMsg = handshakeRequestMessage(
       this.clientId,
       to,
@@ -1391,6 +1455,9 @@ var WebSocketClientTransport = class extends ClientTransport {
       ws.onclose = (evt) => {
         reject(new Error(evt.reason));
       };
+      ws.onerror = (err) => {
+        reject(new Error(err.message));
+      };
     });
     const conn = new WebSocketConnection(ws);
     this.log?.info(`raw websocket to ${to} ok, starting handshake`, {