@replit/river 0.200.0-rc.2 → 0.200.0-rc.20

package/README.md

@@ -1,6 +1,6 @@
 # River
 
-⚠️ Not production ready, while Replit is using parts of river in production, we are still going through rapid breaking changes. First production ready version will be 1.x.x ⚠️
+⚠️ Not production ready, while Replit is using parts of River in production, we are still going through rapid breaking changes. First production ready version will be `1.x.x` ⚠️
 
 River allows multiple clients to connect to and make remote procedure calls to a remote server as if they were local procedures.
 
@@ -65,11 +65,11 @@ Before proceeding, ensure you have TypeScript 5 installed and configured appropr
 
 - Router: a collection of services, namespaced by service name.
 - Service: a collection of procedures with a shared state.
-- Procedure: a single procedure. A procedure declares its type, an input message type, an output message type, optionally an error type, and the associated handler. Valid types are:
-  - `rpc` whose handler has a signature of `Input -> Result<Output, Error>`.
-  - `upload` whose handler has a signature of `AsyncIterableIterator<Input> -> Result<Output, Error>`.
-  - `subscription` whose handler has a signature of `Input -> Pushable<Result<Output, Error>>`.
-  - `stream` whose handler has a signature of `AsyncIterableIterator<Input> -> Pushable<Result<Output, Error>>`.
+- Procedure: a single procedure. A procedure declares its type, a request data type, a response data type, optionally a response error type, and the associated handler. Valid types are:
+  - `rpc`, single request, single response
+  - `upload`, multiple requests, single response
+  - `subscription`, single request, multiple responses
+  - `stream`, multiple requests, multiple response
 - Transport: manages the lifecycle (creation/deletion) of connections and multiplexing read/writes from clients. Both the client and the server must be passed in a subclass of `Transport` to work.
   - Connection: the actual raw underlying transport connection
   - Session: a higher-level abstraction that operates over the span of potentially multiple transport-level connections
@@ -80,7 +80,7 @@ Before proceeding, ensure you have TypeScript 5 installed and configured appropr
 First, we create a service using `ServiceSchema`:
 
 ```ts
-import { ServicaSchema, Procedure, Ok } from '@replit/river';
+import { ServiceSchema, Procedure, Ok } from '@replit/river';
 import { Type } from '@sinclair/typebox';
 
 export const ExampleService = ServiceSchema.define(
@@ -92,11 +92,11 @@ export const ExampleService = ServiceSchema.define(
   // procedures
   {
     add: Procedure.rpc({
-      input: Type.Object({ n: Type.Number() }),
-      output: Type.Object({ result: Type.Number() }),
-      errors: Type.Never(),
+      requestInit: Type.Object({ n: Type.Number() }),
+      responseData: Type.Object({ result: Type.Number() }),
+      requestErrors: Type.Never(),
       // note that a handler is unique per user RPC
-      async handler(ctx, { n }) {
+      async handler({ ctx, reqInit: { n } }) {
         // access and mutate shared state
         ctx.state.count += n;
         return Ok({ result: ctx.state.count });
@@ -134,17 +134,17 @@ In another file for the client (to create a separate entrypoint),
 ```ts
 import { WebSocketClientTransport } from '@replit/river/transport/ws/client';
 import { createClient } from '@replit/river';
-import type ServiceSurface from './server';
+import { WebSocket } from 'ws';
 
 const transport = new WebSocketClientTransport(
   async () => new WebSocket('ws://localhost:3000'),
   'my-client-id',
 );
 
