@replit/river 0.6.4 → 0.7.1

package/dist/transport/impls/ws.js

@@ -1,156 +0,0 @@
-import { Transport } from '../types';
-import { NaiveJsonCodec } from '../../codec/json';
-import { log } from '../../logging';
-const defaultOptions = {
-    retryIntervalMs: 250,
-    codec: NaiveJsonCodec,
-    binaryType: 'arraybuffer',
-};
-/**
- * A transport implementation that uses a WebSocket connection with automatic reconnection.
- * @class
- * @extends Transport
- */
-export class WebSocketTransport extends Transport {
-    /**
-     * A function that returns a Promise that resolves to a WebSocket instance.
-     */
-    wsGetter;
-    ws;
-    options;
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state;
-    /**
-     * An ongoing reconnect attempt if it exists. When the attempt finishes, it contains a
-     * {@link WebSocketResult} object when a connection is established or an error occurs.
-     */
-    reconnectPromise;
-    /**
-     * An array of message IDs that are waiting to be sent over the WebSocket connection.
-     * This builds up if the WebSocket is down for a period of time.
-     */
-    sendQueue;
-    /**
-     * Creates a new WebSocketTransport instance.
-     * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-     * @param clientId The ID of the client using the transport.
-     * @param providedOptions An optional object containing configuration options for the transport.
-     */
-    constructor(wsGetter, clientId, providedOptions) {
-        const options = { ...defaultOptions, ...providedOptions };
-        super(options.codec, clientId);
-        this.state = 'open';
-        this.wsGetter = wsGetter;
-        this.options = options;
-        this.sendQueue = [];
-        this.tryConnect();
-    }
-    /**
-     * Begins a new attempt to establish a WebSocket connection.
-     */
-    async tryConnect() {
-        if (this.state !== 'open') {
-            return;
-        }
-        // wait until it's ready or we get an error
-        this.reconnectPromise ??= new Promise(async (resolve) => {
-            log?.info(`${this.clientId} -- establishing a new websocket`);
-            const ws = await this.wsGetter();
-            if (ws.readyState === ws.OPEN) {
-                return resolve({ ws });
-            }
-            if (ws.readyState === ws.CLOSING || ws.readyState === ws.CLOSED) {
-                return resolve({ err: 'ws is closing or closed' });
-            }
-            ws.addEventListener('open', function onOpen() {
-                ws.removeEventListener('open', onOpen);
-                resolve({ ws });
-            });
-            ws.addEventListener('error', function onError(err) {
-                ws.removeEventListener('error', onError);
-                resolve({ err: err.message });
-            });
-            ws.addEventListener('close', function onClose(evt) {
-                ws.removeEventListener('close', onClose);
-                resolve({ err: evt.reason });
-            });
-        });
-        const res = await this.reconnectPromise;
-        // only send if we resolved a valid websocket
-        if ('ws' in res && res.ws.readyState === res.ws.OPEN) {
-            log?.info(`${this.clientId} -- websocket ok`);
-            this.ws = res.ws;
-            this.ws.binaryType = 'arraybuffer';
-            this.ws.onmessage = (msg) => this.onMessage(msg.data);
-            this.ws.onclose = () => {
-                this.reconnectPromise = undefined;
-                this.tryConnect().catch();
-            };
-            // send outstanding
-            for (const id of this.sendQueue) {
-                const msg = this.sendBuffer.get(id);
-                if (!msg) {
-                    const err = 'tried to resend a message we received an ack for';
-                    log?.error(err);
-                    throw new Error(err);
-                }
-                log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-                this.ws.send(this.codec.toBuffer(msg));
-            }
-            this.sendQueue = [];
-            return;
-        }
-        // otherwise try and reconnect again
-        log?.warn(`${this.clientId} -- websocket failed, trying again in ${this.options.retryIntervalMs}ms`);
-        this.reconnectPromise = undefined;
-        setTimeout(() => this.tryConnect(), this.options.retryIntervalMs);
-    }
-    /**
-     * Sends a message over the WebSocket connection. If the WebSocket connection is
-     * not healthy, it will queue until the connection is successful.
-     * @param msg The message to send.
-     * @returns The ID of the sent message.
-     */
-    send(msg) {
-        const id = msg.id;
-        if (this.state === 'destroyed') {
-            const err = 'ws is destroyed, cant send';
-            log?.error(err + `: ${JSON.stringify(msg)}`);
-            throw new Error(err);
-        }
-        else if (this.state === 'closed') {
-            log?.info(`ws is closed, discarding msg: ${JSON.stringify(msg)}`);
-            return msg.id;
-        }
-        this.sendBuffer.set(id, msg);
-        if (this.ws && this.ws.readyState === this.ws.OPEN) {
-            log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
-            this.ws.send(this.codec.toBuffer(msg));
-        }
-        else {
-            log?.info(`${this.clientId} -- transport not ready, queuing ${JSON.stringify(msg)}`);
-            this.sendQueue.push(id);
-            this.tryConnect().catch();
-        }
-        return id;
-    }
-    /**
-     * Closes the WebSocket transport. Any messages sent while the transport is closed will be silently discarded.
-     */
-    async close() {
-        log?.info('closed ws transport');
-        this.state = 'closed';
-        return this.ws?.close();
-    }
-    /**
-     * Destroys the WebSocket transport. Any messages sent while the transport is closed will throw an error.
-     */
-    async destroy() {
-        log?.info('destroyed ws transport');
-        this.state = 'destroyed';
-        return this.ws?.close();
-    }
-}

