effect 4.0.7 → 4.1.0

package/src/reactivity/AtomRegistry.ts

@@ -587,7 +587,7 @@ class RegistryImpl implements AtomRegistry {
       this.removeNodeTimeout(node)
     }
     if (typeof key === "string" && this.preloadedSerializable.has(key)) {
-      const encoded = this.preloadedSerializable.get(key)
+      const encoded = this.preloadedSerializable.get(key) as Schema.Json
       this.preloadedSerializable.delete(key)
       const serializable = (atom as any as Atom.Serializable<any>)[SerializableTypeId]
       let decoded: A

package/src/rpc/RpcClient.ts

@@ -107,6 +107,14 @@ export declare namespace RpcClient {
         {
           readonly headers?: Headers.Input | undefined
           readonly context?: Context.Context<never> | undefined
+          /**
+           * Completes once the server acknowledges the call as its handler starts,
+           * after the middleware has run, instead of waiting for the result. The
+           * handler's result and error are not returned, but transport errors,
+           * middleware errors and failures before the handler starts still fail the
+           * call. Over HTTP and workers the call completes after the handler has
+           * finished.
+           */
           readonly discard?: Discard | undefined
         }
     ) => Current extends Rpc.Rpc<
@@ -174,6 +182,14 @@ export declare namespace RpcClient {
       {
         readonly headers?: Headers.Input | undefined
         readonly context?: Context.Context<never> | undefined
+        /**
+         * Completes once the server acknowledges the call as its handler starts,
+         * after the middleware has run, instead of waiting for the result. The
+         * handler's result and error are not returned, but transport errors,
+         * middleware errors and failures before the handler starts still fail the
+         * call. Over HTTP and workers the call completes after the handler has
+         * finished.
+         */
         readonly discard?: Discard | undefined
       }
   ) => Rpcs extends Rpc.Rpc<
@@ -242,7 +258,6 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       options: {
         readonly message: FromClient<Rpcs>
         readonly context: Context.Context<never>
-        readonly discard: boolean
       }
     ) => Effect.Effect<void, E>
     readonly supportsAck?: boolean | undefined
@@ -266,7 +281,6 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       options: {
         readonly message: FromClient<Rpcs>
         readonly context: Context.Context<never>
-        readonly discard: boolean
       }
     ) => Effect.Effect<void, E>
     readonly supportsAck?: boolean | undefined
@@ -384,12 +398,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       }
       const id = generateRequestId()
       const send = middleware(
-        (message) =>
-          options.onFromClient({
-            message,
-            context,
-            discard
-          }),
+        (message) => options.onFromClient({ message, context }),
         {
           _tag: "Request",
           id,
@@ -402,20 +411,28 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
               sampled: span.sampled
             } :
             {}),
-          headers: Headers.merge(parentFiber.getRef(CurrentHeaders), headers)
+          headers: Headers.merge(parentFiber.getRef(CurrentHeaders), headers),
+          ...(discard ? { discard: true as const } : {})
         }
       )
