@replit/river 0.207.3 → 0.208.0

package/dist/message-Di94OL80.d.ts

@@ -0,0 +1,108 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TSchema } from '@sinclair/typebox';
+import { Span, Context } from '@opentelemetry/api';
+
+interface PropagationContext {
+    traceparent: string;
+    tracestate: string;
+}
+interface TelemetryInfo {
+    span: Span;
+    ctx: Context;
+}
+
+/**
+ * Generic Typebox schema for a transport message.
+ * @template T The type of the payload.
+ * @param {T} t The payload schema.
+ * @returns The transport message schema.
+ */
+declare const TransportMessageSchema: <T extends TSchema>(t: T) => _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    from: _sinclair_typebox.TString;
+    to: _sinclair_typebox.TString;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    streamId: _sinclair_typebox.TString;
+    controlFlags: _sinclair_typebox.TInteger;
+    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        traceparent: _sinclair_typebox.TString;
+        tracestate: _sinclair_typebox.TString;
+    }>>;
+    payload: T;
+}>;
+type ProtocolVersion = 'v1.1' | 'v2.0';
+declare const HandshakeErrorCustomHandlerFatalResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>;
+declare const HandshakeErrorResponseCodes: _sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"SESSION_STATE_MISMATCH">, _sinclair_typebox.TUnion<[_sinclair_typebox.TUnion<[_sinclair_typebox.TLiteral<"REJECTED_UNSUPPORTED_CLIENT">, _sinclair_typebox.TLiteral<"REJECTED_BY_CUSTOM_HANDLER">]>, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE_META">, _sinclair_typebox.TLiteral<"MALFORMED_HANDSHAKE">, _sinclair_typebox.TLiteral<"PROTOCOL_VERSION_MISMATCH">]>]>;
+/**
+ * Defines the schema for an opaque transport message that is agnostic to any
+ * procedure/service.
+ * @returns The transport message schema.
+ */
+declare const OpaqueTransportMessageSchema: _sinclair_typebox.TObject<{
+    id: _sinclair_typebox.TString;
+    from: _sinclair_typebox.TString;
+    to: _sinclair_typebox.TString;
+    seq: _sinclair_typebox.TInteger;
+    ack: _sinclair_typebox.TInteger;
+    serviceName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    procedureName: _sinclair_typebox.TOptional<_sinclair_typebox.TString>;
+    streamId: _sinclair_typebox.TString;
+    controlFlags: _sinclair_typebox.TInteger;
+    tracing: _sinclair_typebox.TOptional<_sinclair_typebox.TObject<{
+        traceparent: _sinclair_typebox.TString;
+        tracestate: _sinclair_typebox.TString;
+    }>>;
+    payload: _sinclair_typebox.TUnknown;
+}>;
+/**
+ * Represents a transport message. This is the same type as {@link TransportMessageSchema} but
+ * we can't statically infer generics from generic Typebox schemas so we have to define it again here.
+ *
+ * TypeScript can't enforce types when a bitmask is involved, so these are the semantics of
+ * `controlFlags`:
+ * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `streamId` must be set to a unique value
+ *   (suggestion: use `nanoid`).
+ * * If `controlFlags & StreamOpenBit == StreamOpenBit`, `serviceName` and `procedureName` must be set.
+ * * If `controlFlags & StreamClosedBit == StreamClosedBit` and the kind is `stream` or `subscription`,
+ *   `payload` should be discarded (usually contains a control message).
+ * * If `controlFlags & AckBit == AckBit`, the message is an explicit acknowledgement message and doesn't
+ *   contain any payload that is relevant to the application so should not be delivered.
+ * @template Payload The type of the payload.
+ */
+interface TransportMessage<Payload = unknown> {
+    id: string;
+    from: TransportClientId;
+    to: TransportClientId;
+    seq: number;
+    ack: number;
+    serviceName?: string;
+    procedureName?: string;
+    streamId: string;
+    controlFlags: number;
+    tracing?: PropagationContext;
+    payload: Payload;
+}
+type PartialTransportMessage<Payload = unknown> = Omit<TransportMessage<Payload>, 'id' | 'from' | 'to' | 'seq' | 'ack'>;
+/**
+ * A type alias for a transport message with an opaque payload.
+ * @template T - The type of the opaque payload.
+ */
+type OpaqueTransportMessage = TransportMessage;
+type TransportClientId = string;
+/**
+ * Checks if the given control flag (usually found in msg.controlFlag) is a stream open message.
+ * @param controlFlag - The control flag to check.
+ * @returns True if the control flag contains the StreamOpenBit, false otherwise.
+ */
+declare function isStreamOpen(controlFlag: number): boolean;
+/**
+ * Checks if the given control flag (usually found in msg.controlFlag) is a stream close message.
+ * @param controlFlag - The control flag to check.
+ * @returns True if the control flag contains the StreamCloseBit, false otherwise.
+ */
+declare function isStreamClose(controlFlag: number): boolean;
+
+export { HandshakeErrorCustomHandlerFatalResponseCodes as H, type OpaqueTransportMessage as O, type ProtocolVersion as P, type TransportClientId as T, type PartialTransportMessage as a, type TelemetryInfo as b, type TransportMessage as c, HandshakeErrorResponseCodes as d, TransportMessageSchema as e, OpaqueTransportMessageSchema as f, isStreamClose as g, isStreamOpen as i };

package/dist/router/index.cjs

@@ -68,10 +68,11 @@ function castTypeboxValueErrors(errors) {
   }
   return result;
 }
