@replit/river 0.200.1 → 0.200.2

package/dist/router/index.cjs

@@ -42,7 +42,58 @@ __export(router_exports, {
 module.exports = __toCommonJS(router_exports);
 
 // router/services.ts
+var import_typebox2 = require("@sinclair/typebox");
+
+// router/errors.ts
 var import_typebox = require("@sinclair/typebox");
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var CANCEL_CODE = "CANCEL";
+var ErrResultSchema = (t) => import_typebox.Type.Object({
+  ok: import_typebox.Type.Literal(false),
+  payload: t
+});
+var ReaderErrorSchema = import_typebox.Type.Union([
+  import_typebox.Type.Object({
+    code: import_typebox.Type.Literal(UNCAUGHT_ERROR_CODE),
+    message: import_typebox.Type.String()
+  }),
+  import_typebox.Type.Object({
+    code: import_typebox.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    message: import_typebox.Type.String()
+  }),
+  import_typebox.Type.Object({
+    code: import_typebox.Type.Literal(INVALID_REQUEST_CODE),
+    message: import_typebox.Type.String()
+  }),
+  import_typebox.Type.Object({
+    code: import_typebox.Type.Literal(CANCEL_CODE),
+    message: import_typebox.Type.String()
+  })
+]);
+function isUnion(schema) {
+  return schema[import_typebox.Kind] === "Union";
+}
+function flattenErrorType(errType) {
+  if (!isUnion(errType)) {
+    return errType;
+  }
+  const flattenedTypes = [];
+  function flatten(type) {
+    if (isUnion(type)) {
+      for (const t of type.anyOf) {
+        flatten(t);
+      }
+    } else {
+      flattenedTypes.push(type);
+    }
+  }
+  flatten(errType);
+  return import_typebox.Type.Union(flattenedTypes);
+}
+
+// router/services.ts
 function serializeSchemaV1Compat(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serializeV1Compat();
@@ -52,7 +103,7 @@ function serializeSchemaV1Compat(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = import_typebox.Type.Strict(handshakeSchema);
+    schema.handshakeSchema = import_typebox2.Type.Strict(handshakeSchema);
   }
   return schema;
 }
@@ -65,7 +116,7 @@ function serializeSchema(services, handshakeSchema) {
     services: serializedServiceObject
   };
   if (handshakeSchema) {
-    schema.handshakeSchema = import_typebox.Type.Strict(handshakeSchema);
+    schema.handshakeSchema = import_typebox2.Type.Strict(handshakeSchema);
   }
   return schema;
 }
@@ -168,18 +219,15 @@ var ServiceSchema = class _ServiceSchema {
         Object.entries(this.procedures).map(([procName, procDef]) => [
           procName,
           {
-            init: import_typebox.Type.Strict(procDef.requestInit),
-            output: import_typebox.Type.Strict(procDef.responseData),
+            init: import_typebox2.Type.Strict(procDef.requestInit),
+            output: import_typebox2.Type.Strict(procDef.responseData),
+            errors: getSerializedProcErrors(procDef),
             // Only add `description` field if the type declares it.
             ..."description" in procDef ? { description: procDef.description } : {},
-            // Only add the `errors` field if the type declares it.
-            ..."responseError" in procDef ? {
-              errors: import_typebox.Type.Strict(procDef.responseError)
-            } : {},
             type: procDef.type,
             // Only add the `input` field if the type declares it.
             ..."requestData" in procDef ? {
-              input: import_typebox.Type.Strict(procDef.requestData)
+              input: import_typebox2.Type.Strict(procDef.requestData)
             } : {}
           }
         ])
@@ -203,14 +251,11 @@ var ServiceSchema = class _ServiceSchema {
                 {
                   // BACKWARDS COMPAT: map init to input for protocolv1
                   // this is the only change needed to make it compatible.
-                  input: import_typebox.Type.Strict(procDef.requestInit),
-                  output: import_typebox.Type.Strict(procDef.responseData),
+                  input: import_typebox2.Type.Strict(procDef.requestInit),
+                  output: import_typebox2.Type.Strict(procDef.responseData),
+                  errors: getSerializedProcErrors(procDef),
                   // Only add `description` field if the type declares it.
                   ..."description" in procDef ? { description: procDef.description } : {},
-                  // Only add the `errors` field if the type declares it.
-                  ..."responseError" in procDef ? {
-                    errors: import_typebox.Type.Strict(procDef.responseError)
-                  } : {},
                   type: procDef.type
                 }
               ];
@@ -218,16 +263,13 @@ var ServiceSchema = class _ServiceSchema {
             return [
               procName,
               {
-                init: import_typebox.Type.Strict(procDef.requestInit),
-                output: import_typebox.Type.Strict(procDef.responseData),
+                init: import_typebox2.Type.Strict(procDef.requestInit),
+                output: import_typebox2.Type.Strict(procDef.responseData),
+                errors: getSerializedProcErrors(procDef),
                 // Only add `description` field if the type declares it.
                 ..."description" in procDef ? { description: procDef.description } : {},
-                // Only add the `errors` field if the type declares it.
-                ..."responseError" in procDef ? {
-                  errors: import_typebox.Type.Strict(procDef.responseError)
-                } : {},
                 type: procDef.type,
-                input: import_typebox.Type.Strict(procDef.requestData)
+                input: import_typebox2.Type.Strict(procDef.requestData)
               }
             ];
           }
@@ -248,6 +290,15 @@ var ServiceSchema = class _ServiceSchema {
     });
   }
 };
