effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/rpc/RpcClient.ts

@@ -652,7 +652,9 @@ export const make: <Rpcs extends Rpc.Any, const Flatten extends boolean = false>
   } | undefined
 ) {
   const clientId = clientIdCounter++
-  const { run, send, supportsAck, supportsTransferables } = yield* Protocol
+  const { codecFor, run, send, supportsAck, supportsTransferables } = yield* Protocol
+  const rpcSchemas = makeRpcSchemas(codecFor)
+  const decodeDefect = Schema.decodeSync(codecFor(Schema.Defect()))
 
   type ClientEntry = {
     readonly rpc: Rpc.AnyWithProps
@@ -782,23 +784,27 @@ 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>
 }
-const rpcSchemasCache = new WeakMap<Rpc.AnyWithProps, RpcSchemas>()
-const rpcSchemas = (rpc: Rpc.AnyWithProps) => {
-  let entry = rpcSchemasCache.get(rpc)
-  if (entry !== undefined) {
+// Codecs are compiled per client, because two protocols can fill the message
+// holes with different codecs.
+const makeRpcSchemas = (codecFor: RpcSerialization.CodecFor) => {
+  const cache = new WeakMap<Rpc.AnyWithProps, RpcSchemas>()
+  return (rpc: Rpc.AnyWithProps): RpcSchemas => {
+    let entry = cache.get(rpc)
+    if (entry !== undefined) {
+      return entry
+    }
+    const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
+    entry = {
+      decodeChunk: Option.map(
+        streamSchemas,
+        (streamSchemas) => Schema.decodeUnknownEffect(codecFor(Schema.NonEmptyArray(streamSchemas.success)))
+      ),
+      encodePayload: Schema.encodeEffect(codecFor(rpc.payloadSchema)),
+      decodeExit: Schema.decodeUnknownEffect(codecFor(Rpc.exitSchema(rpc as any)))
+    }
+    cache.set(rpc, entry)
     return entry
   }
-  const streamSchemas = RpcSchema.getStreamSchemas(rpc.successSchema)
-  entry = {
-    decodeChunk: Option.map(
-      streamSchemas,
-      (streamSchemas) => Schema.decodeUnknownEffect(Schema.toCodecJson(Schema.NonEmptyArray(streamSchemas.success)))
-    ),
-    encodePayload: Schema.encodeEffect(Schema.toCodecJson(rpc.payloadSchema)),
-    decodeExit: Schema.decodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any)))
-  }
-  rpcSchemasCache.set(rpc, entry)
-  return entry
 }
 
 /**
@@ -871,6 +877,11 @@ export class Protocol extends Context.Service<Protocol, {
   ) => Effect.Effect<void, RpcClientError>
   readonly supportsAck: boolean
   readonly supportsTransferables: boolean
+  /**
+   * Builds the codec that fills the `unknown` holes of the protocol messages,
+   * re-passed from the `RpcSerialization` backing this transport.
+   */
+  readonly codecFor: RpcSerialization.CodecFor
 }>()("effect/rpc/RpcClient/Protocol") {
   /**
    * Creates a client protocol service from the supplied RPC request runner.
@@ -935,18 +946,13 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
           return yield* emptyResponseError(request)
         }
         let completed = false
-        let i = 0
-        yield* Effect.whileLoop({
-          while: () => i < responses.length,
-          body: () => {
-            const response = responses[i++]
-            if (isTerminalResponse(response)) {
-              completed = true
-            }
-            return writeResponse(clientId, response)
-          },
-          step: constVoid
-        })
+        for (let i = 0; i < responses.length; i++) {
+          const response = responses[i]
+          if (isTerminalResponse(response)) {
+            completed = true
+          }
+          yield* writeResponse(clientId, response)
+        }
         if (!completed) {
           return yield* incompleteResponseError(request)
         }
@@ -989,7 +995,8 @@ export const makeProtocolHttp = (client: HttpClient.HttpClient): Effect.Effect<
     return {
       send,
       supportsAck: false,
-      supportsTransferables: false
+      supportsTransferables: false,
+      codecFor: serialization.codecFor
     }
   }))
 
@@ -1043,16 +1050,15 @@ export const makeProtocolSocket = (options?: {
     const hooks = yield* Effect.serviceOption(ConnectionHooks)
     const requestClientMap = new Map<string | number, number>()
 
-    const write = yield* socket.writer
+    const writer = yield* socket.writer
 
     let parser = serialization.makeUnsafe()
 
-    const pinger = yield* makePinger(write(parser.encode(constPing)!))
+    // `parser` is replaced on every connect, and a stateful serialization
+    // encodes against the connection it is writing to, so the ping is encoded
+    // when it is sent rather than once up front.
+    const pinger = yield* makePinger(Effect.suspend(() => writer.write(parser.encode(constPing)!)))
     let currentError: RpcClientError | undefined
-    const onOpen = Effect.suspend(() => {
-      currentError = undefined
-      return Option.isSome(hooks) ? hooks.value.onConnect : Effect.void
-    })
 
     const broadcast = (response: FromServerEncoded) =>
       Effect.forEach(clientIds, (clientId) => writeResponse(clientId, response))
@@ -1064,48 +1070,63 @@ export const makeProtocolSocket = (options?: {
       })
     }
 
-    yield* Effect.suspend(() => {
-      parser = serialization.makeUnsafe()
-      pinger.reset()
-      return socket.runRaw((message) => {
-        try {
-          const responses = parser.decode(message) as Array<FromServerEncoded>
-          if (responses.length === 0) return
-          let i = 0
-          return Effect.whileLoop({
-            while: () => i < responses.length,
-            body: () => {
-              const response = responses[i++]
-              if (response._tag === "Pong") {
-                pinger.onPong()
-                return Effect.void
-              }
-              if (Object.hasOwn(response, "requestId")) {
-                const requestId = (response as FromServerEncoded & { readonly requestId: string | number }).requestId
-                const clientId = requestClientMap.get(requestId)
-                if (clientId !== undefined) {
-                  if (response._tag === "Exit") {
-                    requestClientMap.delete(requestId)
-                  }
-                  return writeResponse(clientId, response)
+    const processData = (data: Uint8Array | string): Effect.Effect<void> => {
+      try {
+        const responses = parser.decode(data) as Array<FromServerEncoded>
+        if (responses.length === 0) return Effect.void
+        let i = 0
+        return Effect.whileLoop({
+          while: () => i < responses.length,
+          body: () => {
+            const response = responses[i++]
+            if (response._tag === "Pong") {
+              pinger.onPong()
+              return Effect.void
+            }
+            if (Object.hasOwn(response, "requestId")) {
+              const requestId = (response as FromServerEncoded & { readonly requestId: string | number }).requestId
+              const clientId = requestClientMap.get(requestId)
+              if (clientId !== undefined) {
+                if (response._tag === "Exit") {
+                  requestClientMap.delete(requestId)
                 }
+                return writeResponse(clientId, response)
               }
-              return broadcast(response)
-            },
-            step: constVoid
-          })
-        } catch (defect) {
-          return broadcast({
-            _tag: "ClientProtocolError",
-            error: new RpcClientError({
-              reason: new RpcClientDefect({
-                message: "Error decoding message",
-                cause: defect
-              })
+            }
+            return broadcast(response)
+          },
+          step: constVoid
+        })
+      } catch (defect) {
+        return broadcast({
+          _tag: "ClientProtocolError",
+          error: new RpcClientError({
+            reason: new RpcClientDefect({
+              message: "Error decoding message",
+              cause: defect
             })
           })
+        })
+      }
+    }
+
+    yield* Effect.suspend(() => {
+      parser = serialization.makeUnsafe()
+      pinger.reset()
+      return Effect.gen(function*() {
+        const { pull } = yield* socket.reader
+        currentError = undefined
+        if (Option.isSome(hooks)) {
+          yield* hooks.value.onConnect
         }
-      }, { onOpen }).pipe(
+        while (true) {
+          const frames = yield* pull
+          for (let i = 0; i < frames.length; i++) {
+            yield* processData(frames[i])
+          }
+        }
+      }).pipe(
+        Effect.scoped,
         Effect.raceFirst(Effect.flatMap(
           pinger.timeout,
           () =>
@@ -1120,9 +1141,6 @@ export const makeProtocolSocket = (options?: {
         ))
       )
     }).pipe(
-      Effect.flatMap(() =>
-        Effect.fail(new Socket.SocketError({ reason: new Socket.SocketCloseError({ code: 1000 }) }))
-      ),
       Option.isSome(hooks) ? Effect.ensuring(hooks.value.onDisconnect) : identity,
       Effect.tapCause((cause) => {
         const error = Cause.findError(cause)
@@ -1167,10 +1185,11 @@ export const makeProtocolSocket = (options?: {
         }
         const encoded = parser.encode(request)
         if (encoded === undefined) return Effect.void
-        return Effect.orDie(write(encoded))
+        return Effect.orDie(writer.write(encoded))
       },
       supportsAck: true,
-      supportsTransferables: false
+      supportsTransferables: false,
+      codecFor: serialization.codecFor
     }
   }))
 
@@ -1392,7 +1411,10 @@ export const makeProtocolWorker = (
     return {
       send,
       supportsAck: true,
-      supportsTransferables: true
+      supportsTransferables: true,
+      // Worker protocols use structured clone, so they do not depend on
+      // `RpcSerialization`. A binary worker protocol is a separate protocol.
+      codecFor: Schema.toCodecJson as RpcSerialization.CodecFor
     }
   }))
 
@@ -1437,7 +1459,3 @@ export class ConnectionHooks extends Context.Service<ConnectionHooks, {
   readonly onConnect: Effect.Effect<void>
   readonly onDisconnect: Effect.Effect<void>
 }>()("effect/rpc/RpcClient/ConnectionHooks") {}
-
-// internal
-
-const decodeDefect = Schema.decodeSync(Schema.Defect())

package/src/unstable/rpc/RpcMessage.ts

@@ -54,6 +54,8 @@ export const RequestId = (id: string | number): RequestId => id as RequestId
  * The transport-encoded RPC request envelope, including the string request id,
  * RPC tag, encoded payload, headers, and optional trace context.
  *
+ * **Details**
+ *
  * Requests flow in both directions: servers use them for server-originated
  * requests and, with `isNotification` set, for server notifications.
  *
@@ -206,7 +208,7 @@ export type FromServerEncoded =
  * @category type IDs
  * @since 4.0.0
  */
-export const ResponseIdTypeId = "~effect//rpc/RpcServer/ResponseId"
+export const ResponseIdTypeId = "~effect/rpc/RpcMessage/ResponseId"
 
 /**
  * The literal type of the `ResponseId` brand identifier.
@@ -328,18 +330,25 @@ export interface ResponseDefectEncoded {
   readonly defect: unknown
 }
 
-const encodeDefect = Schema.encodeSync(Schema.Defect())
-
 /**
- * Creates an encoded terminal response for a request whose exit is a defect
- * encoded with `Schema.Defect()`.
+ * Creates an encoded terminal response for a request whose exit is a defect.
+ *
+ * **Details**
+ *
+ * The defect must already be encoded, because the codec that fills the defect
+ * hole belongs to the protocol. Encode it with
+ * `protocol.codecFor(Schema.Defect())` first.
+ *
+ * This constructor produces the structured exit used by JSON-compatible
+ * protocols. Serializations whose `codecFor` returns bytes must encode the
+ * complete RPC exit before placing it in the response envelope instead.
  *
  * @category constructors
  * @since 4.0.0
  */
 export const ResponseExitDieEncoded = (options: {
   readonly requestId: RequestId
-  readonly defect: unknown
+  readonly encodedDefect: unknown
 }): ResponseExitEncoded => ({
   _tag: "Exit",
   requestId: options.requestId,
@@ -347,21 +356,25 @@ export const ResponseExitDieEncoded = (options: {
     _tag: "Failure",
     cause: [{
       _tag: "Die",
-      defect: encodeDefect(options.defect)
+      defect: options.encodedDefect
     }]
   }
 })
 
 /**
- * Creates a transport-encoded defect response by encoding the input with
- * `Schema.Defect()`.
+ * Creates a transport-encoded defect response around an already-encoded defect.
+ *
+ * **Details**
+ *
+ * Encode the defect with `protocol.codecFor(Schema.Defect())` before wrapping
+ * it, because the codec that fills the defect hole belongs to the protocol.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const ResponseDefectEncoded = (input: unknown): ResponseDefectEncoded => ({
+export const ResponseDefectEncoded = (encodedDefect: unknown): ResponseDefectEncoded => ({
   _tag: "Defect",
-  defect: encodeDefect(input)
+  defect: encodedDefect
 })
 
 /**
@@ -397,6 +410,60 @@ export interface Pong {
   readonly _tag: "Pong"
 }
 
+const RequestIdSchema = Schema.Union([Schema.String, Schema.Number])
+
+// Schema for transport-encoded RPC requests whose payload hole has already
+// been filled by the active serialization.
+const RequestEncodedSchema = Schema.Struct({
+  _tag: Schema.tag("Request"),
+  id: RequestIdSchema,
+  tag: Schema.String,
+  payload: Schema.Uint8Array,
+  headers: Schema.Array(Schema.Tuple([Schema.String, Schema.String])),
+  isNotification: Schema.optional(Schema.Literal(true)),
+  traceId: Schema.optional(Schema.String),
+  spanId: Schema.optional(Schema.String),
+  sampled: Schema.optional(Schema.Boolean)
+})
+
+/**
+ * Schema for every transport-encoded RPC envelope that crosses the wire.
+ * Binary serializers use it only after each schema-dependent hole has been
+ * encoded as bytes. `ClientProtocolError` is excluded because clients create
+ * it locally rather than receiving it from a server.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const EncodedSchema = Schema.Union([
+  RequestEncodedSchema,
+  Schema.Struct({
+    _tag: Schema.tag("Ack"),
+    requestId: RequestIdSchema
+  }),
+  Schema.Struct({
+    _tag: Schema.tag("Interrupt"),
+    requestId: RequestIdSchema
+  }),
+  Schema.Struct({ _tag: Schema.tag("Ping") }),
+  Schema.Struct({ _tag: Schema.tag("Eof") }),
+  Schema.Struct({
+    _tag: Schema.tag("Chunk"),
+    requestId: RequestIdSchema,
+    values: Schema.Uint8Array
+  }),
+  Schema.Struct({
+    _tag: Schema.tag("Exit"),
+    requestId: RequestIdSchema,
+    exit: Schema.Uint8Array
+  }),
+  Schema.Struct({
+    _tag: Schema.tag("Defect"),
+    defect: Schema.Uint8Array
+  }),
+  Schema.Struct({ _tag: Schema.tag("Pong") })
+])
+
 /**
  * Represents the reusable `Pong` message value.
  *

package/src/unstable/rpc/RpcMiddleware.ts

@@ -292,11 +292,13 @@ export const Service = <
     readonly requiredForClient?: boolean | undefined
   }
 ) => {
-  const Err = globalThis.Error as any
   const limit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const creationError = new Err()
-  setStackTraceLimit(limit)
+  let creationError: globalThis.Error | undefined
+  if (limit !== 0) {
+    setStackTraceLimit(2)
+    creationError = new globalThis.Error()
+    setStackTraceLimit(limit)
+  }
 
   function ServiceClass() {}
   const ServiceClass_ = ServiceClass as any as Mutable<AnyService>
@@ -304,7 +306,7 @@ export const Service = <
   ServiceClass.key = id
   Object.defineProperty(ServiceClass, "stack", {
     get() {
-      return creationError.stack
+      return creationError?.stack
     }
   })
   ServiceClass_[TypeId] = TypeId