@replit/river 0.10.0 → 0.10.2

package/dist/chunk-PC65ZFWJ.js

@@ -0,0 +1,29 @@
+import {
+  Connection
+} from "./chunk-AJQU4AZG.js";
+
+// transport/impls/ws/connection.ts
+var WebSocketConnection = class extends Connection {
+  ws;
+  constructor(transport, connectedTo, ws) {
+    super(transport, connectedTo);
+    this.ws = ws;
+    ws.binaryType = "arraybuffer";
+    this.ws.onmessage = (msg) => transport.onMessage(msg.data);
+  }
+  send(payload) {
+    if (this.ws.readyState === this.ws.OPEN) {
+      this.ws.send(payload);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async close() {
+    this.ws.close();
+  }
+};
+
+export {
+  WebSocketConnection
+};

package/dist/chunk-R6H2BIMC.js

@@ -0,0 +1,49 @@
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        let val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
+        if (val?.$t) {
+          return base64ToUint8Array(val.$t);
+        } else {
+          return val;
+        }
+      });
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  NaiveJsonCodec
+};

package/dist/chunk-RGMHF6PF.js

@@ -0,0 +1,65 @@
+import {
+  WebSocketConnection
+} from "./chunk-PC65ZFWJ.js";
+import {
+  NaiveJsonCodec
+} from "./chunk-R6H2BIMC.js";
+import {
+  Transport
+} from "./chunk-AJQU4AZG.js";
+import {
+  log
+} from "./chunk-SLUSVGQH.js";
+
+// transport/impls/ws/server.ts
+var defaultOptions = {
+  codec: NaiveJsonCodec
+};
+var WebSocketServerTransport = class extends Transport {
+  wss;
+  clientId;
+  constructor(wss, clientId, providedOptions) {
+    const options = { ...defaultOptions, ...providedOptions };
+    super(options.codec, clientId);
+    this.wss = wss;
+    this.clientId = clientId;
+    this.setupConnectionStatusListeners();
+  }
+  connectionHandler = (ws) => {
+    let conn = void 0;
+    ws.onmessage = (msg) => {
+      const parsedMsg = this.parseMsg(msg.data);
+      if (parsedMsg && !conn) {
+        conn = new WebSocketConnection(this, parsedMsg.from, ws);
+        this.onConnect(conn);
+        this.handleMsg(parsedMsg);
+      }
+    };
+    ws.onclose = () => {
+      if (conn) {
+        this.onDisconnect(conn);
+      }
+    };
+    ws.onerror = (msg) => {
+      log?.warn(
+        `${this.clientId} -- ws error from client ${conn?.connectedTo ?? "unknown"}: ${msg}`
+      );
+    };
+  };
+  setupConnectionStatusListeners() {
+    this.wss.on("connection", this.connectionHandler);
+  }
+  async createNewConnection(to) {
+    const err = `${this.clientId} -- failed to send msg to ${to}, client probably dropped`;
+    log?.warn(err);
+    return;
+  }
+  async close() {
+    super.close();
+    this.wss.off("connection", this.connectionHandler);
+  }
+};
+
+export {
+  WebSocketServerTransport
+};

package/dist/chunk-SLUSVGQH.js

@@ -0,0 +1,30 @@
+// logging/index.ts
+var LoggingLevels = {
+  info: 0,
+  warn: 1,
+  error: 2
+};
+var log;
+var defaultLoggingLevel = "warn";
+function bindLogger(write, color) {
+  const info = color ? "\x1B[37minfo\x1B[0m" : "info";
+  const warn = color ? "\x1B[33mwarn\x1B[0m" : "warn";
+  const error = color ? "\x1B[31merr\x1B[0m" : "err";
+  log = {
+    info: (msg) => log && LoggingLevels[log.minLevel] <= 0 && write(`[river:${info}] ${msg}`),
+    warn: (msg) => log && LoggingLevels[log.minLevel] <= 1 && write(`[river:${warn}] ${msg}`),
+    error: (msg) => log && LoggingLevels[log.minLevel] <= 2 && write(`[river:${error}] ${msg}`),
+    minLevel: log?.minLevel ?? defaultLoggingLevel
+  };
+}
+function setLevel(level) {
+  if (log) {
+    log.minLevel = level;
+  }
+}
+
+export {
+  log,
+  bindLogger,
+  setLevel
+};

package/dist/chunk-UU2Z7LDR.js

