TypeScript
fix(client): a big server config on a slow link no longer drops the connection in a loop (#23758)
shivamb9522c845b06
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.tsindex 1b078b192c1..3eba0e1e576 100644--- a/apps/server/src/ws.ts+++ b/apps/server/src/ws.ts@@ -262,6 +262,10 @@ import * as SessionStore from "./auth/SessionStore.ts";import { failEnvironmentAuthInvalid, failEnvironmentInternal } from "./auth/http.ts";import { isNetworkPath } from "@t3tools/shared/path";import * as RelayClient from "@t3tools/shared/relayClient";+import {+ SOCKET_FRAME_PARTS_QUERY_PARAM,+ splitLargeSocketFrames,+} from "@t3tools/shared/socketFrameParts";import { isTelemetryIdHash } from "@t3tools/shared/telemetryId";import {sameUsageLimitCommandCoverage,@@ -3533,11 +3537,25 @@ export const layer = Layer.unwrap(),),);+ const framedRpcWebSocketHttpEffect = url.value.searchParams.has(+ SOCKET_FRAME_PARTS_QUERY_PARAM,+ )+ ? rpcWebSocketHttpEffect.pipe(+ Effect.provideService(+ HttpServerRequest.HttpServerRequest,+ // The RPC server upgrades the request itself, so its socket is+ // wrapped through the request it reads.+ Object.create(request, {+ upgrade: { value: Effect.map(request.upgrade, splitLargeSocketFrames) },+ }),+ ),+ )+ : rpcWebSocketHttpEffect;return yield* Effect.acquireUseRelease(sessions.markConnected(session.sessionId),() =>Effect.raceFirst(- rpcWebSocketHttpEffect,+ framedRpcWebSocketHttpEffect,sessions.awaitInvalidation(session.sessionId, session.proofKeyThumbprint).pipe(Effect.as(HttpServerResponse.empty()),Effect.catchTags({diff --git a/packages/client-runtime/src/rpc/session.test.ts b/packages/client-runtime/src/rpc/session.test.tsindex 95702f14787..9e63f8485ad 100644--- a/packages/client-runtime/src/rpc/session.test.ts+++ b/packages/client-runtime/src/rpc/session.test.ts@@ -8,6 +8,7 @@ import {WS_METHODS,UsageLimitSourceId,} from "@t3tools/contracts";+import { splitSocketFrame } from "@t3tools/shared/socketFrameParts";import { describe, expect, it } from "@effect/vitest";import * as Cause from "effect/Cause";import * as Deferred from "effect/Deferred";@@ -21,6 +22,7 @@ import * as Schema from "effect/Schema";import * as Stream from "effect/Stream";import * as SubscriptionRef from "effect/SubscriptionRef";import * as Socket from "effect/socket/Socket";+import * as TestClock from "effect/testing/TestClock";import {AVAILABLE_CONNECTION_STATE,@@ -275,6 +277,36 @@ const publishConfigEvents = Effect.fn("TestRpcSessionFactory.publishConfigEvents});describe("RpcSessionFactory", () => {+ it.effect("connects while a large config snapshot downloads at 4000 bytes per second", () =>+ Effect.gen(function* () {+ const { factory, sockets } = yield* makeFactory();+ const session = yield* factory.connect(PREPARED);+ const readyFiber = yield* Effect.forkChild(session.ready);+ const socket = yield* awaitSocket(sockets);+ socket.open();+ const request = yield* awaitRequest(socket);+ // Multi-byte text, so parts must be sized in UTF-8 bytes and never split a surrogate pair.+ const config = { ...SERVER_CONFIG, cwd: "/" + "é€😀x".repeat(32 * 1024) };+ const frame = encodeJson({+ _tag: "Chunk",+ requestId: request.id,+ values: [{ version: 1, type: "snapshot", config: encodeServerConfig(config) }],+ });+ const parts = new URL(socket.url).searchParams.has("frameParts")+ ? splitSocketFrame(frame)+ : [frame];++ for (const part of parts) {+ const bytes = new TextEncoder().encode(part);+ yield* TestClock.adjust((bytes.length / 4000) * 1000);+ socket.serverMessage(new TextDecoder().decode(bytes));+ }+ yield* Fiber.join(readyFiber);++ expect(yield* session.initialConfig).toEqual(config);+ }),+ );+it.effect("owns one scoped websocket attempt and exposes readiness and closure", () =>Effect.gen(function* () {const { factory, sockets } = yield* makeFactory();@@ -282,7 +314,7 @@ describe("RpcSessionFactory", () => {const readyFiber = yield* Effect.forkChild(session.ready);const socket = yield* awaitSocket(sockets);- expect(socket.url).toBe(PREPARED.socketUrl);+ expect(socket.url).toBe(`${PREPARED.socketUrl}&frameParts=1`);socket.open();yield* completeInitialConfig(socket);yield* Fiber.join(readyFiber);diff --git a/packages/client-runtime/src/rpc/session.ts b/packages/client-runtime/src/rpc/session.tsindex fa654561844..ddf591b1391 100644--- a/packages/client-runtime/src/rpc/session.ts+++ b/packages/client-runtime/src/rpc/session.ts@@ -4,6 +4,10 @@ import {WsSubscribeServerConfigRpc,WS_METHODS,} from "@t3tools/contracts";+import {+ joinSocketFrameParts,+ SOCKET_FRAME_PARTS_QUERY_PARAM,+} from "@t3tools/shared/socketFrameParts";import * as Cause from "effect/Cause";import * as Context from "effect/Context";import * as Deferred from "effect/Deferred";@@ -223,9 +227,17 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* (});return socket;};- const layerSocket = Socket.layerWebSocket(connection.socketUrl, {- openTimeout: SOCKET_OPEN_TIMEOUT,- }).pipe(+ const socketUrl = new URL(connection.socketUrl);+ socketUrl.searchParams.set(SOCKET_FRAME_PARTS_QUERY_PARAM, "1");+ const layerSocket = Layer.effect(+ Socket.Socket,+ Effect.map(Effect.service(Socket.Socket), joinSocketFrameParts),+ ).pipe(+ Layer.provide(+ Socket.layerWebSocket(socketUrl.toString(), {+ openTimeout: SOCKET_OPEN_TIMEOUT,+ }),+ ),Layer.provide(Layer.succeed(Socket.WebSocketConstructor, countingWebSocketConstructor)),);const layerProtocol = Layer.effect(diff --git a/packages/shared/package.json b/packages/shared/package.jsonindex b09248b2163..67426ca8d8a 100644--- a/packages/shared/package.json+++ b/packages/shared/package.json@@ -19,6 +19,10 @@"types": "./src/delimitedPreview.ts","import": "./src/delimitedPreview.ts"},+ "./socketFrameParts": {+ "types": "./src/socketFrameParts.ts",+ "import": "./src/socketFrameParts.ts"+ },"./composerPullRequestMatches": {"types": "./src/composerPullRequestMatches.ts","import": "./src/composerPullRequestMatches.ts"diff --git a/packages/shared/src/socketFrameParts.ts b/packages/shared/src/socketFrameParts.tsnew file mode 100644index 00000000000..e0c82a87de3--- /dev/null+++ b/packages/shared/src/socketFrameParts.ts@@ -0,0 +1,81 @@+import * as Arr from "effect/Array";+import * as Effect from "effect/Effect";+import * as Socket from "effect/socket/Socket";++// Old clients omit this; old servers ignore it.+export const SOCKET_FRAME_PARTS_QUERY_PARAM = "frameParts";++// WebSocket messages arrive whole. At 4,000 bytes/s each part takes about+// 12 seconds, leaving margin before the client's 15-second liveness timeout.+const SOCKET_FRAME_PART_BYTES = 48 * 1024;++// No JSON message starts with a record separator. It marks every part but the last.+const PART_PREFIX = "\u001e";++// The RPC client only counts frames that decode to messages as liveness, and+// ignores pongs, so each held-back part reads to it as one.+const PART_RECEIVED_FRAME = '{"_tag":"Pong"}';++/** Splits on the UTF-8 size the frame has on the wire, never inside a surrogate pair. */+export function splitSocketFrame(+ frame: string,+ partBytes = SOCKET_FRAME_PART_BYTES,+): Arr.NonEmptyReadonlyArray<string> {+ // UTF-8 spends at most 3 bytes on a UTF-16 code unit.+ if (frame.length * 3 <= partBytes) return [frame];+ const parts: Array<string> = [];+ let start = 0;+ let bytes = PART_PREFIX.length;+ for (let index = 0; index < frame.length;) {+ const code = frame.charCodeAt(index);+ const pair = code >= 0xd800 && code <= 0xdbff && index + 1 < frame.length;+ const size = pair ? 4 : code < 0x80 ? 1 : code < 0x800 ? 2 : 3;+ if (bytes + size > partBytes) {+ parts.push(PART_PREFIX + frame.slice(start, index));+ start = index;+ bytes = PART_PREFIX.length;+ }+ bytes += size;+ index += pair ? 2 : 1;+ }+ return Arr.append(parts, frame.slice(start));+}++/** Server side: sends string frames longer than one part as consecutive parts. */+export function splitLargeSocketFrames(socket: Socket.Socket): Socket.Socket {+ const split = (chunk: string | Uint8Array): Arr.NonEmptyReadonlyArray<string | Uint8Array> =>+ typeof chunk === "string" ? splitSocketFrame(chunk) : [chunk];+ return Socket.make({+ reader: socket.reader,+ writer: Effect.map(socket.writer, (writer) => ({+ write: (chunk) =>+ typeof chunk === "string" ? writer.writeAll(splitSocketFrame(chunk)) : writer.write(chunk),+ writeAll: (chunks) => writer.writeAll(Arr.flatMap(chunks, split)),+ })),+ });+}++/** Client side: joins parts back into whole frames. */+export function joinSocketFrameParts(socket: Socket.Socket): Socket.Socket {+ return Socket.make({+ reader: Effect.map(socket.reader, (reader) => {+ let pending = "";+ const join = (frame: string | Uint8Array) => {+ if (typeof frame !== "string") return frame;+ if (frame.startsWith(PART_PREFIX)) {+ pending += frame.slice(PART_PREFIX.length);+ return PART_RECEIVED_FRAME;+ }+ if (pending === "") return frame;+ const whole = pending + frame;+ pending = "";+ return whole;+ };+ return {+ upgrade: reader.upgrade,+ pull: Effect.map(reader.pull, Arr.map(join)),+ };+ }),+ writer: socket.writer,+ });+}