-const client = createClient<ServiceSurface>(
+const client = createClient(
   transport,
   'SERVER', // transport id of the server in the previous step
-  true, // whether to eagerly connect to the server on creation (optional argument)
+  { eagerlyConnect: true }, // whether to eagerly connect to the server on creation (optional argument)
 );
 
 // we get full type safety on `client`
@@ -157,15 +157,6 @@ if (result.ok) {
 }
 ```
 
-You can then access the `ParsedMetadata` in your procedure handlers:
-
-```ts
-async handler(ctx, ...args) {
-  // this contains the parsed metadata
-  console.log(ctx.metadata)
-}
-```
-
 ### Logging
 
 To add logging, you can bind a logging function to a transport.
@@ -192,12 +183,12 @@ River defines two types of reconnects:
 1. **Transparent reconnects:** These occur when the connection is temporarily lost and reestablished without losing any messages. From the application's perspective, this process is seamless and does not disrupt ongoing operations.
 2. **Hard reconnect:** This occurs when all server state is lost, requiring the client to reinitialize anything stateful (e.g. subscriptions).
 
-You can listen for transparent reconnects via the `connectionStatus` events, but realistically, no applications should need to listen for this unless it is for debugging purposes. Hard reconnects are signaled via `sessionStatus` events.
+Hard reconnects are signaled via `sessionStatus` events.
 
 If your application is stateful on either the server or the client, the service consumer _should_ wrap all the client-side setup with `transport.addEventListener('sessionStatus', (evt) => ...)` to do appropriate setup and teardown.
 
 ```ts
-transport.addEventListener('connectionStatus', (evt) => {
+transport.addEventListener('sessionStatus', (evt) => {
   if (evt.status === 'connect') {
     // do something
   } else if (evt.status === 'disconnect') {
@@ -205,11 +196,12 @@ transport.addEventListener('connectionStatus', (evt) => {
   }
 });
 
-transport.addEventListener('sessionStatus', (evt) => {
-  if (evt.status === 'connect') {
+// or, listen for specific session states
+transport.addEventListener('sessionTransition', (evt) => {
+  if (evt.state === SessionState.Connected) {
+    // switch on various transition states
+  } else if (evt.state === SessionState.NoConnection) {
     // do something
-  } else if (evt.status === 'disconnect') {
-    // do something else
   }
 });
 ```
@@ -253,6 +245,15 @@ createServer(new MockServerTransport('SERVER'), services, {
 });
 ```
 
+You can then access the `ParsedMetadata` in your procedure handlers:
+
+```ts
+async handler(ctx, ...args) {
+  // this contains the parsed metadata
+  console.log(ctx.metadata)
+}
+```
+
 ### Further examples
 
 We've also provided an end-to-end testing environment using `Next.js`, and a simple backend connected with the WebSocket transport that you can [play with on Replit](https://replit.com/@jzhao-replit/riverbed).

package/dist/chunk-3HI3IJTL.js

@@ -0,0 +1,285 @@
+import {
+  BaseLogger,
+  createLogProxy
+} from "./chunk-BAGOAJ3K.js";
+import {
+  SessionStateGraph,
+  defaultTransportOptions
+} from "./chunk-OLWVR5AB.js";
+import {
+  generateId
+} from "./chunk-BYCR4VEM.js";
+
+// transport/events.ts
+var ProtocolError = {
+  RetriesExceeded: "conn_retry_exceeded",
+  HandshakeFailed: "handshake_failed",
+  MessageOrderingViolated: "message_ordering_violated",
+  InvalidMessage: "invalid_message"
+};
+var EventDispatcher = class {
+  eventListeners = {};
+  removeAllListeners() {
+    this.eventListeners = {};
+  }
+  numberOfListeners(eventType) {
+    return this.eventListeners[eventType]?.size ?? 0;
+  }
+  addEventListener(eventType, handler) {
+    if (!this.eventListeners[eventType]) {
+      this.eventListeners[eventType] = /* @__PURE__ */ new Set();
+    }
+    this.eventListeners[eventType]?.add(handler);
+  }
+  removeEventListener(eventType, handler) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      this.eventListeners[eventType]?.delete(handler);
+    }
+  }
+  dispatchEvent(eventType, event) {
+    const handlers = this.eventListeners[eventType];
+    if (handlers) {
+      const copy = [...handlers];
+      for (const handler of copy) {
+        handler(event);
+      }
+    }
+  }
+};
+
+// transport/transport.ts
+var Transport = class {
+  /**
+   * The status of the transport.
+   */
+  status;
+  /**
+   * The client ID of this transport.
+   */
+  clientId;
+  /**
+   * The event dispatcher for handling events of type EventTypes.
+   */
+  eventDispatcher;
+  /**
+   * The options for this transport.
+   */
+  options;
+  log;
+  sessions;
+  /**
+   * Creates a new Transport instance.
+   * @param codec The codec used to encode and decode messages.
+   * @param clientId The client ID of this transport.
+   */
+  constructor(clientId, providedOptions) {
+    this.options = { ...defaultTransportOptions, ...providedOptions };
+    this.eventDispatcher = new EventDispatcher();
+    this.clientId = clientId;
+    this.status = "open";
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  bindLogger(fn, level) {
+    if (typeof fn === "function") {
+      this.log = createLogProxy(new BaseLogger(fn, level));
+      return;
+    }
+    this.log = createLogProxy(fn);
+  }
+  /**
+   * Called when a message is received by this transport.
+   * You generally shouldn't need to override this in downstream transport implementations.
+   * @param msg The received message.
+   */
+  handleMsg(msg) {
+    if (this.getStatus() !== "open")
+      return;
+    this.eventDispatcher.dispatchEvent("message", msg);
+  }
+  /**
+   * Adds a listener to this transport.
+   * @param the type of event to listen for
+   * @param handler The message handler to add.
+   */
+  addEventListener(type, handler) {
+    this.eventDispatcher.addEventListener(type, handler);
+  }
+  /**
+   * Removes a listener from this transport.
+   * @param the type of event to un-listen on
+   * @param handler The message handler to remove.
+   */
+  removeEventListener(type, handler) {
+    this.eventDispatcher.removeEventListener(type, handler);
+  }
+  protocolError(message) {
+    this.eventDispatcher.dispatchEvent("protocolError", message);
+  }
+  /**
+   * Default close implementation for transports. You should override this in the downstream
+   * implementation if you need to do any additional cleanup and call super.close() at the end.
+   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
+   */
+  close() {
+    this.status = "closed";
+    for (const session of this.sessions.values()) {
+      this.deleteSession(session);
+    }
+    this.eventDispatcher.dispatchEvent("transportStatus", {
+      status: this.status
+    });
+    this.eventDispatcher.removeAllListeners();
+    this.log?.info(`manually closed transport`, { clientId: this.clientId });
+  }
+  getStatus() {
+    return this.status;
+  }
+  updateSession(session) {
+    const activeSession = this.sessions.get(session.to);
+    if (activeSession && activeSession.id !== session.id) {
+      const msg = `attempt to transition active session for ${session.to} but active session (${activeSession.id}) is different from handle (${session.id})`;
+      throw new Error(msg);
+    }
+    this.sessions.set(session.to, session);
+    if (!activeSession) {
+      this.eventDispatcher.dispatchEvent("sessionStatus", {
+        status: "connect",
+        session
+      });
+    }
+    this.eventDispatcher.dispatchEvent("sessionTransition", {
+      state: session.state,
+      session
+    });
+    return session;
+  }
+  // state transitions
+  deleteSession(session, options) {
+    if (session._isConsumed)
+      return;
+    const loggingMetadata = session.loggingMetadata;
+    if (loggingMetadata.tags && options?.unhealthy) {
+      loggingMetadata.tags.push("unhealthy-session");
+    }
+    session.log?.info(`closing session ${session.id}`, loggingMetadata);
+    this.eventDispatcher.dispatchEvent("sessionStatus", {
+      status: "disconnect",
+      session
+    });
+    const to = session.to;
+    session.close();
+    this.sessions.delete(to);
+  }
+  // common listeners
+  onSessionGracePeriodElapsed(session) {
+    this.log?.warn(
+      `session to ${session.to} grace period elapsed, closing`,
+      session.loggingMetadata
+    );
+    this.deleteSession(session);
+  }
+  onConnectingFailed(session) {
+    const noConnectionSession = SessionStateGraph.transition.ConnectingToNoConnection(session, {
+      onSessionGracePeriodElapsed: () => {
+        this.onSessionGracePeriodElapsed(noConnectionSession);
+      }
+    });
+    return this.updateSession(noConnectionSession);
+  }
+  onConnClosed(session) {
+    let noConnectionSession;
+    if (session.state === "Handshaking" /* Handshaking */) {
+      noConnectionSession = SessionStateGraph.transition.HandshakingToNoConnection(session, {
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(noConnectionSession);
+        }
+      });
+    } else {
+      noConnectionSession = SessionStateGraph.transition.ConnectedToNoConnection(session, {
+        onSessionGracePeriodElapsed: () => {
+          this.onSessionGracePeriodElapsed(noConnectionSession);
+        }
+      });
+    }
+    return this.updateSession(noConnectionSession);
+  }
+};
+
+// transport/connection.ts
+var Connection = class {
+  id;
+  telemetry;
+  constructor() {
+    this.id = `conn-${generateId()}`;
+  }
+  get loggingMetadata() {
+    const metadata = { connId: this.id };
+    const spanContext = this.telemetry?.span.spanContext();
+    if (this.telemetry?.span.isRecording() && spanContext) {
+      metadata.telemetry = {
+        traceId: spanContext.traceId,
+        spanId: spanContext.spanId
+      };
+    }
+    return metadata;
+  }
+  // can't use event emitter because we need this to work in both node + browser
+  _dataListeners = /* @__PURE__ */ new Set();
+  _closeListeners = /* @__PURE__ */ new Set();
+  _errorListeners = /* @__PURE__ */ new Set();
+  get dataListeners() {
+    return [...this._dataListeners];
+  }
+  get closeListeners() {
+    return [...this._closeListeners];
+  }
+  get errorListeners() {
+    return [...this._errorListeners];
+  }
+  /**
+   * Handle adding a callback for when a message is received.
+   * @param msg The message that was received.
+   */
+  addDataListener(cb) {
+    this._dataListeners.add(cb);
+  }
+  removeDataListener(cb) {
+    this._dataListeners.delete(cb);
+  }
+  /**
+   * Handle adding a callback for when the connection is closed.
+   * This should also be called if an error happens and after notifying all the error listeners.
+   * @param cb The callback to call when the connection is closed.
+   */
+  addCloseListener(cb) {
+    this._closeListeners.add(cb);
+  }
+  removeCloseListener(cb) {
+    this._closeListeners.delete(cb);
+  }
+  /**
+   * Handle adding a callback for when an error is received.
+   * This should only be used for this.logging errors, all cleanup
+   * should be delegated to addCloseListener.
+   *
+   * The implementer should take care such that the implemented
+   * connection will call both the close and error callbacks
+   * on an error.
+   *
+   * @param cb The callback to call when an error is received.
+   */
+  addErrorListener(cb) {
+    this._errorListeners.add(cb);
+  }
+  removeErrorListener(cb) {
+    this._errorListeners.delete(cb);
+  }
+};
+
+export {
+  ProtocolError,
+  Transport,
+  Connection
+};
+//# sourceMappingURL=chunk-3HI3IJTL.js.map

package/dist/chunk-3HI3IJTL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../transport/events.ts","../transport/transport.ts","../transport/connection.ts"],"sourcesContent":["import { type Static } from '@sinclair/typebox';\nimport { Connection } from './connection';\nimport { OpaqueTransportMessage, HandshakeErrorResponseCodes } from './message';\nimport { Session, SessionState } from './sessionStateMachine';\nimport { TransportStatus } from './transport';\n\nexport const ProtocolError = {\n  RetriesExceeded: 'conn_retry_exceeded',\n  HandshakeFailed: 'handshake_failed',\n  MessageOrderingViolated: 'message_ordering_violated',\n  InvalidMessage: 'invalid_message',\n} as const;\n\nexport type ProtocolErrorType =\n  (typeof ProtocolError)[keyof typeof ProtocolError];\n\nexport interface EventMap {\n  message: OpaqueTransportMessage;\n  sessionStatus: {\n    status: 'connect' | 'disconnect';\n    session: Session<Connection>;\n  };\n  sessionTransition:\n    | { state: SessionState.Connected }\n    | { state: SessionState.Handshaking }\n    | { state: SessionState.Connecting }\n    | { state: SessionState.BackingOff }\n    | { state: SessionState.NoConnection };\n  protocolError:\n    | {\n        type: (typeof ProtocolError)['HandshakeFailed'];\n        code: Static<typeof HandshakeErrorResponseCodes>;\n        message: string;\n      }\n    | {\n        type: Omit<\n          ProtocolErrorType,\n          (typeof ProtocolError)['HandshakeFailed']\n        >;\n        message: string;\n      };\n  transportStatus: {\n    status: TransportStatus;\n  };\n}\n\nexport type EventTypes = keyof EventMap;\nexport type EventHandler<K extends EventTypes> = (\n  event: EventMap[K],\n) => unknown;\n\nexport class EventDispatcher<T extends EventTypes> {\n  private eventListeners: { [K in T]?: Set<EventHandler<K>> } = {};\n\n  removeAllListeners() {\n    this.eventListeners = {};\n  }\n\n  numberOfListeners<K extends T>(eventType: K) {\n    return this.eventListeners[eventType]?.size ?? 0;\n  }\n\n  addEventListener<K extends T>(eventType: K, handler: EventHandler<K>) {\n    if (!this.eventListeners[eventType]) {\n      this.eventListeners[eventType] = new Set();\n    }\n\n    this.eventListeners[eventType]?.add(handler);\n  }\n\n  removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>) {\n    const handlers = this.eventListeners[eventType];\n    if (handlers) {\n      this.eventListeners[eventType]?.delete(handler);\n    }\n  }\n\n  dispatchEvent<K extends T>(eventType: K, event: EventMap[K]) {\n    const handlers = this.eventListeners[eventType];\n    if (handlers) {\n      // copying ensures that adding more listeners in a handler doesn't\n      // affect the current dispatch.\n      const copy = [...handlers];\n      for (const handler of copy) {\n        handler(event);\n      }\n    }\n  }\n}\n","import {\n  OpaqueTransportMessage,\n  TransportClientId,\n  PartialTransportMessage,\n} from './message';\nimport {\n  BaseLogger,\n  LogFn,\n  Logger,\n  LoggingLevel,\n  createLogProxy,\n} from '../logging/log';\nimport { EventDispatcher, EventHandler, EventMap, EventTypes } from './events';\nimport {\n  ProvidedTransportOptions,\n  TransportOptions,\n  defaultTransportOptions,\n} from './options';\nimport {\n  SessionConnected,\n  SessionConnecting,\n  SessionHandshaking,\n  SessionNoConnection,\n  SessionState,\n} from './sessionStateMachine';\nimport { Connection } from './connection';\nimport { Session, SessionStateGraph } from './sessionStateMachine/transitions';\n\n/**\n * Represents the possible states of a transport.\n * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)\n * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.\n */\nexport type TransportStatus = 'open' | 'closed';\n\nexport interface DeleteSessionOptions {\n  unhealthy: boolean;\n}\n\n/**\n * Transports manage the lifecycle (creation/deletion) of sessions\n *\n * ```plaintext\n *            ▲\n *  incoming  │\n *  messages  │\n *            ▼\n *      ┌─────────────┐   1:N   ┌───────────┐   1:1*  ┌────────────┐\n *      │  Transport  │ ◄─────► │  Session  │ ◄─────► │ Connection │\n *      └─────────────┘         └───────────┘         └────────────┘\n *            ▲                               * (may or may not be initialized yet)\n *            │\n *            ▼\n *      ┌───────────┐\n *      │ Message   │\n *      │ Listeners │\n *      └───────────┘\n * ```\n * @abstract\n */\nexport abstract class Transport<ConnType extends Connection> {\n  /**\n   * The status of the transport.\n   */\n  private status: TransportStatus;\n\n  /**\n   * The client ID of this transport.\n   */\n  clientId: TransportClientId;\n\n  /**\n   * The event dispatcher for handling events of type EventTypes.\n   */\n  eventDispatcher: EventDispatcher<EventTypes>;\n\n  /**\n   * The options for this transport.\n   */\n  protected options: TransportOptions;\n  log?: Logger;\n\n  sessions: Map<TransportClientId, Session<ConnType>>;\n\n  /**\n   * Creates a new Transport instance.\n   * @param codec The codec used to encode and decode messages.\n   * @param clientId The client ID of this transport.\n   */\n  constructor(\n    clientId: TransportClientId,\n    providedOptions?: ProvidedTransportOptions,\n  ) {\n    this.options = { ...defaultTransportOptions, ...providedOptions };\n    this.eventDispatcher = new EventDispatcher();\n    this.clientId = clientId;\n    this.status = 'open';\n    this.sessions = new Map();\n  }\n\n  bindLogger(fn: LogFn | Logger, level?: LoggingLevel) {\n    // construct logger from fn\n    if (typeof fn === 'function') {\n      this.log = createLogProxy(new BaseLogger(fn, level));\n      return;\n    }\n\n    // object case, just assign\n    this.log = createLogProxy(fn);\n  }\n\n  /**\n   * Called when a message is received by this transport.\n   * You generally shouldn't need to override this in downstream transport implementations.\n   * @param msg The received message.\n   */\n  protected handleMsg(msg: OpaqueTransportMessage) {\n    if (this.getStatus() !== 'open') return;\n    this.eventDispatcher.dispatchEvent('message', msg);\n  }\n\n  /**\n   * Adds a listener to this transport.\n   * @param the type of event to listen for\n   * @param handler The message handler to add.\n   */\n  addEventListener<K extends EventTypes, T extends EventHandler<K>>(\n    type: K,\n    handler: T,\n  ): void {\n    this.eventDispatcher.addEventListener(type, handler);\n  }\n\n  /**\n   * Removes a listener from this transport.\n   * @param the type of event to un-listen on\n   * @param handler The message handler to remove.\n   */\n  removeEventListener<K extends EventTypes, T extends EventHandler<K>>(\n    type: K,\n    handler: T,\n  ): void {\n    this.eventDispatcher.removeEventListener(type, handler);\n  }\n\n  /**\n   * Sends a message over this transport, delegating to the appropriate connection to actually\n   * send the message.\n   * @param msg The message to send.\n   * @returns The ID of the sent message or undefined if it wasn't sent\n   */\n  abstract send(to: TransportClientId, msg: PartialTransportMessage): string;\n\n  protected protocolError(message: EventMap['protocolError']) {\n    this.eventDispatcher.dispatchEvent('protocolError', message);\n  }\n\n  /**\n   * Default close implementation for transports. You should override this in the downstream\n   * implementation if you need to do any additional cleanup and call super.close() at the end.\n   * Closes the transport. Any messages sent while the transport is closed will be silently discarded.\n   */\n  close() {\n    this.status = 'closed';\n\n    for (const session of this.sessions.values()) {\n      this.deleteSession(session);\n    }\n\n    this.eventDispatcher.dispatchEvent('transportStatus', {\n      status: this.status,\n    });\n\n    this.eventDispatcher.removeAllListeners();\n\n    this.log?.info(`manually closed transport`, { clientId: this.clientId });\n  }\n\n  getStatus(): TransportStatus {\n    return this.status;\n  }\n\n  protected updateSession<S extends Session<ConnType>>(session: S): S {\n    const activeSession = this.sessions.get(session.to);\n    if (activeSession && activeSession.id !== session.id) {\n      const msg = `attempt to transition active session for ${session.to} but active session (${activeSession.id}) is different from handle (${session.id})`;\n      throw new Error(msg);\n    }\n\n    this.sessions.set(session.to, session);\n\n    if (!activeSession) {\n      this.eventDispatcher.dispatchEvent('sessionStatus', {\n        status: 'connect',\n        session: session,\n      });\n    }\n\n    this.eventDispatcher.dispatchEvent('sessionTransition', {\n      state: session.state,\n      session: session,\n    } as EventMap['sessionTransition']);\n\n    return session;\n  }\n\n  // state transitions\n  protected deleteSession(\n    session: Session<ConnType>,\n    options?: DeleteSessionOptions,\n  ) {\n    // ensure idempotency esp re: dispatching events\n    if (session._isConsumed) return;\n\n    const loggingMetadata = session.loggingMetadata;\n    if (loggingMetadata.tags && options?.unhealthy) {\n      loggingMetadata.tags.push('unhealthy-session');\n    }\n\n    session.log?.info(`closing session ${session.id}`, loggingMetadata);\n    this.eventDispatcher.dispatchEvent('sessionStatus', {\n      status: 'disconnect',\n      session: session,\n    });\n\n    const to = session.to;\n    session.close();\n    this.sessions.delete(to);\n  }\n\n  // common listeners\n  protected onSessionGracePeriodElapsed(session: Session<ConnType>) {\n    this.log?.warn(\n      `session to ${session.to} grace period elapsed, closing`,\n      session.loggingMetadata,\n    );\n\n    this.deleteSession(session);\n  }\n\n  protected onConnectingFailed(\n    session: SessionConnecting<ConnType>,\n  ): SessionNoConnection {\n    // transition to no connection\n    const noConnectionSession =\n      SessionStateGraph.transition.ConnectingToNoConnection(session, {\n        onSessionGracePeriodElapsed: () => {\n          this.onSessionGracePeriodElapsed(noConnectionSession);\n        },\n      });\n\n    return this.updateSession(noConnectionSession);\n  }\n\n  protected onConnClosed(\n    session: SessionHandshaking<ConnType> | SessionConnected<ConnType>,\n  ): SessionNoConnection {\n    // transition to no connection\n    let noConnectionSession: SessionNoConnection;\n    if (session.state === SessionState.Handshaking) {\n      noConnectionSession =\n        SessionStateGraph.transition.HandshakingToNoConnection(session, {\n          onSessionGracePeriodElapsed: () => {\n            this.onSessionGracePeriodElapsed(noConnectionSession);\n          },\n        });\n    } else {\n      noConnectionSession =\n        SessionStateGraph.transition.ConnectedToNoConnection(session, {\n          onSessionGracePeriodElapsed: () => {\n            this.onSessionGracePeriodElapsed(noConnectionSession);\n          },\n        });\n    }\n\n    return this.updateSession(noConnectionSession);\n  }\n}\n","import { TelemetryInfo } from '../tracing';\nimport { MessageMetadata } from '../logging';\nimport { generateId } from './id';\n\n/**\n * A connection is the actual raw underlying transport connection.\n * It’s responsible for dispatching to/from the actual connection itself\n * This should be instantiated as soon as the client/server has a connection\n * It’s tied to the lifecycle of the underlying transport connection (i.e. if the WS drops, this connection should be deleted)\n */\nexport abstract class Connection {\n  id: string;\n  telemetry?: TelemetryInfo;\n\n  constructor() {\n    this.id = `conn-${generateId()}`; // for debugging, no collision safety needed\n  }\n\n  get loggingMetadata(): MessageMetadata {\n    const metadata: MessageMetadata = { connId: this.id };\n    const spanContext = this.telemetry?.span.spanContext();\n\n    if (this.telemetry?.span.isRecording() && spanContext) {\n      metadata.telemetry = {\n        traceId: spanContext.traceId,\n        spanId: spanContext.spanId,\n      };\n    }\n\n    return metadata;\n  }\n\n  // can't use event emitter because we need this to work in both node + browser\n  private _dataListeners = new Set<(msg: Uint8Array) => void>();\n  private _closeListeners = new Set<() => void>();\n  private _errorListeners = new Set<(err: Error) => void>();\n\n  get dataListeners() {\n    return [...this._dataListeners];\n  }\n\n  get closeListeners() {\n    return [...this._closeListeners];\n  }\n\n  get errorListeners() {\n    return [...this._errorListeners];\n  }\n\n  /**\n   * Handle adding a callback for when a message is received.\n   * @param msg The message that was received.\n   */\n  addDataListener(cb: (msg: Uint8Array) => void) {\n    this._dataListeners.add(cb);\n  }\n\n  removeDataListener(cb: (msg: Uint8Array) => void): void {\n    this._dataListeners.delete(cb);\n  }\n\n  /**\n   * Handle adding a callback for when the connection is closed.\n   * This should also be called if an error happens and after notifying all the error listeners.\n   * @param cb The callback to call when the connection is closed.\n   */\n  addCloseListener(cb: () => void): void {\n    this._closeListeners.add(cb);\n  }\n\n  removeCloseListener(cb: () => void): void {\n    this._closeListeners.delete(cb);\n  }\n\n  /**\n   * Handle adding a callback for when an error is received.\n   * This should only be used for this.logging errors, all cleanup\n   * should be delegated to addCloseListener.\n   *\n   * The implementer should take care such that the implemented\n   * connection will call both the close and error callbacks\n   * on an error.\n   *\n   * @param cb The callback to call when an error is received.\n   */\n  addErrorListener(cb: (err: Error) => void): void {\n    this._errorListeners.add(cb);\n  }\n\n  removeErrorListener(cb: (err: Error) => void): void {\n    this._errorListeners.delete(cb);\n  }\n\n  /**\n   * Sends a message over the connection.\n   * @param msg The message to send.\n   * @returns true if the message was sent, false otherwise.\n   */\n  abstract send(msg: Uint8Array): boolean;\n\n  /**\n   * Closes the connection.\n   */\n  abstract close(): void;\n}\n"],"mappings":"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","names":[]}