-var CancelResultSchema = import_typebox.Type.Object({
+var CancelErrorSchema = import_typebox.Type.Object({
   code: import_typebox.Type.Literal(CANCEL_CODE),
   message: import_typebox.Type.String()
 });
+var CancelResultSchema = ErrResultSchema(CancelErrorSchema);
 var ReaderErrorSchema = import_typebox.Type.Union([
   import_typebox.Type.Object({
     code: import_typebox.Type.Literal(UNCAUGHT_ERROR_CODE),
@@ -91,8 +92,9 @@ var ReaderErrorSchema = import_typebox.Type.Union([
       })
     )
   }),
-  CancelResultSchema
+  CancelErrorSchema
 ]);
+var ReaderErrorResultSchema = ErrResultSchema(ReaderErrorSchema);
 function isUnion(schema) {
   return schema[import_typebox.Kind] === "Union";
 }
@@ -900,15 +902,13 @@ var WritableImpl = class {
 
 // router/client.ts
 var import_value = require("@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
@@ -1037,8 +1037,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,
@@ -1050,20 +1049,20 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
       cleanClose = false;
       span.addEvent("received cancel");
       let cancelResult;
-      if (import_value.Value.Check(ReaderErrResultSchema, msg.payload)) {
+      if (import_value.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: [
-              ...import_value.Value.Errors(ReaderErrResultSchema, msg.payload)
+              ...import_value.Value.Errors(ReaderErrorResultSchema, msg.payload)
             ]
           }
         );
@@ -1191,6 +1190,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
@@ -1203,8 +1203,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)) {
@@ -1261,8 +1262,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`,
@@ -1276,8 +1276,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 = () => {
@@ -1328,7 +1327,7 @@ var RiverServer = class {
       if (isStreamCancelBackwardsCompat(msg.controlFlags, protocolVersion)) {
         let cancelResult;
         if (import_value2.Value.Check(CancelResultSchema, msg.payload)) {
-          cancelResult = Err(msg.payload);
+          cancelResult = msg.payload;
         } else {
           cancelResult = Err({
             code: CANCEL_CODE,
@@ -1524,12 +1523,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,
@@ -1539,13 +1538,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()) {
@@ -1557,13 +1567,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
@@ -1573,13 +1581,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
             });
@@ -1588,13 +1594,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
             });
@@ -1607,9 +1611,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);
     }
@@ -1860,7 +1878,8 @@ function createServer(transport, services, providedServerOptions) {
     services,
     providedServerOptions?.handshakeOptions,
     providedServerOptions?.extendedContext,
-    providedServerOptions?.maxCancelledStreamTombstonesPerSession
+    providedServerOptions?.maxCancelledStreamTombstonesPerSession,
+    providedServerOptions?.middlewares
   );
 }
 
@@ -1873,7 +1892,7 @@ function createServerHandshakeOptions(schema, validate) {
 }
 
 // package.json
-var version = "0.207.3";
+var version = "0.208.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CANCEL_CODE,