@replit/river 0.207.2 → 0.208.0

package/dist/{chunk-46IVOKJU.js → chunk-ETZAHFGQ.js}

@@ -29,10 +29,11 @@ function castTypeboxValueErrors(errors) {
   }
   return result;
 }
-var CancelResultSchema = Type.Object({
+var CancelErrorSchema = Type.Object({
   code: Type.Literal(CANCEL_CODE),
   message: Type.String()
 });
+var CancelResultSchema = ErrResultSchema(CancelErrorSchema);
 var ReaderErrorSchema = Type.Union([
   Type.Object({
     code: Type.Literal(UNCAUGHT_ERROR_CODE),
@@ -52,8 +53,9 @@ var ReaderErrorSchema = Type.Union([
       })
     )
   }),
-  CancelResultSchema
+  CancelErrorSchema
 ]);
+var ReaderErrorResultSchema = ErrResultSchema(ReaderErrorSchema);
 function isUnion(schema) {
   return schema[Kind] === "Union";
 }
@@ -653,7 +655,7 @@ function getPropagationContext(ctx) {
 function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx) {
   const parentCtx = propagationCtx ? propagation.extract(context.active(), propagationCtx) : context.active();
   const span = tracer.startSpan(
-    `river.session.${sessionId}`,
+    `river.session`,
     {
       attributes: {
         component: "river",
@@ -669,7 +671,7 @@ function createSessionTelemetryInfo(tracer, sessionId, to, from, propagationCtx)
 }
 function createConnectionTelemetryInfo(tracer, connection, info) {
   const span = tracer.startSpan(
-    `connection ${connection.id}`,
+    `river.connection`,
     {
       attributes: {
         component: "river",
@@ -955,15 +957,13 @@ var WritableImpl = class {
 
 // router/client.ts
 import { Value } from "@sinclair/typebox/value";
-var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
 var noop = () => {
 };
 function _createRecursiveProxy(callback, path) {
   const proxy = new Proxy(noop, {
     // property access, recurse and add field to path
     get(_obj, key) {
-      if (typeof key !== "string")
-        return void 0;
+      if (typeof key !== "string") return void 0;
       return _createRecursiveProxy(callback, [...path, key]);
     },
     // hit the end, let's invoke the handler
@@ -1092,8 +1092,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     );
   }
   function onMessage(msg) {
-    if (msg.streamId !== streamId)
-      return;
+    if (msg.streamId !== streamId) return;
     if (msg.to !== transport.clientId) {
       transport.log?.error("got stream message from unexpected client", {
         clientId: transport.clientId,
@@ -1105,20 +1104,20 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
       cleanClose = false;
       span.addEvent("received cancel");
       let cancelResult;
-      if (Value.Check(ReaderErrResultSchema, msg.payload)) {
+      if (Value.Check(ReaderErrorResultSchema, msg.payload)) {
         cancelResult = msg.payload;
       } else {
         cancelResult = Err({
           code: CANCEL_CODE,
           message: "stream cancelled with invalid payload"
         });
-        transport.log?.error(
+        transport.log?.warn(
           "got stream cancel without a valid protocol error",
           {
             clientId: transport.clientId,
             transportMessage: msg,
             validationErrors: [
-              ...Value.Errors(ReaderErrResultSchema, msg.payload)
+              ...Value.Errors(ReaderErrorResultSchema, msg.payload)
             ]
           }
         );
@@ -1246,6 +1245,7 @@ var RiverServer = class {
   transport;
   contextMap;
   log;
+  middlewares;
   /**
    * We create a tombstones for streams cancelled by the server
    * so that we don't hit errors when the client has inflight
@@ -1258,8 +1258,9 @@ var RiverServer = class {
   streams;
   services;
   unregisterTransportListeners;
-  constructor(transport, services, handshakeOptions, extendedContext, maxCancelledStreamTombstonesPerSession = 200) {
+  constructor(transport, services, handshakeOptions, extendedContext, maxCancelledStreamTombstonesPerSession = 200, middlewares = []) {
     const instances = {};
+    this.middlewares = middlewares;
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
     for (const [name, service] of Object.entries(services)) {
@@ -1316,8 +1317,7 @@ var RiverServer = class {
       );
     };
     const handleSessionStatus = (evt) => {
-      if (evt.status !== "closing")
-        return;
+      if (evt.status !== "closing") return;
       const disconnectedClientId = evt.session.to;
       this.log?.info(
         `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
@@ -1331,8 +1331,7 @@ var RiverServer = class {
       this.serverCancelledStreams.delete(disconnectedClientId);
     };
     const handleTransportStatus = (evt) => {
-      if (evt.status !== "closed")
-        return;
+      if (evt.status !== "closed") return;
       this.unregisterTransportListeners();
     };
     this.unregisterTransportListeners = () => {
@@ -1383,7 +1382,7 @@ var RiverServer = class {
       if (isStreamCancelBackwardsCompat(msg.controlFlags, protocolVersion)) {
         let cancelResult;
         if (Value2.Check(CancelResultSchema, msg.payload)) {
-          cancelResult = Err(msg.payload);
+          cancelResult = msg.payload;
         } else {
           cancelResult = Err({
             code: CANCEL_CODE,
@@ -1579,12 +1578,12 @@ var RiverServer = class {
     if (procClosesWithInit) {
       closeReadable();
     }
-    const handlerContextWithSpan = (span2) => ({
+    const handlerContextWithSpan = {
       ...serviceContext,
       from,
       sessionId,
       metadata: sessionMetadata,
-      span: span2,
+      span,
       cancel: (message) => {
         const errRes = {
           code: CANCEL_CODE,
@@ -1594,13 +1593,24 @@ var RiverServer = class {
         return Err(errRes);
       },
       signal: finishedController.signal
-    });
-    switch (procedure.type) {
-      case "rpc":
-        void (async () => {
+    };
+    const middlewareContext = {
+      ...serviceContext,
+      sessionId,
+      from,
+      metadata: sessionMetadata,
+      span,
+      signal: finishedController.signal,
+      streamId,
+      procedureName,
+      serviceName
+    };
+    const runProcedureHandler = async () => {
+      switch (procedure.type) {
+        case "rpc":
           try {
             const responsePayload = await procedure.handler({
-              ctx: handlerContextWithSpan(span),
+              ctx: handlerContextWithSpan,
               reqInit: initPayload
             });
             if (resWritable.isClosed()) {
@@ -1612,13 +1622,11 @@ var RiverServer = class {
           } finally {
             span.end();
           }
-        })();
-        break;
-      case "stream":
-        void (async () => {
+          break;
+        case "stream":
           try {
             await procedure.handler({
-              ctx: handlerContextWithSpan(span),
+              ctx: handlerContextWithSpan,
               reqInit: initPayload,
               reqReadable,
               resWritable
@@ -1628,13 +1636,11 @@ var RiverServer = class {
           } finally {
             span.end();
           }
-        })();
-        break;
-      case "subscription":
-        void (async () => {
+          break;
+        case "subscription":
           try {
             await procedure.handler({
-              ctx: handlerContextWithSpan(span),
+              ctx: handlerContextWithSpan,
               reqInit: initPayload,
               resWritable
             });
@@ -1643,13 +1649,11 @@ var RiverServer = class {
           } finally {
             span.end();
           }
-        })();
-        break;
-      case "upload":
-        void (async () => {
+          break;
+        case "upload":
           try {
             const responsePayload = await procedure.handler({
-              ctx: handlerContextWithSpan(span),
+              ctx: handlerContextWithSpan,
               reqInit: initPayload,
               reqReadable
             });
@@ -1662,9 +1666,23 @@ var RiverServer = class {
           } finally {
             span.end();
           }
-        })();
-        break;
-    }
+          break;
+      }
+    };
+    this.middlewares.reduceRight(
+      (next, middleware) => {
+        return () => {
+          middleware({
+            ctx: middlewareContext,
+            reqInit: initPayload,
+            next
+          });
+        };
+      },
+      () => {
+        void runProcedureHandler();
+      }
+    )();
     if (!finishedController.signal.aborted) {
       this.streams.set(streamId, procStream);
     }
@@ -1915,7 +1933,8 @@ function createServer(transport, services, providedServerOptions) {
     services,
     providedServerOptions?.handshakeOptions,
     providedServerOptions?.extendedContext,
-    providedServerOptions?.maxCancelledStreamTombstonesPerSession
+    providedServerOptions?.maxCancelledStreamTombstonesPerSession,
+    providedServerOptions?.middlewares
   );
 }
 
@@ -1928,19 +1947,9 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.207.2";
+var version = "0.208.0";
 
 export {
-  UNCAUGHT_ERROR_CODE,
-  UNEXPECTED_DISCONNECT_CODE,
-  INVALID_REQUEST_CODE,
-  CANCEL_CODE,
-  ReaderErrorSchema,
-  flattenErrorType,
-  serializeSchemaV1Compat,
-  serializeSchema,
-  ServiceSchema,
-  Procedure,
   generateId,
   TransportMessageSchema,
   currentProtocolVersion,
@@ -1954,17 +1963,27 @@ export {
   handshakeRequestMessage,
   handshakeResponseMessage,
   isAck,
+  UNCAUGHT_ERROR_CODE,
+  UNEXPECTED_DISCONNECT_CODE,
+  INVALID_REQUEST_CODE,
+  CANCEL_CODE,
+  ReaderErrorSchema,
+  flattenErrorType,
+  serializeSchemaV1Compat,
+  serializeSchema,
+  ServiceSchema,
+  Procedure,
   Ok,
   Err,
-  getPropagationContext,
-  createSessionTelemetryInfo,
-  createConnectionTelemetryInfo,
-  getTracer,
   createClient,
   coerceErrorString,
   createServer,
   createClientHandshakeOptions,
   createServerHandshakeOptions,
-  version
+  version,
+  getPropagationContext,
+  createSessionTelemetryInfo,
+  createConnectionTelemetryInfo,
+  getTracer
 };
-//# sourceMappingURL=chunk-46IVOKJU.js.map
+//# sourceMappingURL=chunk-ETZAHFGQ.js.map