@replit/river 0.12.6 → 0.13.1

package/README.md

@@ -8,7 +8,9 @@ It's like tRPC/gRPC but with
 - result types and error handling
 - snappy DX (no code-generation)
 - transparent reconnect support for long-lived sessions
-- over any transport (WebSockets, stdio, Unix Domain Socket out of the box)
+- over any transport (WebSockets and Unix Domain Socket out of the box)
+
+See [PROTOCOL.md](./PROTOCOL.md) for more information on the protocol.
 
 ## Installation
 
@@ -47,6 +49,7 @@ import { Type } from '@sinclair/typebox';
 
 export const ExampleServiceConstructor = () =>
   ServiceBuilder.create('example')
+    // initializer for shared state
     .initialState({
       count: 0,
     })
@@ -55,7 +58,9 @@ export const ExampleServiceConstructor = () =>
       input: Type.Object({ n: Type.Number() }),
       output: Type.Object({ result: Type.Number() }),
       errors: Type.Never(),
+      // note that a handler is unique per user RPC
       async handler(ctx, { n }) {
+        // access and mutate shared state
         ctx.state.count += n;
         return Ok({ result: ctx.state.count });
       },

package/dist/{builder-c593de11.d.ts → builder-eef3b061.d.ts}

@@ -1,5 +1,6 @@
 import { TObject, TUnion, TString, TSchema, TNever, TLiteral, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
+import { b as TransportClientId, d as Session, C as Connection } from './index-9aa0aabb.js';
 
 /**
  * The context for services/procedures. This is used only on
@@ -21,6 +22,7 @@ import { Pushable } from 'it-pushable';
  * }
  * ```
  */
+
 interface ServiceContext {
 }
 /**
@@ -29,6 +31,13 @@ interface ServiceContext {
 type ServiceContextWithState<State> = ServiceContext & {
     state: State;
 };
+type ServiceContextWithTransportInfo<State> = ServiceContext & {
+    state: State;
+    to: TransportClientId;
+    from: TransportClientId;
+    streamId: string;
+    session: Session<Connection>;
+};
 
 type TLiteralString = TLiteral<string>;
 type RiverErrorSchema = TObject<{
@@ -145,39 +154,39 @@ type Procedure<State, Ty extends ValidProcType, I extends PayloadType, O extends
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: Static<I>) => Promise<Result<Static<O>, Static<E>>>;
+    handler: (context: ServiceContextWithTransportInfo<State>, input: Static<I>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : never : Ty extends 'upload' ? Init extends PayloadType ? {
     init: Init;
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
+    handler: (context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
+    handler: (context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>) => Promise<Result<Static<O>, Static<E>>>;
     type: Ty;
 } : Ty extends 'subscription' ? Init extends null ? {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: Static<I>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
+    handler: (context: ServiceContextWithTransportInfo<State>, input: Static<I>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : never : Ty extends 'stream' ? Init extends PayloadType ? {
     init: Init;
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
+    handler: (context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : {
     input: I;
     output: O;
     errors: E;
-    handler: (context: ServiceContextWithState<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
+    handler: (context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<Result<Static<O>, Static<E>>>) => Promise<void>;
     type: Ty;
 } : never;
 type AnyProcedure = Procedure<object, ValidProcType, PayloadType, PayloadType, RiverError, PayloadType | null>;
@@ -230,4 +239,4 @@ declare class ServiceBuilder<T extends Service<string, object, ProcListing>> {
     }>;
 }
 
-export { AnyService as A, Err as E, Ok as O, PayloadType as P, RiverError as R, ServiceContext as S, UNCAUGHT_ERROR as U, ValidProcType as V, Procedure as a, Result as b, RiverUncaughtSchema as c, ProcType as d, ProcInput as e, ProcOutput as f, ProcErrors as g, ProcHasInit as h, ProcInit as i, ServiceBuilder as j, ProcListing as k, Service as l, ProcHandler as m, ServiceContextWithState as n, RiverErrorSchema as o, serializeService as s };
+export { AnyService as A, Err as E, Ok as O, PayloadType as P, RiverError as R, ServiceContext as S, UNCAUGHT_ERROR as U, ValidProcType as V, Procedure as a, Result as b, RiverUncaughtSchema as c, ProcType as d, ProcInput as e, ProcOutput as f, ProcErrors as g, ProcHasInit as h, ProcInit as i, ServiceBuilder as j, ProcListing as k, Service as l, ProcHandler as m, ServiceContextWithState as n, ServiceContextWithTransportInfo as o, RiverErrorSchema as p, serializeService as s };

package/dist/{chunk-AFLZ6INU.js → chunk-JXKTY3GQ.js}

@@ -3,7 +3,7 @@ import {
   coerceErrorString,
   isStreamClose,
   isStreamOpen
-} from "./chunk-XFFS4UOD.js";
+} from "./chunk-SCG5S2EC.js";
 import {
   log
 } from "./chunk-H4BYJELI.js";
@@ -429,7 +429,8 @@ function _createRecursiveProxy(callback, path) {
   });
   return proxy;
 }
-var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(async (opts) => {
+var createClient = (transport) => _createRecursiveProxy(async (opts) => {
+  const serverId = transport.connectedTo;
   const [serviceName, procName, procType] = [...opts.path];
   if (!(serviceName && procName && procType)) {
     throw new Error(
@@ -437,6 +438,11 @@ var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(asy
     );
   }
   const [input] = opts.args;
+  log?.info(
+    `${transport.clientId} -- invoked ${procType}: ${serviceName}.${procName} with args: ${JSON.stringify(
+      input
+    )}`
+  );
   if (procType === "rpc") {
     return handleRpc(
       transport,
@@ -504,16 +510,12 @@ function handleRpc(transport, serverId, input, serviceName, procedureName) {
       transport.removeEventListener("sessionStatus", onSessionStatus);
     }
     function onMessage(msg) {
-      if (msg.streamId !== streamId) {
+      if (msg.streamId !== streamId)
         return;
-      }
-      if (msg.to !== transport.clientId) {
+      if (msg.to !== transport.clientId)
         return;
-      }
-      if (msg.streamId === streamId) {
-        cleanup();
-        resolve(msg.payload);
-      }
+      cleanup();
+      resolve(msg.payload);
     }
     transport.addEventListener("message", onMessage);
     transport.addEventListener("sessionStatus", onSessionStatus);
@@ -557,12 +559,10 @@ function handleStream(transport, serverId, init, serviceName, procedureName) {
   };
   void pipeInputToTransport();
   function onMessage(msg) {
-    if (msg.streamId !== streamId) {
+    if (msg.streamId !== streamId)
       return;
-    }
-    if (msg.to !== transport.clientId) {
+    if (msg.to !== transport.clientId)
       return;
-    }
     if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
@@ -601,12 +601,10 @@ function handleSubscribe(transport, serverId, input, serviceName, procedureName)
   let healthyClose = true;
   const outputStream = pushable({ objectMode: true });
   function onMessage(msg) {
-    if (msg.streamId !== streamId) {
+    if (msg.streamId !== streamId)
       return;
-    }
-    if (msg.to !== transport.clientId) {
+    if (msg.to !== transport.clientId)
       return;
-    }
     if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
@@ -690,13 +688,12 @@ function handleUpload(transport, serverId, init, serviceName, procedureName) {
       transport.removeEventListener("sessionStatus", onSessionStatus);
     }
     function onMessage(msg) {
-      if (msg.to !== transport.clientId) {
+      if (msg.streamId !== streamId)
         return;
-      }
-      if (msg.streamId === streamId) {
-        cleanup();
-        resolve(msg.payload);
-      }
+      if (msg.to !== transport.clientId)
+        return;
+      cleanup();
+      resolve(msg.payload);
     }
     transport.addEventListener("message", onMessage);
     transport.addEventListener("sessionStatus", onSessionStatus);
@@ -751,17 +748,15 @@ var RiverServer = class {
   };
   // cleanup streams on session close
   onSessionStatus = async (evt) => {
-    if (evt.status !== "disconnect") {
+    if (evt.status !== "disconnect")
       return;
-    }
     const disconnectedClientId = evt.session.to;
     log?.info(
       `${this.transport.clientId} -- got session disconnect from ${disconnectedClientId}, cleaning up streams`
     );
     const streamsFromThisClient = this.clientStreams.get(disconnectedClientId);
-    if (!streamsFromThisClient) {
+    if (!streamsFromThisClient)
       return;
-    }
     this.disconnectedSessions.add(disconnectedClientId);
     await Promise.all(
       Array.from(streamsFromThisClient).map(this.cleanupStream)
@@ -781,7 +776,13 @@ var RiverServer = class {
       );
       return;
     }
-    if (!message.serviceName || !(message.serviceName in this.services)) {
+    if (!message.procedureName || !message.serviceName) {
+      log?.warn(
+        `${this.transport.clientId} -- missing procedure or service name in stream open message`
+      );
+      return;
+    }
+    if (!(message.serviceName in this.services)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find service ${message.serviceName}`
       );
@@ -789,7 +790,7 @@ var RiverServer = class {
     }
     const service = this.services[message.serviceName];
     const serviceContext = this.getContext(service);
-    if (!message.procedureName || !(message.procedureName in service.procedures)) {
+    if (!(message.procedureName in service.procedures)) {
       log?.warn(
         `${this.transport.clientId} -- couldn't find a matching procedure for ${message.serviceName}.${message.procedureName}`
       );
@@ -805,21 +806,36 @@ var RiverServer = class {
     const procedure = service.procedures[message.procedureName];
     const incoming = pushable({ objectMode: true });
     const outgoing = pushable({ objectMode: true });
+    const needsClose = procedure.type === "subscription" || procedure.type === "stream";
     const outputHandler = (
       // sending outgoing messages back to client
-      (async () => {
-        for await (const response of outgoing) {
-          this.transport.send(session.to, {
-            streamId: message.streamId,
-            controlFlags: 0,
-            payload: response
-          });
-        }
-        const needsClose = procedure.type === "subscription" || procedure.type === "stream";
-        if (needsClose && !this.disconnectedSessions.has(message.from)) {
-          this.transport.sendCloseStream(session.to, message.streamId);
-        }
-      })()
+      needsClose ? (
+        // subscription and stream case, we need to send a close bit after the response stream
+        (async () => {
+          for await (const response of outgoing) {
+            this.transport.send(session.to, {
+              streamId: message.streamId,
+              controlFlags: 0,
+              payload: response
+            });
+          }
+          if (!this.disconnectedSessions.has(message.from)) {
+            this.transport.sendCloseStream(session.to, message.streamId);
+          }
+        })()
+      ) : (
+        // rpc and upload case, we just send the response back with close bit
+        (async () => {
+          const response = await outgoing.next().then((res) => res.value);
+          if (response) {
+            this.transport.send(session.to, {
+              streamId: message.streamId,
+              controlFlags: 4 /* StreamClosedBit */,
+              payload: response
+            });
+          }
+        })()
+      )
     );
     const errorHandler = (err) => {
       const errorMsg = coerceErrorString(err);
@@ -835,6 +851,13 @@ var RiverServer = class {
     };
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
+    const serviceContextWithTransportInfo = {
+      ...serviceContext,
+      to: message.to,
+      from: message.from,
+      streamId: message.streamId,
+      session
+    };
     switch (procedure.type) {
       case "rpc":
         inputHandler = (async () => {
@@ -844,7 +867,7 @@ var RiverServer = class {
           }
           try {
             const outputMessage = await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value
             );
             outgoing.push(outputMessage);
@@ -860,10 +883,15 @@ var RiverServer = class {
             if (initMessage.done) {
               return;
             }
-            return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+            return procedure.handler(
+              serviceContextWithTransportInfo,
+              initMessage.value,
+              incoming,
+              outgoing
+            ).catch(errorHandler);
           })();
         } else {
-          inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+          inputHandler = procedure.handler(serviceContextWithTransportInfo, incoming, outgoing).catch(errorHandler);
         }
         break;
       case "subscription":
@@ -874,7 +902,7 @@ var RiverServer = class {
           }
           try {
             await procedure.handler(
-              serviceContext,
+              serviceContextWithTransportInfo,
               inputMessage.value,
               outgoing
             );
@@ -892,7 +920,7 @@ var RiverServer = class {
             }
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 initMessage.value,
                 incoming
               );
@@ -907,7 +935,7 @@ var RiverServer = class {
           inputHandler = (async () => {
             try {
               const outputMessage = await procedure.handler(
-                serviceContext,
+                serviceContextWithTransportInfo,
                 incoming
               );
               if (!this.disconnectedSessions.has(message.from)) {

package/dist/{chunk-IIBVKYDB.js → chunk-JXO2SCQB.js}

@@ -1,3 +1,7 @@
+import {
+  Connection
+} from "./chunk-LDUFHGZU.js";
+
 // transport/transforms/messageFraming.ts
 import { Transform } from "node:stream";
 var Uint32LengthPrefixFraming = class extends Transform {
@@ -57,6 +61,40 @@ var MessageFramer = {
   }
 };
 
+// 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 {
-  MessageFramer
+  UdsConnection
 };