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

package/dist/client-f56a6da3.d.ts

@@ -0,0 +1,49 @@
+import { C as Connection, T as Transport, o as ClientTransportOptions, L as LeakyBucketRateLimit, p as ClientHandshakeOptions, b as ProvidedClientTransportOptions, f as SessionConnecting, e as SessionNoConnection, g as SessionHandshaking, h as SessionConnected } from './context-73df8978.js';
+import { c as TransportClientId, P as PartialTransportMessage, b as OpaqueTransportMessage } from './message-fd349b27.js';
+
+declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    retryBudget: LeakyBucketRateLimit;
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    /**
+     * Optional handshake options for this client.
+     */
+    handshakeExtensions?: ClientHandshakeOptions;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     * This should call {@link handleConnection} when the connection is created.
+     * The downstream client implementation needs to implement this.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    private tryReconnecting;
+    send(to: string, msg: PartialTransportMessage): string;
+    private createUnconnectedSession;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+    protected onConnectionEstablished(session: SessionConnecting<ConnType>, conn: ConnType): SessionHandshaking<ConnType>;
+    private rejectHandshakeResponse;
+    protected onHandshakeResponse(session: SessionHandshaking<ConnType>, msg: OpaqueTransportMessage): void;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): void;
+    private sendHandshake;
+    close(): void;
+}
+
+export { ClientTransport as C };

package/dist/{connection-f900e390.d.ts → connection-11991b13.d.ts}

@@ -1,6 +1,6 @@
-import { C as Connection } from './services-970f97bb.js';
 import { Socket } from 'node:net';
 import stream, { Transform, TransformCallback, TransformOptions } from 'node:stream';