@@ -0,0 +1,113 @@
+import {
+  WebSocketConnection
+} from "./chunk-PC65ZFWJ.js";
+import {
+  NaiveJsonCodec
+} from "./chunk-R6H2BIMC.js";
+import {
+  Transport
+} from "./chunk-AJQU4AZG.js";
+import {
+  log
+} from "./chunk-SLUSVGQH.js";
+
+// transport/impls/ws/client.ts
+var defaultOptions = {
+  retryIntervalMs: 250,
+  retryAttemptsMax: 5,
+  codec: NaiveJsonCodec
+};
+var WebSocketClientTransport = class extends Transport {
+  /**
+   * A function that returns a Promise that resolves to a WebSocket instance.
+   */
+  wsGetter;
+  options;
+  serverId;
+  reconnectPromises;
+  tryReconnecting = true;
+  /**
+   * 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, serverId, providedOptions) {
+    const options = { ...defaultOptions, ...providedOptions };
+    super(options.codec, clientId);
+    this.wsGetter = wsGetter;
+    this.serverId = serverId;
+    this.options = options;
+    this.reconnectPromises = /* @__PURE__ */ new Map();
+    this.setupConnectionStatusListeners();
+  }
+  setupConnectionStatusListeners() {
+    this.createNewConnection(this.serverId);
+  }
+  async createNewConnection(to, attempt = 0) {
+    if (this.state === "destroyed") {
+      throw new Error("cant reopen a destroyed connection");
+    }
+    let reconnectPromise = this.reconnectPromises.get(to);
+    if (!reconnectPromise) {
+      if (!this.tryReconnecting) {
+        log?.info(
+          `${this.clientId} -- tryReconnecting is false, not attempting reconnect`
+        );
+        return;
+      }
+      reconnectPromise = new Promise(async (resolve) => {
+        log?.info(`${this.clientId} -- establishing a new websocket to ${to}`);
+        const ws = await this.wsGetter(to);
+        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("close", function onClose(evt) {
+          ws.removeEventListener("close", onClose);
+          resolve({ err: evt.reason });
+        });
+      });
+      this.reconnectPromises.set(to, reconnectPromise);
+    }
+    const res = await reconnectPromise;
+    if ("ws" in res && res.ws.readyState === res.ws.OPEN) {
+      if (res.ws === this.connections.get(to)?.ws) {
+        return;
+      }
+      log?.info(`${this.clientId} -- websocket ok`);
+      const conn = new WebSocketConnection(this, to, res.ws);
+      this.onConnect(conn);
+      res.ws.onclose = () => {
+        this.reconnectPromises.delete(to);
+        this.onDisconnect(conn);
+      };
+      this.state = "open";
+      return;
+    }
+    this.reconnectPromises.delete(to);
+    if (attempt >= this.options.retryAttemptsMax) {
+      throw new Error(
+        `${this.clientId} -- websocket to ${to} failed after ${attempt} attempts, giving up`
+      );
+    } else {
+      log?.warn(
+        `${this.clientId} -- websocket to ${to} failed, trying again in ${this.options.retryIntervalMs * attempt}ms`
+      );
+      setTimeout(
+        () => this.createNewConnection(to, attempt + 1),
+        this.options.retryIntervalMs * attempt
+      );
+    }
+  }
+};
+
+export {
+  WebSocketClientTransport
+};

package/dist/chunk-WVT5QXMZ.js

@@ -0,0 +1,20 @@
+// codec/binary.ts
+import { decode, encode } from "@msgpack/msgpack";
+var BinaryCodec = {
+  toBuffer: encode,
+  fromBuffer: (buff) => {
+    try {
+      const res = decode(buff);
+      if (typeof res !== "object") {
+        return null;
+      }
+      return res;
+    } catch {
+      return null;
+    }
+  }
+};
+
+export {
+  BinaryCodec
+};

package/dist/chunk-ZE4MX7DF.js