-      if (discard) {
-        return send
-      }
       let fiber: Fiber.Fiber<any, any>
       return Effect.onInterrupt(
         Effect.callback<any, any>((resume) => {
+          // the acknowledgement of a discarded call, held until its send has finished
+          let ack: Exit.Exit<any, any> | undefined
           const entry: ClientEntry = {
             _tag: "Effect",
             rpc,
             context,
             resume(exit) {
+              if (discard) {
+                // Interrupting the send could cancel the call, as an HTTP
+                // handler is scoped to its request, so the call completes
+                // once the send has finished too.
+                ack = exit._tag === "Success" ? Exit.void : exit
+                if (fiber?.pollUnsafe()) resume(ack)
+                return
+              }
               resume(exit)
               if (fiber && !fiber.pollUnsafe()) {
                 parentFiber.currentDispatcher.scheduleTask(() => {
@@ -433,6 +450,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             if (exit._tag === "Failure") {
               entries.delete(id)
               return resume(exit)
+            } else if (ack) {
+              return resume(ack)
             }
           })
         }),
@@ -495,12 +514,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
     })
 
     yield* middleware(
-      (message) =>
-        options.onFromClient({
-          message,
-          context,
-          discard: false
-        }),
+      (message) => options.onFromClient({ message, context }),
       {
         _tag: "Request",
         id,
@@ -572,8 +586,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
       const parentFiber = Fiber.getCurrent()!
       const fiber = options.onFromClient({
         message: { _tag: "Interrupt", requestId, interruptors },
-        context,
-        discard: false
+        context
       }).pipe(
         Effect.timeout(1000),
         Effect.runForkWith(parentFiber.context)
@@ -594,8 +607,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any, E, const Flatten extend
             ? Effect.flatMap(() =>
               options.onFromClient({
                 message: { _tag: "Ack", requestId: message.requestId },
-                context: entry.context,
-                discard: false
+                context: entry.context
               })
             )
             : identity,
@@ -687,6 +699,7 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
     readonly rpc: Rpc.AnyWithProps
     readonly context: Context.Context<never>
     readonly schemas: RpcSchemas
+    readonly discard: boolean
   }
   const entries = new Map<RequestId, ClientEntry>()
   // Completed before the protocol stops running this client, so requests made
@@ -713,7 +726,8 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
           const entry: ClientEntry = {
             rpc,
             context: collector ? Context.add(fiber.context, Transferable.Collector, collector) : fiber.context,
-            schemas: rpcSchemas(rpc)
+            schemas: rpcSchemas(rpc),
+            discard: message.discard === true
           }
           entries.set(message.id, entry)
 
@@ -795,7 +809,13 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
         const entry = entries.get(requestId)
         if (!entry) return Effect.void
         entries.delete(requestId)
-        return entry.schemas.decodeExit(message.exit).pipe(
+        // the success of a discarded call is its acknowledgement, which has no
+        // value, and an older server may send the handler result instead
+        if (entry.discard && message.exit._tag === "Success") {
+          return write({ _tag: "Exit", clientId: 0, requestId, exit: Exit.void as any })
+        }
+        const decodeExit = entry.discard ? entry.schemas.decodeDiscardExit : entry.schemas.decodeExit
+        return decodeExit(message.exit).pipe(
           Effect.provideContext(entry.context),
           Effect.orDie,
           Effect.matchCauseEffect({
@@ -839,6 +859,7 @@ interface RpcSchemas {
   >
   readonly encodePayload: (payload: any) => Effect.Effect<any, Schema.SchemaError, unknown>
   readonly decodeExit: (encoded: unknown) => Effect.Effect<Exit.Exit<any, any>, Schema.SchemaError, unknown>
+  readonly decodeDiscardExit: (encoded: unknown) => Effect.Effect<Exit.Exit<any, any>, Schema.SchemaError, unknown>
 }
 // Codecs are compiled per client, because two protocols can fill the message
 // holes with different codecs.
@@ -851,6 +872,8 @@ const makeRpcSchemas = (codecFor: RpcSerialization.CodecFor) => {
     }
     const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
     const parseOptions = Context.get(rpc.annotations, Rpc.ParseOptions)
+    const exitSchema = Rpc.exitSchema(rpc as any)
+    let decodeDiscardExit: RpcSchemas["decodeDiscardExit"] | undefined
     entry = {
       decodeChunk: Option.map(
         streamSchemas,
@@ -858,7 +881,13 @@ const makeRpcSchemas = (codecFor: RpcSerialization.CodecFor) => {
           Schema.decodeUnknownEffect(codecFor(Schema.NonEmptyArray(streamSchemas.success)), parseOptions)
       ),
       encodePayload: Schema.encodeEffect(codecFor(rpc.payloadSchema), parseOptions),
-      decodeExit: Schema.decodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any)), parseOptions)
+      decodeExit: Schema.decodeUnknownEffect(codecFor(exitSchema), parseOptions),
+      // the server encodes the Exits of a discarded call with a void success
+      decodeDiscardExit: (encoded) =>
+        (decodeDiscardExit ??= Schema.decodeUnknownEffect(
+          codecFor(Schema.Exit(Schema.Void, exitSchema.error, exitSchema.defect)),
+          parseOptions
+        ))(encoded)
     }
     cache.set(rpc, entry)
     return entry
@@ -1635,7 +1664,14 @@ export const makeProtocolWorker = (
             Effect.flatMap((worker) => {
               const latch = Latch.makeUnsafe(false)
               entries.set(request.id, { clientId, worker, latch })
-              return Effect.flatMap(worker.send(request, transferables), () => latch.await)
+              // the pool counts a worker as busy until the Exit arrives, so a
+              // discarded call is sent without its marker to get the handler Exit
+              let message = request
+              if (request.discard === true) {
+                const { discard: _, ...rest } = request
+                message = rest
+              }
+              return Effect.flatMap(worker.send(message, transferables), () => latch.await)
             }),
             Effect.scoped,
             Effect.orDie

package/src/rpc/RpcMessage.ts

@@ -62,7 +62,12 @@ export const RequestId = (id: string | number): RequestId => id as RequestId
  * **Details**
  *
  * Requests flow in both directions: servers use them for server-originated
- * requests and, with `isNotification` set, for server notifications.
+ * requests and, with `isNotification` set, for requests that get no reply,
+ * such as server notifications and inbound JSON-RPC notifications.
+ *
+ * A client call made with `discard` sets `discard` instead. It keeps its id,
+ * and the server acknowledges it with a successful `Exit` once the handler
+ * starts, then sends nothing more for it.
  *
  * @stability unstable
  * @category models
@@ -75,6 +80,7 @@ export interface RequestEncoded {
   readonly payload: unknown
   readonly headers: ReadonlyArray<[string, string]>
   readonly isNotification?: true
+  readonly discard?: true
   readonly traceId?: string
   readonly spanId?: string
   readonly sampled?: boolean
@@ -94,6 +100,8 @@ export interface Request<A extends Rpc.Any> {
   readonly tag: Rpc.Tag<A>
   readonly payload: Rpc.Payload<A>
   readonly headers: Headers
+  readonly isNotification?: true
+  readonly discard?: true
   readonly traceId?: string
   readonly spanId?: string
   readonly sampled?: boolean
@@ -453,6 +461,7 @@ const RequestEncodedSchema = Schema.Struct({
   payload: Schema.Uint8Array,
   headers: Schema.Array(Schema.Tuple([Schema.String, Schema.String])),
   isNotification: Schema.optional(Schema.Literal(true)),
+  discard: Schema.optional(Schema.Literal(true)),
   traceId: Schema.optional(Schema.String),
   spanId: Schema.optional(Schema.String),
   sampled: Schema.optional(Schema.Boolean)

package/src/rpc/RpcSerialization.ts

@@ -374,6 +374,7 @@ function decodeJsonRpcMessage(
       payload: request.params ?? null,
       headers: request.headers ?? [],
       ...(Predicate.hasProperty(request, "id") ? {} : { isNotification: true as const }),
+      ...(request.discard === true ? { discard: true as const } : {}),
       ...(request.spanId ?
         {
           traceId: request.traceId,
@@ -490,6 +491,7 @@ function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessag
         // a JSON-RPC notification is a request without an id
         ...(response.isNotification ? {} : { id: response.id }),
         ...(response.headers?.length > 0 ? { headers: response.headers } : {}),
+        ...(response.discard ? { discard: true } : {}),
         traceId: response.traceId,
         spanId: response.spanId,
         sampled: response.sampled
@@ -560,6 +562,7 @@ interface JsonRpcRequest {
   readonly method: string
   readonly params?: unknown
   readonly headers?: ReadonlyArray<[string, string]>
+  readonly discard?: true
   readonly traceId?: string
   readonly spanId?: string
   readonly sampled?: boolean