package/dist/transport/impls/ws.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws.test.d.ts","sourceRoot":"","sources":["../../../transport/impls/ws.test.ts"],"names":[],"mappings":""}

package/dist/transport/types.d.ts

@@ -1,50 +0,0 @@
-import { Codec } from '../codec/types';
-import { MessageId, OpaqueTransportMessage, TransportClientId } from './message';
-/**
- * Abstract base for a transport layer for communication between nodes in a River network.
- * Any River transport methods need to implement this interface.
- * @abstract
- */
-export declare abstract class Transport {
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec: Codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId: TransportClientId;
-    /**
-     * The set of message handlers registered with this transport.
-     */
-    handlers: Set<(msg: OpaqueTransportMessage) => void>;
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    sendBuffer: Map<MessageId, OpaqueTransportMessage>;
-    /**
-     * Creates a new Transport instance.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(codec: Codec, clientId: TransportClientId);
-    /**
-     * 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.
-     */
-    onMessage(msg: Uint8Array): void;
-    /**
-     * Adds a message listener to this transport.
-     * @param handler The message handler to add.
-     */
-    addMessageListener(handler: (msg: OpaqueTransportMessage) => void): void;
-    /**
-     * Removes a message listener from this transport.
-     * @param handler The message handler to remove.
-     */
-    removeMessageListener(handler: (msg: OpaqueTransportMessage) => void): void;
-    abstract send(msg: OpaqueTransportMessage): MessageId;
-    abstract close(): Promise<void>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../transport/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAEL,SAAS,EACT,sBAAsB,EAGtB,iBAAiB,EAGlB,MAAM,WAAW,CAAC;AAGnB;;;;GAIG;AACH,8BAAsB,SAAS;IAC7B;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,iBAAiB,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,GAAG,CAAC,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,CAAC,CAAC;IAGrD;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,sBAAsB,CAAC,CAAC;IAEnD;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB;IAOrD;;;;OAIG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU;IAoDzB;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAIxE;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,IAAI,GAAG,IAAI;IAI3E,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IACrD,QAAQ,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAChC"}

package/dist/transport/types.js

@@ -1,95 +0,0 @@
-import { Value } from '@sinclair/typebox/value';
-import { OpaqueTransportMessageSchema, TransportAckSchema, isAck, reply, } from './message';
-import { log } from '../logging';
-/**
- * Abstract base for a transport layer for communication between nodes in a River network.
- * Any River transport methods need to implement this interface.
- * @abstract
- */
-export class Transport {
-    /**
-     * The {@link Codec} used to encode and decode messages.
-     */
-    codec;
-    /**
-     * The client ID of this transport.
-     */
-    clientId;
-    /**
-     * The set of message handlers registered with this transport.
-     */
-    handlers;
-    // TODO; we can do much better here on retry (maybe resending the sendBuffer on fixed interval)
-    /**
-     * The buffer of messages that have been sent but not yet acknowledged.
-     */
-    sendBuffer;
-    /**
-     * Creates a new Transport instance.
-     * @param codec The codec used to encode and decode messages.
-     * @param clientId The client ID of this transport.
-     */
-    constructor(codec, clientId) {
-        this.handlers = new Set();
-        this.sendBuffer = new Map();
-        this.codec = codec;
-        this.clientId = clientId;
-    }
-    /**
-     * 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.
-     */
-    onMessage(msg) {
-        const parsedMsg = this.codec.fromBuffer(msg);
-        if (parsedMsg === null) {
-            log?.warn(`${this.clientId} -- received malformed msg: ${new TextDecoder().decode(msg)}`);
-            return;
-        }
-        let stringifiedMessage;
-        if (log) {
-            stringifiedMessage = JSON.stringify(parsedMsg);
-        }
-        if (Value.Check(TransportAckSchema, parsedMsg) &&
-            isAck(parsedMsg.controlFlags)) {
-            // process ack
-            log?.info(`${this.clientId} -- received ack: ${stringifiedMessage}`);
-            if (this.sendBuffer.has(parsedMsg.payload.ack)) {
-                this.sendBuffer.delete(parsedMsg.payload.ack);
-            }
-        }
-        else if (Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
-            // regular river message
-            log?.info(`${this.clientId} -- received msg: ${stringifiedMessage}`);
-            // ignore if not for us
-            if (parsedMsg.to !== this.clientId && parsedMsg.to !== 'broadcast') {
-                return;
-            }
-            // handle actual message
-            for (const handler of this.handlers) {
-                handler(parsedMsg);
-            }
-            const ackMsg = reply(parsedMsg, { ack: parsedMsg.id });
-            ackMsg.controlFlags = 1 /* ControlFlags.AckBit */;
-            ackMsg.from = this.clientId;
-            this.send(ackMsg);
-        }
-        else {
-            log?.warn(`${this.clientId} -- received invalid transport msg: ${stringifiedMessage}`);
-        }
-    }
-    /**
-     * Adds a message listener to this transport.
-     * @param handler The message handler to add.
-     */
-    addMessageListener(handler) {
-        this.handlers.add(handler);
-    }
-    /**
-     * Removes a message listener from this transport.
-     * @param handler The message handler to remove.
-     */
-    removeMessageListener(handler) {
-        this.handlers.delete(handler);
-    }
-}