effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/unstable/rpc/RpcClient.ts

@@ -946,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)
         }
@@ -1055,19 +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()
 
     // `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(() => write(parser.encode(constPing)!)))
+    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))
@@ -1079,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
+        }
+        while (true) {
+          const frames = yield* pull
+          for (let i = 0; i < frames.length; i++) {
+            yield* processData(frames[i])
+          }
         }
-      }, { onOpen }).pipe(
+      }).pipe(
+        Effect.scoped,
         Effect.raceFirst(Effect.flatMap(
           pinger.timeout,
           () =>
@@ -1135,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)
@@ -1182,7 +1185,7 @@ 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,

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.

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

package/src/unstable/rpc/RpcSerialization.ts

@@ -3,13 +3,12 @@
  *
  * `RpcSerialization` is the boundary between `RpcMessage` envelopes and the
  * bytes or strings carried by a transport. This module provides built-in
- * serializers for JSON, newline-delimited JSON, JSON-RPC 2.0, MessagePack, and
- * SchemaBinary, including framed formats that can decode multiple messages
+ * serializers for JSON, newline-delimited JSON, JSON-RPC 2.0, and SchemaBinary,
+ * including framed formats that can decode multiple messages
  * from streaming chunks.
  *
  * @since 4.0.0
  */
-import * as Msgpackr from "msgpackr"
 import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Layer from "../../Layer.ts"
@@ -39,6 +38,11 @@ export type CodecFor = <S extends Schema.Top>(
 
 const codecForJson = Schema.toCodecJson as CodecFor
 
+// shared by every parser that decodes whole frames, so creating a parser does
+// not pay for a native TextDecoder
+let sharedTextDecoder: TextDecoder | undefined
+const decodeText = (bytes: Uint8Array): string => (sharedTextDecoder ??= new TextDecoder()).decode(bytes)
+
 /**
  * Service that describes how RPC protocol messages are encoded and decoded,
  * including the content type and whether the serialization format provides
@@ -119,16 +123,13 @@ export const json: RpcSerialization["Service"] = RpcSerialization.of({
   contentType: "application/json",
   includesFraming: false,
   codecFor: codecForJson,
-  makeUnsafe: () => {
-    const decoder = new TextDecoder()
-    return {
-      decode: (bytes) => {
-        const decoded = JSON.parse(typeof bytes === "string" ? bytes : decoder.decode(bytes))
-        return Array.isArray(decoded) ? decoded : [decoded]
-      },
-      encode: (response) => JSON.stringify(response)
-    }
-  }
+  makeUnsafe: () => ({
+    decode: (bytes) => {
+      const decoded = JSON.parse(typeof bytes === "string" ? bytes : decodeText(bytes))
+      return Array.isArray(decoded) ? decoded : [decoded]
+    },
+    encode: (response) => JSON.stringify(response)
+  })
 })
 
 /**
@@ -145,7 +146,8 @@ export const makeNdjson = (options?: StreamOptions): RpcSerialization["Service"]
     includesFraming: true,
     codecFor: codecForJson,
     makeUnsafe: () => {
-      const decoder = new TextDecoder()
+      // lazily created: string transports never need byte decoding
+      let decoder: TextDecoder | undefined
       let buffer = ""
       const failMaxBufferSize = (maxBufferSize: number): never => {
         buffer = ""
@@ -153,7 +155,7 @@ export const makeNdjson = (options?: StreamOptions): RpcSerialization["Service"]
       }
       return ({
         decode: (bytes) => {
-          buffer += typeof bytes === "string" ? bytes : decoder.decode(bytes, { stream: true })
+          buffer += typeof bytes === "string" ? bytes : (decoder ??= new TextDecoder()).decode(bytes, { stream: true })
           let position = 0
           let nlIndex = buffer.indexOf("\n", position)
           const items: Array<unknown> = []
@@ -211,7 +213,6 @@ export const jsonRpc = (options?: {
     includesFraming: false,
     codecFor: codecForJson,
     makeUnsafe: () => {
-      const decoder = new TextDecoder()
       const batches = new Map<string | number, {
         readonly size: number
         readonly responses: Map<string | number, RpcMessage.FromServerEncoded>
@@ -219,7 +220,7 @@ export const jsonRpc = (options?: {
       return {
         decode: (bytes) => {
           const decoded: JsonRpcMessage | Array<JsonRpcMessage> = JSON.parse(
-            typeof bytes === "string" ? bytes : decoder.decode(bytes)
+            typeof bytes === "string" ? bytes : decodeText(bytes)
           )
           return decodeJsonRpcRaw(decoded, batches)
         },
@@ -305,7 +306,7 @@ function decodeJsonRpcMessage(decoded: JsonRpcMessage): RpcMessage.FromClientEnc
         | RpcMessage.FromServerEncoded["_tag"]
         | Exclude<RpcMessage.FromClientEncoded["_tag"], "Request">
       const requestId = (request as any).params?.requestId
-      return requestId ?
+      return requestId !== undefined ?
         {
           _tag: tag,
           requestId
@@ -525,90 +526,21 @@ interface JsonRpcResponse {
 
 type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse
 
-/**
- * Create a MessagePack serialization with custom msgpackr options.
- *
- * @category serialization
- * @since 4.0.0
- */
-export const makeMsgPack = (
-  options?: (Msgpackr.Options & StreamOptions) | undefined
-): RpcSerialization["Service"] => {
-  const { maxBufferSize = defaultMaxBufferSize, ...msgpackOptions } = options ?? {}
-  return RpcSerialization.of({
-    contentType: "application/msgpack",
-    includesFraming: true,
-    codecFor: codecForJson,
-    makeUnsafe: () => {
-      const unpackr = new Msgpackr.Unpackr(msgpackOptions)
-      const packr = new Msgpackr.Packr(msgpackOptions)
-      const encoder = new TextEncoder()
-      let incomplete: Uint8Array | undefined = undefined
-      const failMaxBufferSize = (maxBufferSize: number): never => {
-        incomplete = undefined
-        throw new MaxBufferSizeExceeded({ maxBufferSize })
-      }
-      return {
-        decode(bytes) {
-          let buf = typeof bytes === "string" ? encoder.encode(bytes) : bytes
-          if (incomplete !== undefined) {
-            if (isBufferSizeExceeded(incomplete.length + buf.length, maxBufferSize)) {
-              failMaxBufferSize(maxBufferSize)
-            }
-            const prev = buf
-            bytes = new Uint8Array(incomplete.length + buf.length)
-            bytes.set(incomplete)
-            bytes.set(prev, incomplete.length)
-            buf = bytes
-            incomplete = undefined
-          }
-          try {
-            return unpackr.unpackMultiple(buf)
-          } catch (error_) {
-            const error = error_ as any
-            if (error.incomplete) {
-              incomplete = buf.subarray(error.lastPosition)
-              if (isBufferSizeExceeded(incomplete.length, maxBufferSize)) {
-                failMaxBufferSize(maxBufferSize)
-              }
-              return error.values ?? []
-            }
-            throw error_
-          }
-        },
-        encode: (response) => packr.pack(response)
-      }
-    }
-  })
-}
-
-/**
- * Default MessagePack RPC serialization using record support and built-in
- * message framing.
- *
- * @category serialization
- * @since 4.0.0
- */
-export const msgPack: RpcSerialization["Service"] = makeMsgPack({ useRecords: true })
-
 const defaultSchemaBinaryMaxFrameSize = 16 * 1024 * 1024
 
 const schemaBinaryTextEncoder = new TextEncoder()
 
 const makeSchemaBinary = (options?: {
-  readonly maxFrameSize?: number | undefined
+  readonly maxFrameSize?: number | "unbounded" | undefined
   readonly fingerprintPayloads?: boolean | undefined
 }): RpcSerialization["Service"] => {
-  const maxFrameSize = options?.maxFrameSize ?? defaultSchemaBinaryMaxFrameSize
+  const maxFrameSize = options?.maxFrameSize === "unbounded"
+    ? undefined
+    : options?.maxFrameSize ?? defaultSchemaBinaryMaxFrameSize
   const codecFor: CodecFor = options?.fingerprintPayloads === true
     ? (schema) => SchemaBinary.toCodecDirect(schema, { fingerprint: true })
     : SchemaBinary.toCodecDirect
-  // The envelope repeats itself: the same RPC tag, header names, and trace ids
-  // come back on message after message. A dictionary shared by every frame on
-  // the connection sends each of those once and references it afterwards, so
-  // the writer and the reader here are a matched pair and neither one works
-  // against a peer that was built without the other.
-  const envelopeOptions = { fingerprint: true, dictionary: true } as const
+  const envelopeOptions = { fingerprint: true } as const
   return RpcSerialization.of({
     contentType: "application/vnd.effect.rpc+schema-binary",
     includesFraming: true,
@@ -689,38 +621,16 @@ export const layerNdJsonRpc = (options?: {
   readonly maxBufferSize?: number | "unbounded" | undefined
 }): Layer.Layer<RpcSerialization> => Layer.succeed(RpcSerialization)(ndJsonRpc(options))
 
-/**
- * RPC serialization layer that uses MessagePack for serialization.
- *
- * **Details**
- *
- * MessagePack has a more compact binary format compared to JSON and NDJSON. It
- * also has better support for binary data.
- *
- * @category layers
- * @since 4.0.0
- */
-export const layerMsgPack: Layer.Layer<RpcSerialization> = Layer.succeed(RpcSerialization)(msgPack)
-
-/**
- * RPC serialization layer that uses MessagePack with custom options.
- *
- * @category layers
- * @since 4.0.0
- */
-export const layerMsgPackWith = (
-  options?: (Msgpackr.Options & StreamOptions) | undefined
-): Layer.Layer<RpcSerialization> => Layer.succeed(RpcSerialization)(makeMsgPack(options))
-
 /**
  * RPC serialization layer that uses SchemaBinary with fingerprinted RPC
  * envelopes. Payload fingerprints are disabled by default to support compatible
- * schema evolution. Frames default to a 16 MiB maximum size.
+ * schema evolution. Frames default to a 16 MiB maximum size. Use `"unbounded"`
+ * to disable the frame-size limit.
  *
  * @category layers
  * @since 4.0.0
  */
 export const layerSchemaBinary = (options?: {
-  readonly maxFrameSize?: number | undefined
+  readonly maxFrameSize?: number | "unbounded" | undefined
   readonly fingerprintPayloads?: boolean | undefined
 }): Layer.Layer<RpcSerialization> => Layer.sync(RpcSerialization)(() => makeSchemaBinary(options))