@replit/river 0.23.2 → 0.23.4

package/dist/index-72b688b7.d.ts

@@ -1,352 +0,0 @@
-import { ValueError } from '@sinclair/typebox/value';
-import * as _sinclair_typebox from '@sinclair/typebox';
-import { TSchema, Static } from '@sinclair/typebox';
-import { Span, Context } from '@opentelemetry/api';
-import { C as Codec } from './types-3e5768ec.js';
-
-declare const LoggingLevels: {
-    readonly debug: -1;
-    readonly info: 0;
-    readonly warn: 1;
-    readonly error: 2;
-};
-type LoggingLevel = keyof typeof LoggingLevels;
-type LogFn = (msg: string, ctx?: MessageMetadata, level?: LoggingLevel) => void;
-type Logger = {
-    [key in LoggingLevel]: (msg: string, metadata?: MessageMetadata) => void;
-};
-type Tags = 'invariant-violation';
-type MessageMetadata = Partial<{
-    protocolVersion: string;
-    clientId: string;
-    connectedTo: string;
-    sessionId: string;
-    connId: string;
-    transportMessage: Partial<OpaqueTransportMessage>;
-    validationErrors: Array<ValueError>;
-    tags: Array<Tags>;
-}>;
-declare const stringLogger: LogFn;
-declare const coloredStringLogger: LogFn;
-declare const jsonLogger: LogFn;
-declare function bindLogger(fn: LogFn | Logger | undefined, level?: LoggingLevel): void;
-
-/**
- * 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();
-    /**
-     * Handle adding a callback for when a message is received.
-     * @param msg The message that was received.
-     */
-    abstract addDataListener(cb: (msg: Uint8Array) => void): void;
-    abstract 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.
-     * @param cb The callback to call when the connection is closed.
-     */
-    abstract addCloseListener(cb: () => void): void;
-    /**
-     * Handle adding a callback for when an error is received.
-     * This should only be used for 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.
-     */
-    abstract addErrorListener(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 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;
-    /**
-     * The codec to use for encoding/decoding messages over the wire
-     */
-    codec: Codec;
-}
-/**
- * A session is a higher-level abstraction that operates over the span of potentially multiple transport-level connections
- * - It’s responsible for tracking any metadata for a particular client that might need to be persisted across connections (i.e. the sendBuffer, ack, seq)
- * - This will only be considered disconnected if
- *    - the server tells the client that we’ve reconnected but it doesn’t recognize us anymore (server definitely died) or
- *    - we hit a grace period after a connection disconnect
- */
-declare class Session<ConnType extends Connection> {
-    private codec;
-    private options;
-    telemetry: TelemetryInfo;
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    private sendBuffer;
-    /**
-     * The active connection associated with this session
-     */
-    connection?: ConnType;
-    readonly from: TransportClientId;
-    readonly to: TransportClientId;
-    /**
-     * The unique ID of this session.
-     */
-    id: string;
-    /**
-     * What the other side advertised as their session ID
-     * for this session.
-     */
-    advertisedSessionId?: string;
-    /**
-     * Number of messages we've sent along this session (excluding handshake and acks)
-     */
-    private seq;
-    /**
-     * Number of unique messages we've received this session (excluding handshake and acks)
-     */
-    private ack;
-    /**
-     * The grace period between when the inner connection is disconnected
-     * and when we should consider the entire session disconnected.
-     */
-    private disconnectionGrace?;
-    /**
-     * Number of heartbeats we've sent without a response.
-     */
-    private heartbeatMisses;
-    /**
-     * The interval for sending heartbeats.
-     */
-    private heartbeat;
-    constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions, propagationCtx?: PropagationContext);
-    get loggingMetadata(): Omit<MessageMetadata, 'parsedMsg'>;
-    /**
-     * Sends a message over the session's connection.
-     * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
-     *
-     * @param msg The partial message to be sent, which will be constructed into a full message.
-     * @param addToSendBuff Whether to add the message to the send buffer for retry.
-     * @returns The full transport ID of the message that was attempted to be sent.
-     */
-    send(msg: PartialTransportMessage): string;
-    sendHeartbeat(): void;
-    resetBufferedMessages(): void;
-    sendBufferedMessages(conn: ConnType): void;
-    updateBookkeeping(ack: number, seq: number): void;
-    closeStaleConnection(conn?: ConnType): void;
-    replaceWithNewConnection(newConn: ConnType): void;
-    beginGrace(cb: () => void): void;
-    cancelGrace(): void;
-    close(): void;
-    get connected(): boolean;
-    get nextExpectedSeq(): number;
-    constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
-    inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
-}
-
-interface PropagationContext {
-    traceparent: string;
-    tracestate: string;
-}
-interface TelemetryInfo {
-    span: Span;
-    ctx: Context;
-}
-
-/**
- * The context for services/procedures. This is used only on
- * the server.
- *
- * An important detail is that the state prop is always on
- * this interface and it shouldn't be changed, removed, or
- * extended. This prop is for the state of a service.
- *
- * You should use declaration merging to extend this interface
- * with whatever you need. For example, if you need to access
- * a database, you could do:
- *
- * ```ts
- * declare module '@replit/river' {
- *   interface ServiceContext {
- *     db: Database;
- *   }
- * }
- * ```
- */
-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.
- */
-interface ParsedMetadata {
-}
-/**
- * The {@link ServiceContext} with state. This is what is passed to procedures.
- */
-type ServiceContextWithState<State> = ServiceContext & {
-    state: State;
-};
-type ServiceContextWithTransportInfo<State> = ServiceContext & {
-    state: Omit<State, typeof Symbol.dispose>;
-    to: TransportClientId;
-    from: TransportClientId;
-    streamId: string;
-    session: Session<Connection>;
-    metadata: ParsedMetadata;
-};
-
-interface ClientHandshakeOptions<MetadataSchema extends 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: () => Static<MetadataSchema> | Promise<Static<MetadataSchema>>;
-}
-interface ServerHandshakeOptions<MetadataSchema extends 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: (metadata: Static<MetadataSchema>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
-}
-/**
- * Generic Typebox schema for a transport message.
- * @template T The type of the payload.
- * @param {T} t The payload schema.
- * @returns The transport message schema.
- */
-declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    seq: _sinclair_typebox.TInteger;
-    ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
-        traceparent: _sinclair_typebox.TString;
-        tracestate: _sinclair_typebox.TString;
-    }>>;
-    payload: T;
-}>;
-/**
- * Defines the schema for an opaque transport message that is agnostic to any
- * procedure/service.
- * @returns The transport message schema.
- */
-declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
-    id: _sinclair_typebox.TString;
-    from: _sinclair_typebox.TString;
-    to: _sinclair_typebox.TString;
-    seq: _sinclair_typebox.TInteger;
-    ack: _sinclair_typebox.TInteger;
-    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
-    streamId: _sinclair_typebox.TString;
-    controlFlags: _sinclair_typebox.TInteger;
-    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
-        traceparent: _sinclair_typebox.TString;
-        tracestate: _sinclair_typebox.TString;
-    }>>;
-    payload: _sinclair_typebox.TUnknown;
-}>;
-/**
- * Represents a transport message. This is the same type as {@link TransportMessageSchema} but
- * we can't statically infer generics from generic Typebox schemas so we have to define it again here.
- *
- * TypeScript can't enforce types when a bitmask is involved, so these are the semantics of
- * `controlFlags`:
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `streamId` must be set to a unique value
- *   (suggestion: use `nanoid`).
- * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
- * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
- *   `payload` should be discarded (usually contains a control message).
- * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
- *   contain any payload that is relevant to the application so should not be delivered.
- * @template Payload The type of the payload.
- */
-interface TransportMessage<Payload = unknown> {
-    id: string;
-    from: string;
-    to: string;
-    seq: number;
-    ack: number;
-    serviceName?: string;
-    procedureName?: string;
-    streamId: string;
-    controlFlags: number;
-    tracing?: PropagationContext;
-    payload: Payload;
-}
-type PartialTransportMessage<Payload = unknown> = Omit<TransportMessage<Payload>, 'id' | 'from' | 'to' | 'seq' | 'ack'>;
-/**
- * A type alias for a transport message with an opaque payload.
- * @template T - The type of the opaque payload.
- */
-type OpaqueTransportMessage = TransportMessage;
-type TransportClientId = string;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream open message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamOpenBit, false otherwise.
- */
-declare function isStreamOpen(controlFlag: number): boolean;
-/**
- * Checks if the given control flag (usually found in msg.controlFlag) is a stream close message.
- * @param controlFlag - The control flag to check.
- * @returns True if the control flag contains the StreamCloseBit, false otherwise.
- */
-declare function isStreamClose(controlFlag: number): boolean;
-
-export { Connection as C, Logger as L, MessageMetadata as M, OpaqueTransportMessage as O, PartialTransportMessage as P, SessionOptions as S, TransportClientId as T, ServiceContext as a, Session as b, ServerHandshakeOptions as c, ServiceContextWithState as d, ServiceContextWithTransportInfo as e, ClientHandshakeOptions as f, TransportMessageSchema as g, OpaqueTransportMessageSchema as h, TransportMessage as i, isStreamOpen as j, isStreamClose as k, PropagationContext as l, ParsedMetadata as m, coloredStringLogger as n, jsonLogger as o, bindLogger as p, LogFn as q, stringLogger as s };