+function getSerializedProcErrors(procDef) {
+  if (!("responseError" in procDef) || procDef.responseError[import_typebox2.Kind] === "Never") {
+    return import_typebox2.Type.Strict(ReaderErrorSchema);
+  }
+  const withProtocolErrors = flattenErrorType(
+    import_typebox2.Type.Union([procDef.responseError, ReaderErrorSchema])
+  );
+  return import_typebox2.Type.Strict(withProtocolErrors);
+}
 var ServiceScaffold = class {
   /**
    * The configuration for this service.
@@ -306,11 +357,11 @@ var ServiceScaffold = class {
 };
 
 // router/procedures.ts
-var import_typebox2 = require("@sinclair/typebox");
+var import_typebox3 = require("@sinclair/typebox");
 function rpc({
   requestInit,
   responseData,
-  responseError = import_typebox2.Type.Never(),
+  responseError = import_typebox3.Type.Never(),
   description,
   handler
 }) {
@@ -327,7 +378,7 @@ function upload({
   requestInit,
   requestData,
   responseData,
-  responseError = import_typebox2.Type.Never(),
+  responseError = import_typebox3.Type.Never(),
   description,
   handler
 }) {
@@ -344,7 +395,7 @@ function upload({
 function subscription({
   requestInit,
   responseData,
-  responseError = import_typebox2.Type.Never(),
+  responseError = import_typebox3.Type.Never(),
   description,
   handler
 }) {
@@ -361,7 +412,7 @@ function stream({
   requestInit,
   requestData,
   responseData,
-  responseError = import_typebox2.Type.Never(),
+  responseError = import_typebox3.Type.Never(),
   description,
   handler
 }) {
@@ -382,46 +433,6 @@ var Procedure = {
   stream
 };
 
-// router/errors.ts
-var import_typebox3 = require("@sinclair/typebox");
-var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
-var INVALID_REQUEST_CODE = "INVALID_REQUEST";
-var CANCEL_CODE = "CANCEL";
-var ErrResultSchema = (t) => import_typebox3.Type.Object({
-  ok: import_typebox3.Type.Literal(false),
-  payload: t
-});
-var ReaderErrorSchema = import_typebox3.Type.Object({
-  code: import_typebox3.Type.Union([
-    import_typebox3.Type.Literal(UNCAUGHT_ERROR_CODE),
-    import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
-    import_typebox3.Type.Literal(INVALID_REQUEST_CODE),
-    import_typebox3.Type.Literal(CANCEL_CODE)
-  ]),
-  message: import_typebox3.Type.String()
-});
-function isUnion(schema) {
-  return schema[import_typebox3.Kind] === "Union";
-}
-function flattenErrorType(errType) {
-  if (!isUnion(errType)) {
-    return errType;
-  }
-  const flattenedTypes = [];
-  function flatten(type) {
-    if (isUnion(type)) {
-      for (const t of type.anyOf) {
-        flatten(t);
-      }
-    } else {
-      flattenedTypes.push(type);
-    }
-  }
-  flatten(errType);
-  return import_typebox3.Type.Union(flattenedTypes);
-}
-
 // transport/message.ts
 var import_typebox4 = require("@sinclair/typebox");
 
@@ -594,7 +605,7 @@ function unwrapOrThrow(result) {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.200.1";
+var version = "0.200.2";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -1445,6 +1456,19 @@ var RiverServer = class {
       const errorMsg = coerceErrorString(err);
       span.recordException(err instanceof Error ? err : new Error(errorMsg));
       span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+      this.log?.error(
+        `${serviceName}.${procedureName} handler threw an uncaught error`,
+        {
+          ...loggingMetadata,
+          transportMessage: {
+            procedureName,
+            serviceName
+          },
+          extras: {
+            error: errorMsg
+          }
+        }
+      );
       onServerCancel({
         code: UNCAUGHT_ERROR_CODE,
         message: errorMsg
@@ -1453,10 +1477,7 @@ var RiverServer = class {
     if (procClosesWithInit) {
       closeReadable();
     } else if (procedure.type === "rpc" || procedure.type === "subscription") {
-      this.log?.warn("sent an init without a stream close", {
-        ...loggingMetadata,
-        clientId: this.transport.clientId
-      });
+      this.log?.warn("sent an init without a stream close", loggingMetadata);
     }
     const handlerContext = {
       ...serviceContext,