@replit/river 0.23.13 → 0.23.14

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

@@ -59,6 +59,21 @@ var ControlMessageHandshakeRequestSchema = import_typebox.Type.Object({
   type: import_typebox.Type.Literal("HANDSHAKE_REQ"),
   protocolVersion: import_typebox.Type.String(),
   sessionId: import_typebox.Type.String(),
+  /**
+   * Specifies what the server's expected session state (from the pov of the client). This can be
+   * used by the server to know whether this is a new or a reestablished connection, and whether it
+   * is compatible with what it already has.
+   */
+  expectedSessionState: import_typebox.Type.Optional(
+    import_typebox.Type.Object({
+      /**
+       * reconnect is set to true if the client explicitly wants to reestablish an existing
+       * connection.
+       */
+      reconnect: import_typebox.Type.Boolean(),
+      nextExpectedSeq: import_typebox.Type.Integer()
+    })
+  ),
   metadata: import_typebox.Type.Optional(import_typebox.Type.Unknown())
 });
 var ControlMessageHandshakeResponseSchema = import_typebox.Type.Object({
@@ -83,7 +98,14 @@ var ControlMessagePayloadSchema = import_typebox.Type.Union([
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox.Type.Unknown()
 );
-function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
+function handshakeRequestMessage({
+  from,
+  to,
+  sessionId,
+  expectedSessionState,
+  metadata,
+  tracing
+}) {
   return {
     id: (0, import_nanoid.nanoid)(),
     from,
@@ -97,10 +119,12 @@ function handshakeRequestMessage(from, to, sessionId, metadata, tracing) {
       type: "HANDSHAKE_REQ",
       protocolVersion: PROTOCOL_VERSION,
       sessionId,
+      expectedSessionState,
       metadata
     }
   };
 }
+var SESSION_STATE_MISMATCH = "session state mismatch";
 function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
 }
@@ -350,7 +374,7 @@ var import_nanoid2 = require("nanoid");
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.23.13";
+var version = "0.23.14";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -664,9 +688,17 @@ var Session = class {
   get connected() {
     return this.connection !== void 0;
   }
+  get nextExpectedAck() {
+    return this.seq;
+  }
   get nextExpectedSeq() {
     return this.ack;
   }
+  // This is only used in tests to make the session misbehave.
+  /* @internal */
+  advanceAckForTesting(by) {
+    this.ack += by;
+  }
   constructMsg(partialMsg) {
     const msg = {
       ...partialMsg,
@@ -777,6 +809,49 @@ var Transport = class {
     });
     return session;
   }
+  createNewSession({
+    to,
+    conn,
+    sessionId,
+    propagationCtx
+  }) {
+    let session = this.sessions.get(to);
+    if (session !== void 0) {
+      this.log?.info(
+        `session for ${to} already exists, replacing it with a new session as requested`,
+        session.loggingMetadata
+      );
+      this.deleteSession({
+        session,
+        closeHandshakingConnection: false
+      });
+      session = void 0;
+    }
+    session = this.createSession(to, conn, propagationCtx);
+    session.advertisedSessionId = sessionId;
+    this.log?.info(`created new session for ${to}`, session.loggingMetadata);
+    return session;
+  }
+  getExistingSession({
+    to,
+    sessionId,
+    nextExpectedSeq
+  }) {
+    const session = this.sessions.get(to);
+    if (
+      // reject this request if there was no previous session to replace
+      session === void 0 || // or if both parties do not agree about the next expected sequence number
+      session.nextExpectedAck < nextExpectedSeq || // or if both parties do not agree on the advertised session id
+      session.advertisedSessionId !== sessionId
+    ) {
+      return false;
+    }
+    this.log?.info(
+      `reused existing session for ${to}`,
+      session.loggingMetadata
+    );
+    return session;
+  }
   getOrCreateSession({
     to,
     conn,
@@ -1187,24 +1262,40 @@ var ClientTransport = class extends Transport {
       );
       return false;
     }
+    const previousSession = this.sessions.get(parsed.from);
     if (!parsed.payload.status.ok) {
-      conn.telemetry?.span.setStatus({
-        code: import_api4.SpanStatusCode.ERROR,
-        message: "handshake rejected"
-      });
-      this.log?.warn(`received handshake rejection`, {
-        ...conn.loggingMetadata,
-        clientId: this.clientId,
-        connectedTo: parsed.from,
-        transportMessage: parsed
-      });
+      if (parsed.payload.status.reason === SESSION_STATE_MISMATCH) {
+        if (previousSession) {
+          this.deleteSession({
+            session: previousSession,
+            closeHandshakingConnection: true
+          });
+        }
+        conn.telemetry?.span.setStatus({
+          code: import_api4.SpanStatusCode.ERROR,
+          message: parsed.payload.status.reason
+        });
+      } else {
+        conn.telemetry?.span.setStatus({
+          code: import_api4.SpanStatusCode.ERROR,
+          message: "handshake rejected"
+        });
+      }
+      this.log?.warn(
+        `received handshake rejection: ${parsed.payload.status.reason}`,
+        {
+          ...conn.loggingMetadata,
+          clientId: this.clientId,
+          connectedTo: parsed.from,
+          transportMessage: parsed
+        }
+      );
       this.protocolError(
         ProtocolError.HandshakeFailed,
         parsed.payload.status.reason
       );
       return false;
     }
-    const previousSession = this.sessions.get(parsed.from);
     if (previousSession?.advertisedSessionId && previousSession.advertisedSessionId !== parsed.payload.status.sessionId) {
       this.deleteSession({
         session: previousSession,
@@ -1384,13 +1475,17 @@ var ClientTransport = class extends Transport {
       }
     }
     const { session } = this.getOrCreateSession({ to, handshakingConn: conn });
-    const requestMsg = handshakeRequestMessage(
-      this.clientId,
+    const requestMsg = handshakeRequestMessage({
+      from: this.clientId,
       to,
-      session.id,
+      sessionId: session.id,
+      expectedSessionState: {
+        reconnect: session.advertisedSessionId !== void 0,
+        nextExpectedSeq: session.nextExpectedSeq
+      },
       metadata,
-      getPropagationContext(session.telemetry.ctx)
-    );
+      tracing: getPropagationContext(session.telemetry.ctx)
+    });
     this.log?.debug(`sending handshake request to ${to}`, {
       ...conn.loggingMetadata,
       clientId: this.clientId,