effect 4.0.2 → 4.0.3

package/src/rpc/RpcServer.ts

@@ -82,6 +82,12 @@ export interface RpcServer<A extends Rpc.Any> {
  * handlers for a group and sending decoded server responses through
  * `onFromServer`.
  *
+ * **Details**
+ *
+ * If writing a stream `Chunk` fails with anything other than an interruption,
+ * the request fails with that cause. `onFromServer` is assumed to have already
+ * answered the client and reported it, so nothing else is sent or reported.
+ *
  * @stability unstable
  * @category constructors
  * @since 4.0.0
@@ -188,7 +194,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           clients.set(clientId, client)
         } else if (
           client.ended &&
-          (message._tag !== "Interrupt" || !client.fibers.has(message.requestId))
+          ((message._tag !== "Interrupt" && message._tag !== "Ack") || !client.fibers.has(message.requestId))
         ) {
           return Effect.interrupt
         }
@@ -199,7 +205,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           }
           case "Ack": {
             const latch = client.latches?.get(message.requestId)
-            return latch ? latch.open : Effect.void
+            return latch ? Effect.asVoid(latch.open) : Effect.void
           }
           case "Interrupt": {
             const fiber = client.fibers.get(message.requestId)
@@ -279,13 +285,23 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     const isUninterruptible = isWrapper && result.uninterruptible
     // unwrap the fork data type
     const streamOrEffect = isWrapper ? result.value : result
+    // set when a chunk could not be written; the writer has already responded
+    let writeFailure: Cause.Cause<never> | undefined
     const handler = isStream
-      ? (streamEffect(client, request, streamOrEffect) as Effect.Effect<{} | Deferred.Deferred<any, any>>)
+      ? (streamEffect(client, request, streamOrEffect, (cause) => {
+        writeFailure = cause
+      }) as Effect.Effect<{} | Deferred.Deferred<any, any>>)
       : (streamOrEffect as Effect.Effect<{} | Deferred.Deferred<any, any>>)
 
-    const withMiddleware = rpc.middlewares.size > 0
-      ? applyMiddleware(services, handler, metadata)
-      : handler
+    const withMiddleware = rpc.middlewares.size === 0
+      ? handler
+      : isStream
+      // middleware may rewrite or swallow a chunk write failure, so restore it
+      ? Effect.flatMap(
+        Effect.exit(applyMiddleware(services, handler, metadata)),
+        (exit) => writeFailure ? Effect.failCause(writeFailure) : exit
+      )
+      : applyMiddleware(services, handler, metadata)
     let responded = false
     const scope = Scope.makeUnsafe()
     let deferred: Deferred.Deferred<unknown, unknown> | undefined = undefined
@@ -304,6 +320,9 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
             exit: exit as any
           })
         }
+      } else if (writeFailure) {
+        // onFromServer has already answered the client and reported the failure
+        return Scope.closeUnsafe(scope, exit) ?? Effect.void
       } else if (
         !disableFatalDefects &&
         Cause.hasDies(exit.cause) &&
@@ -409,8 +428,17 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     request: Request<Rpcs>,
     stream:
       | Stream.Stream<any, any>
-      | Effect.Effect<Queue.Dequeue<any, any>, any, Scope.Scope>
+      | Effect.Effect<Queue.Dequeue<any, any>, any, Scope.Scope>,
+    onWriteFailure: (cause: Cause.Cause<never>) => void
   ) => {
+    const writeChunk = (values: NonEmptyReadonlyArray<any>) =>
+      Effect.onError(
+        options.onFromServer({ _tag: "Chunk", clientId: client.id, requestId: request.id, values }),
+        (cause) => {
+          if (!Cause.hasInterruptsOnly(cause)) onWriteFailure(cause)
+          return Effect.void
+        }
+      )
     let latch: Latch.Latch | undefined
     if (supportsAck) {
       client.latches ??= new Map()
@@ -427,12 +455,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
             while: constTrue,
             body: constant(
               Effect.flatMap(Queue.takeAll(queue), (values) => {
-                const write = options.onFromServer({
-                  _tag: "Chunk",
-                  clientId: client.id,
-                  requestId: request.id,
-                  values
-                })
+                const write = writeChunk(values)
                 if (!latch) return write
                 latch.closeUnsafe()
                 return Effect.flatMap(write, () => latch.await)
@@ -446,12 +469,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       )
     }
     return Stream.runForEachArray(stream, (values) => {
-      const write = options.onFromServer({
-        _tag: "Chunk",
-        clientId: client.id,
-        requestId: request.id,
-        values
-      })
+      const write = writeChunk(values)
       if (!latch) return write
       latch.closeUnsafe()
       return Effect.andThen(write, latch.await)
@@ -633,6 +651,7 @@ export const make: <Rpcs extends Rpc.Any>(
   )
 
   type Schemas = {
+    readonly tag: string
     readonly decode: (u: unknown) => Effect.Effect<Rpc.Payload<Rpcs>, Schema.SchemaError>
     readonly encodeChunk: (
       u: NonEmptyReadonlyArray<unknown>
@@ -649,6 +668,7 @@ export const make: <Rpcs extends Rpc.Any>(
       const entry = Context.getOrUndefinedUnsafe(services, rpc.key) as Rpc.Handler<Rpcs["_tag"]>
       const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
       schemas = {
+        tag: rpc._tag,
         decode: Schema.decodeUnknownEffect(codecFor(rpc.payloadSchema)) as any,
         encodeChunk: Schema.encodeUnknownEffect(
           codecFor(
@@ -686,23 +706,38 @@ export const make: <Rpcs extends Rpc.Any>(
     tag: "Chunk" | "Exit"
   ) => {
     const collector = schemas.collector
+    let encodeFailed = false
     // The schema encoders evaluate eagerly, so an encode that needs no
     // services is already a resolved success and can skip the effect wrappers.
     const write = Exit.isExit(effect) && Exit.isSuccess(effect)
       ? send(client.id, responseEnvelope(requestId, tag, effect.value), collector && collector.clearUnsafe())
       : Effect.flatMap(
-        Effect.provideContext(
-          collector ? Effect.provideService(effect, Transferable.Collector, collector) : effect,
-          schemas.context
+        Effect.catch(
+          Effect.provideContext(
+            collector ? Effect.provideService(effect, Transferable.Collector, collector) : effect,
+            schemas.context
+          ),
+          (error) =>
+            Effect.withFiber((fiber) => {
+              const defect = Cause.die(
+                `Failed to encode response for RPC "${schemas.tag}": ${SchemaIssue.defaultFormatter(error.issue)}`
+              )
+              reportCauseUnsafe(fiber, defect)
+              encodeFailed = true
+              return Effect.failCause(defect)
+            })
         ),
         (value) => send(client.id, responseEnvelope(requestId, tag, value), collector && collector.clearUnsafe())
       )
     return Effect.catchCause(write, (cause) => {
       client.schemas.delete(requestId)
-      const defect = Cause.squash(Cause.map(cause, (e) => SchemaIssue.defaultFormatter(e.issue)))
+      // An encode failure ends the request with the defect, so the request
+      // span records it. Other failures stop the request as a cancellation.
       return Effect.andThen(
-        sendRequestDefect(client, requestId, schemas.encodeExit, defect),
-        server.write(client.id, { _tag: "Interrupt", requestId, interruptors: [] })
+        sendRequestDefect(client, requestId, schemas.encodeExit, Cause.squash(cause)),
+        encodeFailed
+          ? Effect.failCause(cause)
+          : server.write(client.id, { _tag: "Interrupt", requestId, interruptors: [] })
       )
     })
   }