+import { C as Connection } from './context-73df8978.js';
 
 interface LengthEncodedOptions extends TransformOptions {
     /** Maximum in-memory buffer size before we throw */
@@ -24,10 +24,6 @@ declare class UdsConnection extends Connection {
     input: stream.Readable;
     framer: Uint32LengthPrefixFraming;
     constructor(sock: Socket);
-    addDataListener(cb: (msg: Uint8Array) => void): void;
-    removeDataListener(cb: (msg: Uint8Array) => void): void;
-    addCloseListener(cb: () => void): void;
-    addErrorListener(cb: (err: Error) => void): void;
     send(payload: Uint8Array): boolean;
     close(): void;
 }

package/dist/connection-6031a354.d.ts

@@ -0,0 +1,11 @@
+import { C as Connection } from './context-73df8978.js';
+import { W as WsLike } from './wslike-e0b32dd5.js';
+
+declare class WebSocketConnection extends Connection {
+    ws: WsLike;
+    constructor(ws: WsLike);
+    send(payload: Uint8Array): boolean;
+    close(): void;
+}
+
+export { WebSocketConnection as W };

package/dist/context-73df8978.d.ts

@@ -0,0 +1,528 @@
+import { e as TelemetryInfo, M as MessageMetadata, a as TransportMessage, b as OpaqueTransportMessage, P as PartialTransportMessage, c as TransportClientId, L as Logger, f as LogFn, g as LoggingLevel } from './message-fd349b27.js';
+import { TSchema, Static } from '@sinclair/typebox';
+import { C as Codec } from './types-3e5768ec.js';
+
+/**
+ * A connection is the actual raw underlying transport connection.
+ * It’s responsible for dispatching to/from the actual connection itself
+ * This should be instantiated as soon as the client/server has a connection
+ * It’s tied to the lifecycle of the underlying transport connection (i.e. if the WS drops, this connection should be deleted)
+ */
+declare abstract class Connection {
+    id: string;
+    telemetry?: TelemetryInfo;
+    constructor();
+    get loggingMetadata(): MessageMetadata;
+    private _dataListeners;
+    private _closeListeners;
+    private _errorListeners;
+    get dataListeners(): ((msg: Uint8Array) => void)[];
+    get closeListeners(): (() => void)[];
+    get errorListeners(): ((err: Error) => void)[];
+    /**
+     * Handle adding a callback for when a message is received.
+     * @param msg The message that was received.
+     */
+    addDataListener(cb: (msg: Uint8Array) => void): void;
+    removeDataListener(cb: (msg: Uint8Array) => void): void;
+    /**
+     * 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: () => void): void;
+    removeCloseListener(cb: () => void): void;
+    /**
+     * 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: (err: Error) => void): void;
+    removeErrorListener(cb: (err: Error) => void): void;
+    /**
+     * Sends a message over the connection.
+     * @param msg The message to send.
+     * @returns true if the message was sent, false otherwise.
+     */
+    abstract send(msg: Uint8Array): boolean;
+    /**
+     * Closes the connection.
+     */
+    abstract close(): void;
+}
+
+interface SessionNoConnectionListeners {
+    onSessionGracePeriodElapsed: () => void;
+}
+declare class SessionNoConnection extends IdentifiedSession {
+    readonly state: SessionState.NoConnection;
+    listeners: SessionNoConnectionListeners;
+    gracePeriodTimeout?: ReturnType<typeof setTimeout>;
+    constructor(listeners: SessionNoConnectionListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    _handleClose(): void;
+    _handleStateExit(): void;
+}
+
+interface SessionConnectingListeners {
+    onConnectionEstablished: (conn: Connection) => void;
+    onConnectionFailed: (err: unknown) => void;
+    onConnectionTimeout: () => void;
+}
+declare class SessionConnecting<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Connecting;
+    connPromise: Promise<ConnType>;
+    listeners: SessionConnectingListeners;
+    connectionTimeout?: ReturnType<typeof setTimeout>;
+    constructor(connPromise: Promise<ConnType>, listeners: SessionConnectingListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    bestEffortClose(): void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionHandshakingListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onHandshake: (msg: OpaqueTransportMessage) => void;
+    onInvalidHandshake: (reason: string) => void;
+    onHandshakeTimeout: () => void;
+}
+declare class SessionHandshaking<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Handshaking;
+    conn: ConnType;
+    listeners: SessionHandshakingListeners;
+    handshakeTimeout: ReturnType<typeof setTimeout>;
+    constructor(conn: ConnType, listeners: SessionHandshakingListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    onHandshakeData: (msg: Uint8Array) => void;
+    sendHandshake(msg: TransportMessage): boolean;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+interface SessionConnectedListeners {
+    onConnectionErrored: (err: unknown) => void;
+    onConnectionClosed: () => void;
+    onMessage: (msg: OpaqueTransportMessage) => void;
+    onInvalidMessage: (reason: string) => void;
+}
+declare class SessionConnected<ConnType extends Connection> extends IdentifiedSession {
+    readonly state: SessionState.Connected;
+    conn: ConnType;
+    listeners: SessionConnectedListeners;
+    heartbeatHandle?: ReturnType<typeof setInterval> | undefined;
+    heartbeatMisses: number;
+    get isActivelyHeartbeating(): boolean;
+    updateBookkeeping(ack: number, seq: number): void;
+    send(msg: PartialTransportMessage): string;
+    constructor(conn: ConnType, listeners: SessionConnectedListeners, ...args: ConstructorParameters<typeof IdentifiedSession>);
+    startActiveHeartbeat(): void;
+    private sendHeartbeat;
+    onMessageData: (msg: Uint8Array) => void;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+declare const enum SessionState {
+    NoConnection = "NoConnection",
+    Connecting = "Connecting",
+    Handshaking = "Handshaking",
+    Connected = "Connected",
+    WaitingForHandshake = "WaitingForHandshake"
+}
+type Session<ConnType extends Connection> = SessionNoConnection | SessionConnecting<ConnType> | SessionHandshaking<ConnType> | SessionConnected<ConnType>;
+declare abstract class StateMachineState {
+    abstract readonly state: SessionState;
+    _isConsumed: boolean;
+    abstract _handleStateExit(): void;
+    abstract _handleClose(): void;
+    close(): void;
+    constructor();
+}
+interface SessionOptions {
+    /**
+     * Frequency at which to send heartbeat acknowledgements
+     */
+    heartbeatIntervalMs: number;
+    /**
+     * Number of elapsed heartbeats without a response message before we consider
+     * the connection dead.
+     */
+    heartbeatsUntilDead: number;
+    /**
+     * Duration to wait between connection disconnect and actual session disconnect
+     */
+    sessionDisconnectGraceMs: number;
+    /**
+     * Connection timeout in milliseconds
+     */
+    connectionTimeoutMs: number;
+    /**
+     * Handshake timeout in milliseconds
+     */
+    handshakeTimeoutMs: number;
+    /**
+     * The codec to use for encoding/decoding messages over the wire
+     */
+    codec: Codec;
+}
+declare abstract class CommonSession extends StateMachineState {
+    readonly from: TransportClientId;
+    readonly options: SessionOptions;
+    log?: Logger;
+    abstract get loggingMetadata(): MessageMetadata;
+    constructor(from: TransportClientId, options: SessionOptions, log: Logger | undefined);
+    parseMsg(msg: Uint8Array): OpaqueTransportMessage | null;
+}
+type SessionId = string;
+declare abstract class IdentifiedSession extends CommonSession {
+    readonly id: SessionId;
+    readonly telemetry: TelemetryInfo;
+    readonly to: TransportClientId;
+    readonly protocolVersion: string;
+    /**
+     * Index of the message we will send next (excluding handshake)
+     */
+    seq: number;
+    /**
+     * Number of unique messages we've received this session (excluding handshake)
+     */
+    ack: number;
+    sendBuffer: Array<OpaqueTransportMessage>;
+    constructor(id: SessionId, from: TransportClientId, to: TransportClientId, seq: number, ack: number, sendBuffer: Array<OpaqueTransportMessage>, telemetry: TelemetryInfo, options: SessionOptions, protocolVersion: string, log: Logger | undefined);
+    get loggingMetadata(): MessageMetadata;
+    constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
+    nextSeq(): number;
+    send(msg: PartialTransportMessage): string;
+    _handleStateExit(): void;
+    _handleClose(): void;
+}
+
+declare const ProtocolError: {
+    readonly RetriesExceeded: "conn_retry_exceeded";
+    readonly HandshakeFailed: "handshake_failed";
+    readonly MessageOrderingViolated: "message_ordering_violated";
+};
+type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
+interface EventMap {
+    message: OpaqueTransportMessage;
+    sessionStatus: {
+        status: 'connect' | 'disconnect';
+        session: Session<Connection>;
+    };
+    sessionTransition: {
+        state: SessionState.Connected;
+    } | {
+        state: SessionState.Handshaking;
+    } | {
+        state: SessionState.Connecting;
+    } | {
+        state: SessionState.NoConnection;
+    };
+    protocolError: {
+        type: ProtocolErrorType;
+        message: string;
+    };
+    transportStatus: {
+        status: TransportStatus;
+    };
+}
+type EventTypes = keyof EventMap;
+type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
+declare class EventDispatcher<T extends EventTypes> {
+    private eventListeners;
+    removeAllListeners(): void;
+    numberOfListeners<K extends T>(eventType: K): number;
+    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
+}
+
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandles;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(user: TransportClientId): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(user: TransportClientId): void;
+    getBudgetConsumed(user: TransportClientId): number;
+    hasBudget(user: TransportClientId): boolean;
+    startRestoringBudget(user: TransportClientId): void;
+    private stopLeak;
+    close(): void;
+}
+
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
+
+/**
+ * Represents the possible states of a transport.
+ * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
+ * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
+ */
+type TransportStatus = 'open' | 'closed';
+/**
+ * Transports manage the lifecycle (creation/deletion) of sessions
+ *
+ * ```plaintext
+ *            ▲
+ *  incoming  │
+ *  messages  │
+ *            ▼
+ *      ┌─────────────┐   1:N   ┌───────────┐   1:1*  ┌────────────┐
+ *      │  Transport  │ ◄─────► │  Session  │ ◄─────► │ Connection │
+ *      └─────────────┘         └───────────┘         └────────────┘
+ *            ▲                               * (may or may not be initialized yet)
+ *            │
+ *            ▼
+ *      ┌───────────┐
+ *      │ Message   │
+ *      │ Listeners │
+ *      └───────────┘
+ * ```
+ * @abstract
+ */
+declare abstract class Transport<ConnType extends Connection> {
+    /**
+     * The status of the transport.
+     */
+    private status;
+    /**
+     * The client ID of this transport.
+     */
+    clientId: TransportClientId;
+    /**
+     * The event dispatcher for handling events of type EventTypes.
+     */
+    eventDispatcher: EventDispatcher<EventTypes>;
+    /**
+     * The options for this transport.
+     */
+    protected options: TransportOptions;
+    log?: Logger;
+    sessions: Map<TransportClientId, Session<ConnType>>;
+    /**
+     * 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: TransportClientId, providedOptions?: ProvidedTransportOptions);
+    bindLogger(fn: LogFn | Logger, level?: LoggingLevel): void;
+    /**
+     * 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.
+     */
+    protected handleMsg(msg: OpaqueTransportMessage): void;
+    /**
+     * Adds a listener to this transport.
+     * @param the type of event to listen for
+     * @param handler The message handler to add.
+     */
+    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
+    /**
+     * Removes a listener from this transport.
+     * @param the type of event to un-listen on
+     * @param handler The message handler to remove.
+     */
+    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
+    /**
+     * Sends a message over this transport, delegating to the appropriate connection to actually
+     * send the message.
+     * @param msg The message to send.
+     * @returns The ID of the sent message or undefined if it wasn't sent
+     */
+    abstract send(to: TransportClientId, msg: PartialTransportMessage): string;
+    protected protocolError(type: ProtocolErrorType, message: string): void;
+    /**
+     * 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(): void;
+    getStatus(): TransportStatus;
+    protected updateSession<S extends Session<ConnType>>(session: S): S;
+    protected deleteSession(session: Session<ConnType>): void;
+    protected onSessionGracePeriodElapsed(session: SessionNoConnection): void;
+    protected onConnectingFailed(session: SessionConnecting<ConnType>): SessionNoConnection;
+    protected onConnClosed(session: SessionHandshaking<ConnType> | SessionConnected<ConnType>): SessionNoConnection;
+}
+
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
+interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the client sends to the server
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
+     */
+    construct: ConstructHandshake<MetadataSchema>;
+}
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
+     */
+    validate: ValidateHandshake<MetadataSchema>;
+}
+declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
+declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
+
+/**
+ * ServiceContext exist for the purpose of declaration merging
+ * to extend the context with additional properties.
+ *
+ * For example:
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ *
+ * createServer(someTransport, myServices, { extendedContext: { db: myDb } });
+ * ```
+ *
+ * Once you do this, your {@link ProcedureHandlerContext} will have `db` property on it.
+ */
+interface ServiceContext {
+}
+/**
+ * The parsed metadata schema for a service. This is the
+ * return value of the {@link ServerHandshakeOptions.validate}
+ * if the handshake extension is used.
+ *
+ * You should use declaration merging to extend this interface
+ * with the sanitized metadata.
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ParsedMetadata {
+ *     userId: number;
+ *   }
+ * }
+ * ```
+ */
+interface ParsedMetadata {
+}
+/**
+ * This is passed to every procedure handler and contains various context-level
+ * information and utilities. This may be extended, see {@link ServiceContext}
+ */
+type ProcedureHandlerContext<State> = ServiceContext & {
+    /**
+     * State for this service as defined by the service definition.
+     */
+    state: State;
+    /**
+     * Metadata parsed on the server. See {@link ParsedMetadata}
+     */
+    metadata: ParsedMetadata;
+    /**
+     * The ID of the session that sent this request.
+     */
+    sessionId: SessionId;
+    /**
+     * The ID of the client that sent this request. There may be multiple sessions per client.
+     */
+    from: TransportClientId;
+    /**
+     * An AbortController for this stream. This is used to abort the stream from the
+     * handler and notify the client that the stream was aborted.
+     *
+     * Important to note that this controller is owned by the handler, if you
+     * want to listen to aborts coming from the client, you should use the
+     * {@link clientAbortSignal}.
+     *
+     * Aborts are not the same as closing streams gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    abortController: AbortController;
+    /**
+     * You can listen to clientAbortSignal this to check if the client aborted the request,
+     * or if the request was aborted due to an unexpected disconnect from the calling
+     * session.
+     *
+     * If the procedure has a read stream (e.g. upload or stream), the procedure will
+     * notified of aborts as part of the stream, but you may still want to use
+     * this signal as it is triggered immediately after an abort comes in,
+     * in readStreams some data may be buffered before the abort result shows up.
+     *
+     * Important to note that this signal is owned by the client, you have a separate
+     * signal inside {@link abortController} for aborts triggered within the handler.
+     *
+     * Aborts are not the same as closing streams gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    clientAbortSignal: AbortSignal;
+    /**
+     * Lets you add a function that will run when the request is done, this can be
+     * due to an abort (from either side), error, or success. If the callback is
+     * added after the stream ended, it will run immediately.
+     */
+    onRequestFinished: (callback: () => void) => void;
+};
+
+export { Connection as C, EventMap as E, LeakyBucketRateLimit as L, ProvidedTransportOptions as P, Session as S, Transport as T, TransportStatus as a, ProvidedClientTransportOptions as b, ProvidedServerTransportOptions as c, SessionState as d, SessionNoConnection as e, SessionConnecting as f, SessionHandshaking as g, SessionConnected as h, EventTypes as i, EventHandler as j, ProtocolError as k, ProtocolErrorType as l, SessionOptions as m, ServiceContext as n, ClientTransportOptions as o, ClientHandshakeOptions as p, ServerHandshakeOptions as q, ParsedMetadata as r, ProcedureHandlerContext as s, createClientHandshakeOptions as t, createServerHandshakeOptions as u, CommonSession as v, SessionHandshakingListeners as w, ServerTransportOptions as x };

package/dist/logging/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../logging/index.ts","../../logging/log.ts"],"sourcesContent":["export { stringLogger, coloredStringLogger, jsonLogger } from './log';\nexport type { Logger, LogFn, MessageMetadata } from './log';\n","import { ValueError } from '@sinclair/typebox/value';\nimport { OpaqueTransportMessage } from '../transport/message';\n\nconst LoggingLevels = {\n  debug: -1,\n  info: 0,\n  warn: 1,\n  error: 2,\n} as const;\nexport type LoggingLevel = keyof typeof LoggingLevels;\n\nexport type LogFn = (\n  msg: string,\n  ctx?: MessageMetadata,\n  level?: LoggingLevel,\n) => void;\nexport type Logger = {\n  [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;\n};\n\nexport type Tags = 'invariant-violation' | 'invalid-request';\n\nconst cleanedLogFn = (log: LogFn) => {\n  return (msg: string, metadata?: MessageMetadata) => {\n    // skip cloning object if metadata has no transportMessage\n    if (!metadata?.transportMessage) {\n      log(msg, metadata);\n      return;\n    }\n\n    // clone metadata and clean transportMessage\n    const { payload, ...rest } = metadata.transportMessage;\n    metadata.transportMessage = rest;\n    log(msg, metadata);\n  };\n};\n\nexport type MessageMetadata = Partial<{\n  protocolVersion: string;\n  clientId: string;\n  connectedTo: string;\n  sessionId: string;\n  connId: string;\n  transportMessage: Partial<OpaqueTransportMessage>;\n  validationErrors: Array<ValueError>;\n  tags: Array<Tags>;\n  telemetry: {\n    traceId: string;\n    spanId: string;\n  };\n}>;\n\nexport class BaseLogger implements Logger {\n  minLevel: LoggingLevel;\n  private output: LogFn;\n\n  constructor(output: LogFn, minLevel: LoggingLevel = 'info') {\n    this.minLevel = minLevel;\n    this.output = output;\n  }\n\n  debug(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {\n      this.output(msg, metadata ?? {}, 'debug');\n    }\n  }\n\n  info(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {\n      this.output(msg, metadata ?? {}, 'info');\n    }\n  }\n\n  warn(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {\n      this.output(msg, metadata ?? {}, 'warn');\n    }\n  }\n\n  error(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {\n      this.output(msg, metadata ?? {}, 'error');\n    }\n  }\n}\n\nexport const stringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${level}] ${from}${msg}`);\n};\n\nconst colorMap = {\n  debug: '\\u001b[34m',\n  info: '\\u001b[32m',\n  warn: '\\u001b[33m',\n  error: '\\u001b[31m',\n};\n\nexport const coloredStringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const color = colorMap[level];\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${color}${level}\\u001b[0m] ${from}${msg}`);\n};\n\nexport const jsonLogger: LogFn = (msg, ctx, level) => {\n  console.log(JSON.stringify({ msg, ctx, level }));\n};\n\nexport const createLogProxy = (log: Logger) => ({\n  debug: cleanedLogFn(log.debug.bind(log)),\n  info: cleanedLogFn(log.info.bind(log)),\n  warn: cleanedLogFn(log.warn.bind(log)),\n  error: cleanedLogFn(log.error.bind(log)),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsFO,IAAM,eAAsB,CAAC,KAAK,KAAK,QAAQ,WAAW;AAC/D,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE;AAC9C;AAEA,IAAM,WAAW;AAAA,EACf,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAEO,IAAM,sBAA6B,CAAC,KAAK,KAAK,QAAQ,WAAW;AACtE,QAAM,QAAQ,SAAS,KAAK;AAC5B,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,GAAG,KAAK,YAAc,IAAI,GAAG,GAAG,EAAE;AAC/D;AAEO,IAAM,aAAoB,CAAC,KAAK,KAAK,UAAU;AACpD,UAAQ,IAAI,KAAK,UAAU,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC;AACjD;","names":[]}
+{"version":3,"sources":["../../logging/index.ts","../../logging/log.ts"],"sourcesContent":["export { stringLogger, coloredStringLogger, jsonLogger } from './log';\nexport type { Logger, LogFn, MessageMetadata } from './log';\n","import { ValueError } from '@sinclair/typebox/value';\nimport { OpaqueTransportMessage } from '../transport/message';\n\nconst LoggingLevels = {\n  debug: -1,\n  info: 0,\n  warn: 1,\n  error: 2,\n} as const;\nexport type LoggingLevel = keyof typeof LoggingLevels;\n\nexport type LogFn = (\n  msg: string,\n  ctx?: MessageMetadata,\n  level?: LoggingLevel,\n) => void;\nexport type Logger = {\n  [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;\n};\n\nexport type Tags =\n  | 'invariant-violation'\n  | 'state-transition'\n  | 'invalid-request';\n\nconst cleanedLogFn = (log: LogFn) => {\n  return (msg: string, metadata?: MessageMetadata) => {\n    // skip cloning object if metadata has no transportMessage\n    if (!metadata?.transportMessage) {\n      log(msg, metadata);\n      return;\n    }\n\n    // clone metadata and clean transportMessage\n    const { payload, ...rest } = metadata.transportMessage;\n    metadata.transportMessage = rest;\n    log(msg, metadata);\n  };\n};\n\nexport type MessageMetadata = Partial<{\n  protocolVersion: string;\n  clientId: string;\n  connectedTo: string;\n  sessionId: string;\n  connId: string;\n  transportMessage: Partial<OpaqueTransportMessage>;\n  validationErrors: Array<ValueError>;\n  tags: Array<Tags>;\n  telemetry: {\n    traceId: string;\n    spanId: string;\n  };\n}>;\n\nexport class BaseLogger implements Logger {\n  minLevel: LoggingLevel;\n  private output: LogFn;\n\n  constructor(output: LogFn, minLevel: LoggingLevel = 'info') {\n    this.minLevel = minLevel;\n    this.output = output;\n  }\n\n  debug(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.debug) {\n      this.output(msg, metadata ?? {}, 'debug');\n    }\n  }\n\n  info(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.info) {\n      this.output(msg, metadata ?? {}, 'info');\n    }\n  }\n\n  warn(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.warn) {\n      this.output(msg, metadata ?? {}, 'warn');\n    }\n  }\n\n  error(msg: string, metadata?: MessageMetadata) {\n    if (LoggingLevels[this.minLevel] <= LoggingLevels.error) {\n      this.output(msg, metadata ?? {}, 'error');\n    }\n  }\n}\n\nexport const stringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${level}] ${from}${msg}`);\n};\n\nconst colorMap = {\n  debug: '\\u001b[34m',\n  info: '\\u001b[32m',\n  warn: '\\u001b[33m',\n  error: '\\u001b[31m',\n};\n\nexport const coloredStringLogger: LogFn = (msg, ctx, level = 'info') => {\n  const color = colorMap[level];\n  const from = ctx?.clientId ? `${ctx.clientId} -- ` : '';\n  console.log(`[river:${color}${level}\\u001b[0m] ${from}${msg}`);\n};\n\nexport const jsonLogger: LogFn = (msg, ctx, level) => {\n  console.log(JSON.stringify({ msg, ctx, level }));\n};\n\nexport const createLogProxy = (log: Logger) => ({\n  debug: cleanedLogFn(log.debug.bind(log)),\n  info: cleanedLogFn(log.info.bind(log)),\n  warn: cleanedLogFn(log.warn.bind(log)),\n  error: cleanedLogFn(log.error.bind(log)),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACyFO,IAAM,eAAsB,CAAC,KAAK,KAAK,QAAQ,WAAW;AAC/D,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,KAAK,IAAI,GAAG,GAAG,EAAE;AAC9C;AAEA,IAAM,WAAW;AAAA,EACf,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAEO,IAAM,sBAA6B,CAAC,KAAK,KAAK,QAAQ,WAAW;AACtE,QAAM,QAAQ,SAAS,KAAK;AAC5B,QAAM,OAAO,KAAK,WAAW,GAAG,IAAI,QAAQ,SAAS;AACrD,UAAQ,IAAI,UAAU,KAAK,GAAG,KAAK,YAAc,IAAI,GAAG,GAAG,EAAE;AAC/D;AAEO,IAAM,aAAoB,CAAC,KAAK,KAAK,UAAU;AACpD,UAAQ,IAAI,KAAK,UAAU,EAAE,KAAK,KAAK,MAAM,CAAC,CAAC;AACjD;","names":[]}

package/dist/logging/index.d.cts

@@ -1,4 +1,4 @@
-export { d as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-10ebd26a.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-fd349b27.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.d.ts

@@ -1,4 +1,4 @@
-export { d as LogFn, L as Logger, M as MessageMetadata, j as coloredStringLogger, k as jsonLogger, s as stringLogger } from '../index-10ebd26a.js';
+export { f as LogFn, L as Logger, M as MessageMetadata, h as coloredStringLogger, j as jsonLogger, s as stringLogger } from '../message-fd349b27.js';
 import '@sinclair/typebox/value';
 import '@sinclair/typebox';
 import '@opentelemetry/api';

package/dist/logging/index.js

@@ -2,7 +2,7 @@ import {
   coloredStringLogger,
   jsonLogger,
   stringLogger
-} from "../chunk-QMM35C3H.js";
+} from "../chunk-VXYHC666.js";
 export {
   coloredStringLogger,
   jsonLogger,