@replit/river 0.23.7 → 0.23.9

package/dist/{transport-3d34f714.d.ts → transport-3d0ba1da.d.ts}

@@ -77,7 +77,7 @@ interface SessionOptions {
 declare class Session<ConnType extends Connection> {
     private codec;
     private options;
-    telemetry: TelemetryInfo;
+    readonly telemetry: TelemetryInfo;
     /**
      * The buffer of messages that have been sent but not yet acknowledged.
      */
@@ -86,12 +86,17 @@ declare class Session<ConnType extends Connection> {
      * The active connection associated with this session
      */
     connection?: ConnType;
+    /**
+     * A connection that is currently undergoing handshaking. Used to distinguish between the active
+     * connection, but still be able to close it if needed.
+     */
+    private handshakingConnection?;
     readonly from: TransportClientId;
     readonly to: TransportClientId;
     /**
      * The unique ID of this session.
      */
-    id: string;
+    readonly id: string;
     /**
      * What the other side advertised as their session ID
      * for this session.
@@ -135,10 +140,17 @@ declare class Session<ConnType extends Connection> {
     resetBufferedMessages(): void;
     sendBufferedMessages(conn: ConnType): void;
     updateBookkeeping(ack: number, seq: number): void;
-    closeStaleConnection(conn?: ConnType): void;
+    private closeStaleConnection;
     replaceWithNewConnection(newConn: ConnType): void;
+    replaceWithNewHandshakingConnection(newConn: ConnType): void;
     beginGrace(cb: () => void): void;
-    cancelGrace(): void;
+    cancelGrace({ keepHeartbeatMisses }?: {
+        keepHeartbeatMisses: boolean;
+    }): void;
+    /**
+     * Used to close the handshaking connection, if set.
+     */
+    closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
     close(): void;
     get connected(): boolean;
     get nextExpectedSeq(): number;
@@ -419,11 +431,21 @@ declare abstract class Transport<ConnType extends Connection> {
      */
     protected onConnect(conn: ConnType, connectedTo: TransportClientId, session: Session<ConnType>, isReconnect: boolean): void;
     protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
-    protected getOrCreateSession(to: TransportClientId, conn?: ConnType, sessionId?: string, propagationCtx?: PropagationContext): {
+    protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn?: ConnType;
+        handshakingConn?: ConnType;
+        sessionId?: string;
+        propagationCtx?: PropagationContext;
+    }): {
         session: Session<ConnType>;
         isReconnect: boolean;
     };
-    protected deleteSession(session: Session<ConnType>): void;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
     /**
      * The downstream implementation needs to call this when a connection is closed.
      * @param conn The connection object.
@@ -515,7 +537,11 @@ declare abstract class ClientTransport<ConnType extends Connection> extends Tran
      * @param to The client ID of the node to connect to.
      */
     connect(to: TransportClientId): Promise<void>;
-    protected deleteSession(session: Session<ConnType>): void;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
     protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
     close(): void;
 }

package/dist/util/testHelpers.cjs

@@ -353,7 +353,7 @@ function Err(error) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.7";
+var version = "0.23.9";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(session, propagationCtx) {
@@ -403,6 +403,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;
   /**
@@ -582,23 +587,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() {