@@ -0,0 +1,75 @@
+// transport/message.ts
+import { Type } from "@sinclair/typebox";
+import { nanoid } from "nanoid";
+var TransportMessageSchema = (t) => Type.Object({
+  id: Type.String(),
+  from: Type.String(),
+  to: Type.String(),
+  serviceName: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  procedureName: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+  streamId: Type.String(),
+  controlFlags: Type.Integer(),
+  payload: t
+});
+var TransportAckSchema = TransportMessageSchema(
+  Type.Object({
+    ack: Type.String()
+  })
+);
+var ControlMessagePayloadSchema = Type.Object({
+  type: Type.Literal("CLOSE")
+});
+var OpaqueTransportMessageSchema = TransportMessageSchema(
+  Type.Unknown()
+);
+function msg(from, to, streamId, payload, serviceName, procedureName) {
+  return {
+    id: nanoid(),
+    to,
+    from,
+    serviceName,
+    procedureName,
+    streamId,
+    controlFlags: 0,
+    payload
+  };
+}
+function reply(msg2, response) {
+  return {
+    id: nanoid(),
+    streamId: msg2.streamId,
+    controlFlags: 0,
+    to: msg2.from,
+    from: msg2.to,
+    payload: response
+  };
+}
+function closeStream(from, to, stream) {
+  const closeMessage = msg(from, to, stream, {
+    type: "CLOSE"
+  });
+  closeMessage.controlFlags |= 4 /* StreamClosedBit */;
+  return closeMessage;
+}
+function isAck(controlFlag) {
+  return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
+}
+function isStreamOpen(controlFlag) {
+  return (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */;
+}
+function isStreamClose(controlFlag) {
+  return (controlFlag & 4 /* StreamClosedBit */) === 4 /* StreamClosedBit */;
+}
+
+export {
+  TransportMessageSchema,
+  TransportAckSchema,
+  ControlMessagePayloadSchema,
+  OpaqueTransportMessageSchema,
+  msg,
+  reply,
+  closeStream,
+  isAck,
+  isStreamOpen,
+  isStreamClose
+};

package/dist/codec/index.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// codec/index.ts
+var codec_exports = {};
+__export(codec_exports, {
+  BinaryCodec: () => BinaryCodec,
+  NaiveJsonCodec: () => NaiveJsonCodec
+});
+module.exports = __toCommonJS(codec_exports);
+
+// codec/binary.ts
+var import_msgpack = require("@msgpack/msgpack");
+var BinaryCodec = {
+  toBuffer: import_msgpack.encode,
+  fromBuffer: (buff) => {
+    try {
+      const res = (0, import_msgpack.decode)(buff);
+      if (typeof res !== "object") {
+        return null;
+      }
+      return res;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// codec/json.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  uint8Array.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const uint8Array = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+  return uint8Array;
+}
+var NaiveJsonCodec = {
+  toBuffer: (obj) => {
+    return encoder.encode(
+      JSON.stringify(obj, function replacer(key) {
+        let val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
+        if (val?.$t) {
+          return base64ToUint8Array(val.$t);
+        } else {
+          return val;
+        }
+      });
+    } catch {
+      return null;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BinaryCodec,
+  NaiveJsonCodec
+});

package/dist/codec/index.d.cts

@@ -0,0 +1,15 @@
+import { C as Codec } from '../types-3e5768ec.js';
+
+/**
+ * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
+ * @type {Codec}
+ */
+declare const BinaryCodec: Codec;
+
+/**
+ * Naive JSON codec implementation using JSON.stringify and JSON.parse.
+ * @type {Codec}
+ */
+declare const NaiveJsonCodec: Codec;
+
+export { BinaryCodec, Codec, NaiveJsonCodec };

package/dist/codec/index.d.ts

@@ -1,4 +1,15 @@
-export { BinaryCodec } from './binary';
-export { NaiveJsonCodec } from './json';
-export type { Codec } from './types';
-//# sourceMappingURL=index.d.ts.map
+import { C as Codec } from '../types-3e5768ec.js';
+
+/**
+ * Binary codec, uses [msgpack](https://www.npmjs.com/package/@msgpack/msgpack) under the hood
+ * @type {Codec}
+ */
+declare const BinaryCodec: Codec;
+
+/**
+ * Naive JSON codec implementation using JSON.stringify and JSON.parse.
+ * @type {Codec}
+ */
+declare const NaiveJsonCodec: Codec;
+
+export { BinaryCodec, Codec, NaiveJsonCodec };

package/dist/codec/index.js

@@ -1,2 +1,10 @@
-export { BinaryCodec } from './binary';
-export { NaiveJsonCodec } from './json';
+import {
+  BinaryCodec
+} from "../chunk-WVT5QXMZ.js";
+import {
+  NaiveJsonCodec
+} from "../chunk-R6H2BIMC.js";
+export {
+  BinaryCodec,
+  NaiveJsonCodec
+};

package/dist/connection-8e19874c.d.ts

@@ -0,0 +1,11 @@
+import { Connection, Transport, TransportClientId } from './transport/index.js';
+import WebSocket from 'isomorphic-ws';
+
+declare class WebSocketConnection extends Connection {
+    ws: WebSocket;
+    constructor(transport: Transport<WebSocketConnection>, connectedTo: TransportClientId, ws: WebSocket);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+
+export { WebSocketConnection as W };

package/dist/connection-f7688cc1.d.ts

@@ -0,0 +1,11 @@
+import { Connection, Transport, TransportClientId } from './transport/index.cjs';
+import WebSocket from 'isomorphic-ws';
+
+declare class WebSocketConnection extends Connection {
+    ws: WebSocket;
+    constructor(transport: Transport<WebSocketConnection>, connectedTo: TransportClientId, ws: WebSocket);
+    send(payload: Uint8Array): boolean;
+    close(): Promise<void>;
+}
+
+export { WebSocketConnection as W };

package/dist/logging/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// logging/index.ts
+var logging_exports = {};
+__export(logging_exports, {
+  bindLogger: () => bindLogger,
+  log: () => log,
+  setLevel: () => setLevel
+});
+module.exports = __toCommonJS(logging_exports);
+var LoggingLevels = {
+  info: 0,
+  warn: 1,
+  error: 2
+};
+var log;
+var defaultLoggingLevel = "warn";
+function bindLogger(write, color) {
+  const info = color ? "\x1B[37minfo\x1B[0m" : "info";
+  const warn = color ? "\x1B[33mwarn\x1B[0m" : "warn";
+  const error = color ? "\x1B[31merr\x1B[0m" : "err";
+  log = {
+    info: (msg) => log && LoggingLevels[log.minLevel] <= 0 && write(`[river:${info}] ${msg}`),
+    warn: (msg) => log && LoggingLevels[log.minLevel] <= 1 && write(`[river:${warn}] ${msg}`),
+    error: (msg) => log && LoggingLevels[log.minLevel] <= 2 && write(`[river:${error}] ${msg}`),
+    minLevel: log?.minLevel ?? defaultLoggingLevel
+  };
+}
+function setLevel(level) {
+  if (log) {
+    log.minLevel = level;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindLogger,
+  log,
+  setLevel
+});

package/dist/logging/index.d.cts

@@ -0,0 +1,28 @@
+declare const LoggingLevels: {
+    readonly info: 0;
+    readonly warn: 1;
+    readonly error: 2;
+};
+type LoggingLevel = keyof typeof LoggingLevels;
+type Logger = {
+    minLevel: LoggingLevel;
+} & {
+    [key in LoggingLevel]: (msg: string) => void;
+};
+/**
+ * The global River logger instance.
+ */
+declare let log: Logger | undefined;
+/**
+ * Binds the given write function to River's logger {@link log}.
+ * @param write - The function to write log messages.
+ * @param color - Whether to use colored log levels.
+ */
+declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
+/**
+ * Sets the minimum logging level for the logger.
+ * @param level - The minimum logging level to set.
+ */
+declare function setLevel(level: LoggingLevel): void;
+
+export { Logger, bindLogger, log, setLevel };

package/dist/logging/index.d.ts

@@ -4,7 +4,7 @@ declare const LoggingLevels: {
     readonly error: 2;
 };
 type LoggingLevel = keyof typeof LoggingLevels;
-export type Logger = {
+type Logger = {
     minLevel: LoggingLevel;
 } & {
     [key in LoggingLevel]: (msg: string) => void;
@@ -12,17 +12,17 @@ export type Logger = {
 /**
  * The global River logger instance.
  */
-export declare let log: Logger | undefined;
+declare let log: Logger | undefined;
 /**
  * Binds the given write function to River's logger {@link log}.
  * @param write - The function to write log messages.
  * @param color - Whether to use colored log levels.
  */
-export declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
+declare function bindLogger(write: (msg: string) => void, color?: boolean): void;
 /**
  * Sets the minimum logging level for the logger.
  * @param level - The minimum logging level to set.
  */
-export declare function setLevel(level: LoggingLevel): void;
-export {};
-//# sourceMappingURL=index.d.ts.map
+declare function setLevel(level: LoggingLevel): void;
+
+export { Logger, bindLogger, log, setLevel };