@replit/river 0.11.0 → 0.12.1

package/dist/{chunk-3JGVFWKQ.js → chunk-55XUAPC6.js}

@@ -1,14 +1,12 @@
 import {
   ControlMessagePayloadSchema,
-  closeStream,
+  coerceErrorString,
   isStreamClose,
-  isStreamOpen,
-  msg,
-  reply
-} from "./chunk-ZE4MX7DF.js";
+  isStreamOpen
+} from "./chunk-XFFS4UOD.js";
 import {
   log
-} from "./chunk-T7M7OKPE.js";
+} from "./chunk-H4BYJELI.js";
 
 // router/builder.ts
 import { Type } from "@sinclair/typebox";
@@ -475,33 +473,24 @@ var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(asy
     throw new Error(`invalid river call, unknown procedure type ${procType}`);
   }
 }, []);
-var CONNECTION_GRACE_PERIOD_MS = 5e3;
-function rejectAfterDisconnectGrace(from, cb) {
-  let timeout = void 0;
+function createSessionDisconnectHandler(from, cb) {
   return (evt) => {
-    if (evt.status === "connect" && evt.conn.connectedTo === from) {
-      clearTimeout(timeout);
-      timeout = void 0;
-    }
-    if (evt.status === "disconnect" && evt.conn.connectedTo === from) {
-      timeout = setTimeout(cb, CONNECTION_GRACE_PERIOD_MS);
+    if (evt.status === "disconnect" && evt.session.to === from) {
+      cb();
     }
   };
 }
-function handleRpc(transport, serverId, input, serviceName, procName) {
+function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = nanoid();
-  const m = msg(
-    transport.clientId,
-    serverId,
+  transport.send(serverId, {
     streamId,
-    input,
     serviceName,
-    procName
-  );
-  m.controlFlags |= 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */;
-  transport.send(m);
+    procedureName,
+    payload: input,
+    controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
+  });
   const responsePromise = new Promise((resolve) => {
-    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
       cleanup();
       resolve(
         Err({
@@ -512,172 +501,181 @@ function handleRpc(transport, serverId, input, serviceName, procName) {
     });
     function cleanup() {
       transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("connectionStatus", onConnectionStatus);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
     }
-    function onMessage(msg2) {
-      if (msg2.streamId !== streamId) {
+    function onMessage(msg) {
+      if (msg.streamId !== streamId) {
         return;
       }
-      if (msg2.to !== transport.clientId) {
+      if (msg.to !== transport.clientId) {
         return;
       }
-      if (msg2.streamId === streamId) {
+      if (msg.streamId === streamId) {
         cleanup();
-        resolve(msg2.payload);
+        resolve(msg.payload);
       }
     }
     transport.addEventListener("message", onMessage);
-    transport.addEventListener("connectionStatus", onConnectionStatus);
+    transport.addEventListener("sessionStatus", onSessionStatus);
   });
   return responsePromise;
 }
-function handleStream(transport, serverId, init, serviceName, procName) {
+function handleStream(transport, serverId, init, serviceName, procedureName) {
   const streamId = nanoid();
   const inputStream = pushable({ objectMode: true });
   const outputStream = pushable({ objectMode: true });
   let firstMessage = true;
+  let healthyClose = true;
   if (init) {
-    const m = msg(
-      transport.clientId,
-      serverId,
+    transport.send(serverId, {
       streamId,
-      init,
       serviceName,
-      procName
-    );
-    m.controlFlags = 2 /* StreamOpenBit */;
-    transport.send(m);
+      procedureName,
+      payload: init,
+      controlFlags: 2 /* StreamOpenBit */
+    });
     firstMessage = false;
   }
-  (async () => {
+  const pipeInputToTransport = async () => {
     for await (const rawIn of inputStream) {
-      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      };
       if (firstMessage) {
         m.serviceName = serviceName;
-        m.procedureName = procName;
+        m.procedureName = procedureName;
         m.controlFlags |= 2 /* StreamOpenBit */;
         firstMessage = false;
       }
-      transport.send(m);
+      transport.send(serverId, m);
     }
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  })();
-  function onMessage(msg2) {
-    if (msg2.streamId !== streamId) {
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
+  function onMessage(msg) {
+    if (msg.streamId !== streamId) {
       return;
     }
-    if (msg2.to !== transport.clientId) {
+    if (msg.to !== transport.clientId) {
       return;
     }
-    if (isStreamClose(msg2.controlFlags)) {
+    if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
-      outputStream.push(msg2.payload);
+      outputStream.push(msg.payload);
     }
   }
   function cleanup() {
     inputStream.end();
     outputStream.end();
     transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("connectionStatus", onConnectionStatus);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
   }
-  const closeHandler = () => {
-    cleanup();
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  };
-  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
     outputStream.push(
       Err({
         code: UNEXPECTED_DISCONNECT,
         message: `${serverId} unexpectedly disconnected`
       })
     );
+    healthyClose = false;
     cleanup();
   });
   transport.addEventListener("message", onMessage);
-  transport.addEventListener("connectionStatus", onConnectionStatus);
-  return [inputStream, outputStream, closeHandler];
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  return [inputStream, outputStream, cleanup];
 }
-function handleSubscribe(transport, serverId, input, serviceName, procName) {
+function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
   const streamId = nanoid();
-  const m = msg(
-    transport.clientId,
-    serverId,
+  transport.send(serverId, {
     streamId,
-    input,
     serviceName,
-    procName
-  );
-  m.controlFlags |= 2 /* StreamOpenBit */;
-  transport.send(m);
+    procedureName,
+    payload: input,
+    controlFlags: 2 /* StreamOpenBit */
+  });
+  let healthyClose = true;
   const outputStream = pushable({ objectMode: true });
-  function onMessage(msg2) {
-    if (msg2.streamId !== streamId) {
+  function onMessage(msg) {
+    if (msg.streamId !== streamId) {
       return;
     }
-    if (msg2.to !== transport.clientId) {
+    if (msg.to !== transport.clientId) {
       return;
     }
-    if (isStreamClose(msg2.controlFlags)) {
+    if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
-      outputStream.push(msg2.payload);
+      outputStream.push(msg.payload);
     }
   }
   function cleanup() {
     outputStream.end();
     transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("connectionStatus", onConnectionStatus);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
   }
   const closeHandler = () => {
     cleanup();
-    transport.send(closeStream(transport.clientId, serverId, streamId));
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
   };
-  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
     outputStream.push(
       Err({
         code: UNEXPECTED_DISCONNECT,
         message: `${serverId} unexpectedly disconnected`
       })
     );
+    healthyClose = false;
     cleanup();
   });
   transport.addEventListener("message", onMessage);
-  transport.addEventListener("connectionStatus", onConnectionStatus);
+  transport.addEventListener("sessionStatus", onSessionStatus);
   return [outputStream, closeHandler];
 }
-function handleUpload(transport, serverId, input, serviceName, procName) {
+function handleUpload(transport, serverId, init, serviceName, procedureName) {
   const streamId = nanoid();
   const inputStream = pushable({ objectMode: true });
   let firstMessage = true;
-  if (input) {
-    const m = msg(
-      transport.clientId,
-      serverId,
+  let healthyClose = true;
+  if (init) {
+    transport.send(serverId, {
       streamId,
-      input,
       serviceName,
-      procName
-    );
-    m.controlFlags = 2 /* StreamOpenBit */;
-    transport.send(m);
+      procedureName,
+      payload: init,
+      controlFlags: 2 /* StreamOpenBit */
+    });
     firstMessage = false;
   }
-  (async () => {
+  const pipeInputToTransport = async () => {
     for await (const rawIn of inputStream) {
-      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      };
       if (firstMessage) {
-        m.controlFlags |= 2 /* StreamOpenBit */;
         m.serviceName = serviceName;
-        m.procedureName = procName;
+        m.procedureName = procedureName;
+        m.controlFlags |= 2 /* StreamOpenBit */;
         firstMessage = false;
       }
-      transport.send(m);
+      transport.send(serverId, m);
     }
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  })();
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
   const responsePromise = new Promise((resolve) => {
-    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+      healthyClose = false;
       cleanup();
       resolve(
         Err({
@@ -689,19 +687,19 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
     function cleanup() {
       inputStream.end();
       transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("connectionStatus", onConnectionStatus);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
     }
-    function onMessage(msg2) {
-      if (msg2.to !== transport.clientId) {
+    function onMessage(msg) {
+      if (msg.to !== transport.clientId) {
         return;
       }
-      if (msg2.streamId === streamId) {
+      if (msg.streamId === streamId) {
         cleanup();
-        resolve(msg2.payload);
+        resolve(msg.payload);
       }
     }
     transport.addEventListener("message", onMessage);
-    transport.addEventListener("connectionStatus", onConnectionStatus);
+    transport.addEventListener("sessionStatus", onSessionStatus);
   });
   return [inputStream, responsePromise];
 }
@@ -716,10 +714,12 @@ var RiverServer = class {
   streamMap;
   // map of client to their open streams by streamId
   clientStreams;
+  disconnectedSessions;
   constructor(transport, services, extendedContext) {
     this.transport = transport;
     this.services = services;
     this.contextMap = /* @__PURE__ */ new Map();
+    this.disconnectedSessions = /* @__PURE__ */ new Set();
     for (const service of Object.values(services)) {
       this.contextMap.set(service, {
         ...extendedContext,
@@ -728,13 +728,13 @@ var RiverServer = class {
     }
     this.streamMap = /* @__PURE__ */ new Map();
     this.clientStreams = /* @__PURE__ */ new Map();
-    this.transport.addEventListener("message", this.handler);
-    this.transport.addEventListener("connectionStatus", this.onDisconnect);
+    this.transport.addEventListener("message", this.onMessage);
+    this.transport.addEventListener("sessionStatus", this.onSessionStatus);
   }
   get streams() {
     return this.streamMap;
   }
-  handler = async (message) => {
+  onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
       log?.info(
         `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
@@ -749,12 +749,12 @@ var RiverServer = class {
     }
     await this.pushToStream(procStream, message, isInitMessage);
   };
-  // cleanup streams on unexpected disconnections
-  onDisconnect = async (evt) => {
+  // cleanup streams on session close
+  onSessionStatus = async (evt) => {
     if (evt.status !== "disconnect") {
       return;
     }
-    const disconnectedClientId = evt.conn.connectedTo;
+    const disconnectedClientId = evt.session.to;
     log?.info(
       `${this.transport.clientId} -- got unexpected disconnect from ${disconnectedClientId}, cleaning up streams`
     );
@@ -762,14 +762,16 @@ var RiverServer = class {
     if (!streamsFromThisClient) {
       return;
     }
+    this.disconnectedSessions.add(disconnectedClientId);
     await Promise.all(
       Array.from(streamsFromThisClient).map(this.cleanupStream)
     );
+    this.disconnectedSessions.delete(disconnectedClientId);
     this.clientStreams.delete(disconnectedClientId);
   };
   async close() {
-    this.transport.removeEventListener("message", this.handler);
-    this.transport.removeEventListener("connectionStatus", this.onDisconnect);
+    this.transport.removeEventListener("message", this.onMessage);
+    this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
     await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
   }
   createNewProcStream(message) {
@@ -793,6 +795,13 @@ var RiverServer = class {
       );
       return;
     }
+    const session = this.transport.sessions.get(message.from);
+    if (!session) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find session for ${message.from}`
+      );
+      return;
+    }
     const procedure = service.procedures[message.procedureName];
     const incoming = pushable({ objectMode: true });
     const outgoing = pushable({ objectMode: true });
@@ -800,21 +809,20 @@ var RiverServer = class {
       // sending outgoing messages back to client
       (async () => {
         for await (const response of outgoing) {
-          this.transport.send(reply(message, response));
+          this.transport.send(session.to, {
+            streamId: message.streamId,
+            controlFlags: 0,
+            payload: response
+          });
         }
-        if (procedure.type === "subscription" || procedure.type === "stream") {
-          this.transport.send(
-            closeStream(
-              this.transport.clientId,
-              message.from,
-              message.streamId
-            )
-          );
+        const needsClose = procedure.type === "subscription" || procedure.type === "stream";
+        if (needsClose && !this.disconnectedSessions.has(message.from)) {
+          this.transport.sendCloseStream(session.to, message.streamId);
         }
       })()
     );
     const errorHandler = (err) => {
-      const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+      const errorMsg = coerceErrorString(err);
       log?.error(
         `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`
       );
@@ -827,82 +835,95 @@ var RiverServer = class {
     };
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
-    if (procedure.type === "stream") {
-      if (procHasInitMessage) {
-        inputHandler = (async () => {
-          const initMessage = await incoming.next();
-          if (initMessage.done) {
-            return;
-          }
-          return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
-        })();
-      } else {
-        inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
-      }
-    } else if (procedure.type === "rpc") {
-      inputHandler = (async () => {
-        const inputMessage = await incoming.next();
-        if (inputMessage.done) {
-          return;
-        }
-        try {
-          const outputMessage = await procedure.handler(
-            serviceContext,
-            inputMessage.value
-          );
-          outgoing.push(outputMessage);
-        } catch (err) {
-          errorHandler(err);
-        }
-      })();
-    } else if (procedure.type === "subscription") {
-      inputHandler = (async () => {
-        const inputMessage = await incoming.next();
-        if (inputMessage.done) {
-          return;
-        }
-        try {
-          await procedure.handler(serviceContext, inputMessage.value, outgoing);
-        } catch (err) {
-          errorHandler(err);
-        }
-      })();
-    } else if (procedure.type === "upload") {
-      if (procHasInitMessage) {
+    switch (procedure.type) {
+      case "rpc":
         inputHandler = (async () => {
-          const initMessage = await incoming.next();
-          if (initMessage.done) {
+          const inputMessage = await incoming.next();
+          if (inputMessage.done) {
             return;
           }
           try {
             const outputMessage = await procedure.handler(
               serviceContext,
-              initMessage.value,
-              incoming
+              inputMessage.value
             );
             outgoing.push(outputMessage);
           } catch (err) {
             errorHandler(err);
           }
         })();
-      } else {
+        break;
+      case "stream":
+        if (procHasInitMessage) {
+          inputHandler = (async () => {
+            const initMessage = await incoming.next();
+            if (initMessage.done) {
+              return;
+            }
+            return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+          })();
+        } else {
+          inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+        }
+        break;
+      case "subscription":
         inputHandler = (async () => {
+          const inputMessage = await incoming.next();
+          if (inputMessage.done) {
+            return;
+          }
           try {
-            const outputMessage = await procedure.handler(
+            await procedure.handler(
               serviceContext,
-              incoming
+              inputMessage.value,
+              outgoing
             );
-            outgoing.push(outputMessage);
           } catch (err) {
             errorHandler(err);
           }
         })();
-      }
-    } else {
-      log?.warn(
-        `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
-      );
-      return;
+        break;
+      case "upload":
+        if (procHasInitMessage) {
+          inputHandler = (async () => {
+            const initMessage = await incoming.next();
+            if (initMessage.done) {
+              return;
+            }
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContext,
+                initMessage.value,
+                incoming
+              );
+              if (!this.disconnectedSessions.has(message.from)) {
+                outgoing.push(outputMessage);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
+          })();
+        } else {
+          inputHandler = (async () => {
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContext,
+                incoming
+              );
+              if (!this.disconnectedSessions.has(message.from)) {
+                outgoing.push(outputMessage);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
+          })();
+        }
+        break;
+      default:
+        log?.warn(
+          `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+        );
+        return;
     }
     const procStream = {
       id: message.streamId,
@@ -910,7 +931,6 @@ var RiverServer = class {
       outgoing,
       serviceName: message.serviceName,
       procedureName: message.procedureName,
-      procedure,
       promises: { inputHandler, outputHandler }
     };
     this.streamMap.set(message.streamId, procStream);
@@ -920,13 +940,18 @@ var RiverServer = class {
     return procStream;
   }
   async pushToStream(procStream, message, isInit) {
-    const procedure = procStream.procedure;
+    const { serviceName, procedureName } = procStream;
+    const procedure = this.services[serviceName].procedures[procedureName];
     const procHasInitMessage = "init" in procedure;
-    if (isInit && procHasInitMessage && Value.Check(procedure.init, message.payload) || Value.Check(procedure.input, message.payload)) {
+    if (isInit && procHasInitMessage && Value.Check(procedure.init, message.payload)) {
+      procStream.incoming.push(message.payload);
+    } else if (Value.Check(procedure.input, message.payload)) {
       procStream.incoming.push(message.payload);
     } else if (!Value.Check(ControlMessagePayloadSchema, message.payload)) {
       log?.error(
-        `${this.transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`
+        `${this.transport.clientId} -- procedure ${serviceName}.${procedureName} received invalid payload: ${JSON.stringify(
+          message.payload
+        )}`
       );
     }
     if (isStreamClose(message.controlFlags)) {

package/dist/{chunk-R6H2BIMC.js → chunk-GZ7HCLLM.js}

@@ -1,3 +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;
+    }
+  }
+};
+
 // codec/json.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -20,7 +37,7 @@ var NaiveJsonCodec = {
   toBuffer: (obj) => {
     return encoder.encode(
       JSON.stringify(obj, function replacer(key) {
-        let val = this[key];
+        const val = this[key];
         if (val instanceof Uint8Array) {
           return { $t: uint8ArrayToBase64(val) };
         } else {
@@ -31,13 +48,19 @@ var NaiveJsonCodec = {
   },
   fromBuffer: (buff) => {
     try {
-      return JSON.parse(decoder.decode(buff), function reviver(_key, val) {
-        if (val?.$t) {
-          return base64ToUint8Array(val.$t);
-        } else {
-          return val;
+      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;
     }
@@ -45,5 +68,6 @@ var NaiveJsonCodec = {
 };
 
 export {
+  BinaryCodec,
   NaiveJsonCodec
 };