@replit/river 0.12.6 → 0.13.0

package/dist/util/testHelpers.cjs

@@ -48,6 +48,276 @@ module.exports = __toCommonJS(testHelpers_exports);
 var import_isomorphic_ws = __toESM(require("isomorphic-ws"), 1);
 var import_ws = require("ws");
 
+// logging/index.ts
+var log;
+
+// transport/session.ts
+var import_nanoid = require("nanoid");
+
+// 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) {
+        const val = this[key];
+        if (val instanceof Uint8Array) {
+          return { $t: uint8ArrayToBase64(val) };
+        } else {
+          return val;
+        }
+      })
+    );
+  },
+  fromBuffer: (buff) => {
+    try {
+      const parsed = JSON.parse(
+        decoder.decode(buff),
+        function reviver(_key, val) {
+          if (val?.$t) {
+            return base64ToUint8Array(val.$t);
+          } else {
+            return val;
+          }
+        }
+      );
+      if (typeof parsed === "object")
+        return parsed;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// transport/session.ts
+var nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvxyz", 6);
+var unsafeId = () => nanoid();
+var HEARTBEAT_INTERVAL_MS = 1e3;
+var HEARTBEATS_TILL_DEAD = 2;
+var SESSION_DISCONNECT_GRACE_MS = 5e3;
+var defaultSessionOptions = {
+  heartbeatIntervalMs: HEARTBEAT_INTERVAL_MS,
+  heartbeatsUntilDead: HEARTBEATS_TILL_DEAD,
+  sessionDisconnectGraceMs: SESSION_DISCONNECT_GRACE_MS,
+  codec: NaiveJsonCodec
+};
+var Session = class {
+  codec;
+  options;
+  /**
+   * The buffer of messages that have been sent but not yet acknowledged.
+   */
+  sendBuffer = [];
+  /**
+   * The active connection associated with this session
+   */
+  connection;
+  from;
+  to;
+  /**
+   * The unique ID of this session.
+   */
+  debugId;
+  /**
+   * Number of messages we've sent along this session (excluding handshake)
+   */
+  seq = 0;
+  /**
+   * Number of unique messages we've received this session (excluding handshake)
+   */
+  ack = 0;
+  /**
+   * The grace period between when the inner connection is disconnected
+   * and when we should consider the entire session disconnected.
+   */
+  disconnectionGrace;
+  /**
+   * Number of heartbeats we've sent without a response.
+   */
+  heartbeatMisses;
+  /**
+   * The interval for sending heartbeats.
+   */
+  heartbeat;
+  constructor(from, connectedTo, conn, options) {
+    this.options = options;
+    this.debugId = `sess-${unsafeId()}`;
+    this.from = from;
+    this.to = connectedTo;
+    this.connection = conn;
+    this.codec = options.codec;
+    this.heartbeatMisses = 0;
+    this.heartbeat = setInterval(
+      () => this.sendHeartbeat(),
+      options.heartbeatIntervalMs
+    );
+  }
+  /**
+   * 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 skipRetry Optional. If true, the message will not be buffered for retry on failure. This should only be used for
+   * ack hearbeats, which contain information that can already be found in the other buffered messages.
+   * @returns The full transport ID of the message that was attempted to be sent.
+   */
+  send(msg, skipRetry) {
+    const fullMsg = this.constructMsg(msg);
+    log?.debug(`${this.from} -- sending ${JSON.stringify(fullMsg)}`);
+    if (this.connection) {
+      const ok = this.connection.send(this.codec.toBuffer(fullMsg));
+      if (ok)
+        return fullMsg.id;
+      log?.info(
+        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection (id: ${this.connection.debugId}) is probably dead`
+      );
+    } else {
+      log?.info(
+        `${this.from} -- failed to send ${fullMsg.id} to ${fullMsg.to}, connection not ready yet`
+      );
+    }
+    if (skipRetry)
+      return fullMsg.id;
+    this.addToSendBuff(fullMsg);
+    log?.info(
+      `${this.from} -- buffering msg ${fullMsg.id} until connection is healthy again`
+    );
+    return fullMsg.id;
+  }
+  sendHeartbeat() {
+    if (this.heartbeatMisses >= this.options.heartbeatsUntilDead) {
+      if (this.connection) {
+        log?.info(
+          `${this.from} -- closing connection (id: ${this.connection.debugId}) to ${this.to} due to inactivity`
+        );
+        this.closeStaleConnection(this.connection);
+      }
+      return;
+    }
+    this.send(
+      {
+        streamId: "heartbeat",
+        controlFlags: 1 /* AckBit */,
+        payload: {
+          type: "ACK"
+        }
+      },
+      true
+    );
+    this.heartbeatMisses++;
+  }
+  resetBufferedMessages() {
+    this.sendBuffer = [];
+    this.seq = 0;
+    this.ack = 0;
+  }
+  sendBufferedMessages() {
+    if (!this.connection) {
+      const msg = `${this.from} -- tried sending buffered messages without a connection (if you hit this code path something is seriously wrong)`;
+      log?.error(msg);
+      throw new Error(msg);
+    }
+    for (const msg of this.sendBuffer) {
+      log?.debug(`${this.from} -- resending ${JSON.stringify(msg)}`);
+      const ok = this.connection.send(this.codec.toBuffer(msg));
+      if (!ok) {
+        const msg2 = `${this.from} -- failed to send buffered message to ${this.to} in session (id: ${this.debugId}) (if you hit this code path something is seriously wrong)`;
+        log?.error(msg2);
+        throw new Error(msg2);
+      }
+    }
+  }
+  updateBookkeeping(ack, seq) {
+    this.sendBuffer = this.sendBuffer.filter((unacked) => unacked.seq > ack);
+    this.ack = seq + 1;
+  }
+  addToSendBuff(msg) {
+    this.sendBuffer.push(msg);
+    log?.debug(
+      `${this.from} -- send buff to ${this.to} now tracking ${this.sendBuffer.length} messages`
+    );
+  }
+  closeStaleConnection(conn) {
+    if (!this.connection || this.connection !== conn)
+      return;
+    log?.info(
+      `${this.from} -- closing old inner connection (id: ${this.connection.debugId}) from session (id: ${this.debugId}) to ${this.to}`
+    );
+    this.connection.close();
+    this.connection = void 0;
+  }
+  replaceWithNewConnection(newConn) {
+    this.closeStaleConnection(this.connection);
+    this.cancelGrace();
+    this.connection = newConn;
+  }
+  beginGrace(cb) {
+    this.disconnectionGrace = setTimeout(() => {
+      this.close();
+      cb();
+    }, this.options.sessionDisconnectGraceMs);
+  }
+  // called on reconnect of the underlying session
+  cancelGrace() {
+    this.heartbeatMisses = 0;
+    clearTimeout(this.disconnectionGrace);
+  }
+  // closed when we want to discard the whole session
+  // (i.e. shutdown or session disconnect)
+  close() {
+    this.closeStaleConnection(this.connection);
+    this.cancelGrace();
+    this.resetBufferedMessages();
+    clearInterval(this.heartbeat);
+  }
+  get connected() {
+    return this.connection !== void 0;
+  }
+  get nextExpectedSeq() {
+    return this.ack;
+  }
+  constructMsg(partialMsg) {
+    const msg = {
+      ...partialMsg,
+      id: unsafeId(),
+      to: this.to,
+      from: this.from,
+      seq: this.seq,
+      ack: this.ack
+    };
+    this.seq++;
+    return msg;
+  }
+  inspectSendBuffer() {
+    return this.sendBuffer;
+  }
+};
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
 // node_modules/p-defer/index.js
 function pDefer() {
   const deferred = {};
@@ -342,16 +612,8 @@ var RiverUncaughtSchema = import_typebox.Type.Object({
   message: import_typebox.Type.String()
 });
 
-// util/stringify.ts
-function coerceErrorString(err) {
-  if (err instanceof Error) {
-    return err.message;
-  }
-  return `[coerced to error] ${String(err)}`;
-}
-
 // util/testHelpers.ts
-var import_nanoid = require("nanoid");
+var import_nanoid2 = require("nanoid");
 function createWebSocketServer(server) {
   return new import_ws.WebSocketServer({ server });
 }
@@ -419,9 +681,25 @@ function catchProcError(err) {
     }
   };
 }
+function dummyCtx(state, extendedContext) {
+  const session = new Session(
+    "client",
+    "SERVER",
+    void 0,
+    defaultSessionOptions
+  );
+  return {
+    ...extendedContext,
+    state,
+    to: "SERVER",
+    from: "client",
+    streamId: (0, import_nanoid2.nanoid)(),
+    session
+  };
+}
 function asClientRpc(state, proc, extendedContext) {
   return async (msg) => {
-    return await proc.handler({ ...extendedContext, state }, msg).catch(catchProcError);
+    return await proc.handler(dummyCtx(state, extendedContext), msg).catch(catchProcError);
   };
 }
 function asClientStream(state, proc, init, extendedContext) {
@@ -432,10 +710,10 @@ function asClientStream(state, proc, init, extendedContext) {
   void (async () => {
     if (init) {
       const _proc = proc;
-      await _proc.handler({ ...extendedContext, state }, init, input, output).catch((err) => output.push(catchProcError(err)));
+      await _proc.handler(dummyCtx(state, extendedContext), init, input, output).catch((err) => output.push(catchProcError(err)));
     } else {
       const _proc = proc;
-      await _proc.handler({ ...extendedContext, state }, input, output).catch((err) => output.push(catchProcError(err)));
+      await _proc.handler(dummyCtx(state, extendedContext), input, output).catch((err) => output.push(catchProcError(err)));
     }
   })();
   return [input, output];
@@ -446,7 +724,7 @@ function asClientSubscription(state, proc, extendedContext) {
   });
   return (msg) => {
     void (async () => {
-      return await proc.handler({ ...extendedContext, state }, msg, output).catch((err) => output.push(catchProcError(err)));
+      return await proc.handler(dummyCtx(state, extendedContext), msg, output).catch((err) => output.push(catchProcError(err)));
     })();
     return output;
   };
@@ -455,16 +733,16 @@ function asClientUpload(state, proc, init, extendedContext) {
   const input = pushable({ objectMode: true });
   if (init) {
     const _proc = proc;
-    const result = _proc.handler({ ...extendedContext, state }, init, input).catch(catchProcError);
+    const result = _proc.handler(dummyCtx(state, extendedContext), init, input).catch(catchProcError);
     return [input, result];
   } else {
     const _proc = proc;
-    const result = _proc.handler({ ...extendedContext, state }, input).catch(catchProcError);
+    const result = _proc.handler(dummyCtx(state, extendedContext), input).catch(catchProcError);
     return [input, result];
   }
 }
 var getUnixSocketPath = () => {
-  return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid.nanoid)()}` : `/tmp/${(0, import_nanoid.nanoid)()}.sock`;
+  return process.platform === "win32" ? `\\\\?\\pipe\\${(0, import_nanoid2.nanoid)()}` : `/tmp/${(0, import_nanoid2.nanoid)()}.sock`;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/util/testHelpers.d.cts

@@ -1,8 +1,8 @@
 import * as it_pushable from 'it-pushable';
 import WebSocket from 'isomorphic-ws';
 import http from 'node:http';
-import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-54e0f99c.js';
-import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-c593de11.js';
+import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-21c1b21d.js';
+import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-169fbf7f.js';
 import { Static } from '@sinclair/typebox';
 import net from 'node:net';
 import '../types-3e5768ec.js';

package/dist/util/testHelpers.d.ts

@@ -1,8 +1,8 @@
 import * as it_pushable from 'it-pushable';
 import WebSocket from 'isomorphic-ws';
 import http from 'node:http';
-import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-54e0f99c.js';
-import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-c593de11.js';
+import { P as PartialTransportMessage, T as Transport, C as Connection, O as OpaqueTransportMessage } from '../index-21c1b21d.js';
+import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-169fbf7f.js';
 import { Static } from '@sinclair/typebox';
 import net from 'node:net';
 import '../types-3e5768ec.js';

package/dist/util/testHelpers.js

@@ -1,11 +1,17 @@
 import {
   UNCAUGHT_ERROR,
   pushable
-} from "../chunk-AFLZ6INU.js";
+} from "../chunk-CBRQM65K.js";
+import "../chunk-5IZ2UHWV.js";
+import {
+  Session,
+  defaultSessionOptions
+} from "../chunk-R2IMXRVU.js";
 import {
   coerceErrorString
-} from "../chunk-XFFS4UOD.js";
+} from "../chunk-MGGIUH5O.js";
 import "../chunk-H4BYJELI.js";
+import "../chunk-GZ7HCLLM.js";
 
 // util/testHelpers.ts
 import WebSocket from "isomorphic-ws";
@@ -78,9 +84,25 @@ function catchProcError(err) {
     }
   };
 }
+function dummyCtx(state, extendedContext) {
+  const session = new Session(
+    "client",
+    "SERVER",
+    void 0,
+    defaultSessionOptions
+  );
+  return {
+    ...extendedContext,
+    state,
+    to: "SERVER",
+    from: "client",
+    streamId: nanoid(),
+    session
+  };
+}
 function asClientRpc(state, proc, extendedContext) {
   return async (msg) => {
-    return await proc.handler({ ...extendedContext, state }, msg).catch(catchProcError);
+    return await proc.handler(dummyCtx(state, extendedContext), msg).catch(catchProcError);
   };
 }
 function asClientStream(state, proc, init, extendedContext) {
@@ -91,10 +113,10 @@ function asClientStream(state, proc, init, extendedContext) {
   void (async () => {
     if (init) {
       const _proc = proc;
-      await _proc.handler({ ...extendedContext, state }, init, input, output).catch((err) => output.push(catchProcError(err)));
+      await _proc.handler(dummyCtx(state, extendedContext), init, input, output).catch((err) => output.push(catchProcError(err)));
     } else {
       const _proc = proc;
-      await _proc.handler({ ...extendedContext, state }, input, output).catch((err) => output.push(catchProcError(err)));
+      await _proc.handler(dummyCtx(state, extendedContext), input, output).catch((err) => output.push(catchProcError(err)));
     }
   })();
   return [input, output];
@@ -105,7 +127,7 @@ function asClientSubscription(state, proc, extendedContext) {
   });
   return (msg) => {
     void (async () => {
-      return await proc.handler({ ...extendedContext, state }, msg, output).catch((err) => output.push(catchProcError(err)));
+      return await proc.handler(dummyCtx(state, extendedContext), msg, output).catch((err) => output.push(catchProcError(err)));
     })();
     return output;
   };
@@ -114,11 +136,11 @@ function asClientUpload(state, proc, init, extendedContext) {
   const input = pushable({ objectMode: true });
   if (init) {
     const _proc = proc;
-    const result = _proc.handler({ ...extendedContext, state }, init, input).catch(catchProcError);
+    const result = _proc.handler(dummyCtx(state, extendedContext), init, input).catch(catchProcError);
     return [input, result];
   } else {
     const _proc = proc;
-    const result = _proc.handler({ ...extendedContext, state }, input).catch(catchProcError);
+    const result = _proc.handler(dummyCtx(state, extendedContext), input).catch(catchProcError);
     return [input, result];
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.12.6",
+  "version": "0.13.0",
   "type": "module",
   "exports": {
     ".": {
@@ -36,14 +36,6 @@
       "import": "./dist/transport/impls/uds/server.js",
       "require": "./dist/transport/impls/uds/server.cjs"
     },
-    "./transport/stdio/client": {
-      "import": "./dist/transport/impls/stdio/client.js",
-      "require": "./dist/transport/impls/stdio/client.cjs"
-    },
-    "./transport/stdio/server": {
-      "import": "./dist/transport/impls/stdio/server.js",
-      "require": "./dist/transport/impls/stdio/server.cjs"
-    },
     "./test-util": {
       "import": "./dist/util/testHelpers.js",
       "require": "./dist/util/testHelpers.cjs"

package/dist/chunk-PBPXYLI6.js

@@ -1,44 +0,0 @@
-import {
-  MessageFramer
-} from "./chunk-IIBVKYDB.js";
-import {
-  Connection
-} from "./chunk-4SDJ5VN4.js";
-
-// transport/impls/uds/connection.ts
-var UdsConnection = class extends Connection {
-  sock;
-  input;
-  framer;
-  constructor(sock) {
-    super();
-    this.framer = MessageFramer.createFramedStream();
-    this.sock = sock;
-    this.input = sock.pipe(this.framer);
-  }
-  addDataListener(cb) {
-    this.input.on("data", cb);
-  }
-  removeDataListener(cb) {
-    this.input.off("data", cb);
-  }
-  addCloseListener(cb) {
-    this.sock.on("close", cb);
-  }
-  addErrorListener(cb) {
-    this.sock.on("error", cb);
-  }
-  send(payload) {
-    if (this.framer.destroyed || !this.sock.writable)
-      return false;
-    return this.sock.write(MessageFramer.write(payload));
-  }
-  close() {
-    this.sock.destroy();
-    this.framer.destroy();
-  }
-};
-
-export {
-  UdsConnection
-};

package/dist/chunk-Q7GL34DZ.js

@@ -1,47 +0,0 @@
-import {
-  MessageFramer
-} from "./chunk-IIBVKYDB.js";
-import {
-  Connection
-} from "./chunk-4SDJ5VN4.js";
-
-// transport/impls/stdio/connection.ts
-var StreamConnection = class extends Connection {
-  input;
-  output;
-  framer;
-  constructor(input, output) {
-    super();
-    this.framer = MessageFramer.createFramedStream();
-    this.input = input.pipe(this.framer);
-    this.output = output;
-  }
-  addDataListener(cb) {
-    this.input.on("data", cb);
-  }
-  removeDataListener(cb) {
-    this.input.off("data", cb);
-  }
-  addCloseListener(cb) {
-    this.input.on("close", cb);
-    this.output.on("close", cb);
-  }
-  addErrorListener(cb) {
-    this.input.on("error", cb);
-    this.output.on("error", cb);
-  }
-  send(payload) {
-    if (!this.output.writable)
-      return false;
-    return this.output.write(MessageFramer.write(payload));
-  }
-  close() {
-    this.output.end();
-    this.input.unpipe(this.framer);
-    this.framer.destroy();
-  }
-};
-
-export {
-  StreamConnection
-};

package/dist/connection-1f9971d8.d.ts

@@ -1,17 +0,0 @@
-import { C as Connection } from './index-54e0f99c.js';
-import { U as Uint32LengthPrefixFraming } from './messageFraming-b200ef25.js';
-
-declare class StreamConnection extends Connection {
-    input: NodeJS.ReadableStream;
-    output: NodeJS.WritableStream;
-    framer: Uint32LengthPrefixFraming;
-    constructor(input: NodeJS.ReadableStream, output: NodeJS.WritableStream);
-    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;
-}
-
-export { StreamConnection as S };

package/dist/connection-24d878ac.d.ts

@@ -1,18 +0,0 @@
-import { C as Connection } from './index-54e0f99c.js';
-import { Socket } from 'node:net';
-import { U as Uint32LengthPrefixFraming } from './messageFraming-b200ef25.js';
-
-declare class UdsConnection extends Connection {
-    sock: Socket;
-    input: NodeJS.ReadableStream;
-    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;
-}
-
-export { UdsConnection as U };