The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import * as BunHttpServer from "@effect/platform-bun/BunHttpServer" |
| 2 | import { assert, describe, it } from "@effect/vitest" |
| 3 | import * as ByteSize from "effect/ByteSize" |
| 4 | import * as Deferred from "effect/Deferred" |
| 5 | import * as Effect from "effect/Effect" |
| 6 | import * as Exit from "effect/Exit" |
| 7 | import * as Fiber from "effect/Fiber" |
| 8 | import * as FetchHttpClient from "effect/http/FetchHttpClient" |
| 9 | import * as HttpBody from "effect/http/HttpBody" |
| 10 | import * as HttpClient from "effect/http/HttpClient" |
| 11 | import * as HttpIncomingMessage from "effect/http/HttpIncomingMessage" |
| 12 | import * as HttpMiddleware from "effect/http/HttpMiddleware" |
| 13 | import * as HttpRouter from "effect/http/HttpRouter" |
| 14 | import * as HttpServer from "effect/http/HttpServer" |
| 15 | import * as HttpServerRequest from "effect/http/HttpServerRequest" |
| 16 | import * as HttpServerResponse from "effect/http/HttpServerResponse" |
| 17 | import * as Layer from "effect/Layer" |
| 18 | import * as Logger from "effect/Logger" |
| 19 | import * as NetAddress from "effect/net/NetAddress" |
| 20 | import * as References from "effect/References" |
| 21 | import * as Scope from "effect/Scope" |
| 22 | import * as Socket from "effect/socket/Socket" |
| 23 | import * as Stream from "effect/Stream" |
| 24 | import { mkdtemp, rm } from "node:fs/promises" |
| 25 | import * as Net from "node:net" |
| 26 | import { tmpdir } from "node:os" |
| 27 | import { join } from "node:path" |
| 28 | |
| 29 | const fetchText = (url: string) => |
| 30 | Effect.promise(() => fetch(url, { headers: { connection: "close" } }).then((response) => response.text())) |
| 31 | |
| 32 | const readWebSocketClose = (port: number, opened: Deferred.Deferred<void>, path = "/") => |
| 33 | Effect.callback<number, Error>((resume) => { |
| 34 | const socket = Net.createConnection({ host: "127.0.0.1", port }) |
| 35 | let received = Buffer.alloc(0) |
| 36 | let upgraded = false |
| 37 | let closeCode: number | undefined |
| 38 | socket.on("close", () => { |
| 39 | if (closeCode !== undefined) resume(Effect.succeed(closeCode)) |
| 40 | }) |
| 41 | socket.on("connect", () => |
| 42 | socket.write([ |
| 43 | `GET ${path} HTTP/1.1`, |
| 44 | "Host: 127.0.0.1:" + port, |
| 45 | "Connection: Upgrade", |
| 46 | "Upgrade: websocket", |
| 47 | "Sec-WebSocket-Version: 13", |
| 48 | "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==", |
| 49 | "", |
| 50 | "" |
| 51 | ].join("\r\n"))) |
| 52 | socket.on("error", (error) => resume(Effect.fail(error))) |
| 53 | socket.on("data", (chunk) => { |
| 54 | received = Buffer.concat([received, typeof chunk === "string" ? Buffer.from(chunk) : chunk]) |
| 55 | if (!upgraded) { |
| 56 | const headerEnd = received.indexOf("\r\n\r\n") |
| 57 | if (headerEnd === -1) return |
| 58 | if (!received.subarray(0, headerEnd).toString().startsWith("HTTP/1.1 101")) { |
| 59 | resume(Effect.fail(new Error("WebSocket upgrade was refused"))) |
| 60 | return |
| 61 | } |
| 62 | upgraded = true |
| 63 | received = received.subarray(headerEnd + 4) |
| 64 | Effect.runSync(Deferred.succeed(opened, undefined)) |
| 65 | } |
| 66 | if (received.length < 4 || (received[0] & 0x0f) !== 8) return |
| 67 | if (closeCode !== undefined) return |
| 68 | closeCode = received.readUInt16BE(2) |
| 69 | socket.write(Buffer.from([0x88, 0x82, 0, 0, 0, 0, closeCode >> 8, closeCode & 0xff])) |
| 70 | }) |
| 71 | return Effect.sync(() => socket.destroy()) |
| 72 | }) |
| 73 | |
| 74 | // Force-stop Bun after the close frame; graceful stop can hang here. |
| 75 | const makeForceStoppableServer = Effect.gen(function*() { |
| 76 | const serve = Bun.serve |
| 77 | let forceStop: (() => void) | undefined |
| 78 | Bun.serve = ((options: Parameters<typeof Bun.serve>[0]) => { |
| 79 | const bunServer = serve(options) |
| 80 | forceStop = () => { |
| 81 | bunServer.stop(true) |
| 82 | } |
| 83 | return bunServer |
| 84 | }) as typeof Bun.serve |
| 85 | const server = yield* BunHttpServer.make({ |
| 86 | hostname: "127.0.0.1", |
| 87 | port: 0, |
| 88 | gracefulShutdownTimeout: "100 millis" |
| 89 | }).pipe(Effect.ensuring(Effect.sync(() => { |
| 90 | Bun.serve = serve |
| 91 | }))) |
| 92 | return { server, forceStop: () => forceStop?.() } |
| 93 | }) |
| 94 | |
| 95 | interface WebSocketFrame { |
| 96 | readonly opcode: number |
| 97 | readonly payload: Uint8Array |
| 98 | readonly payloadLength: number |
| 99 | readonly rsv1: boolean |
| 100 | } |
| 101 | |
| 102 | interface WebSocketFrames { |
| 103 | readonly frames: ReadonlyArray<WebSocketFrame> |
| 104 | readonly headers: string |
| 105 | } |
| 106 | |
| 107 | const readWebSocketFrames = (port: number, perMessageDeflate: boolean) => |
| 108 | Effect.callback<WebSocketFrames, Error>((resume) => { |
| 109 | const socket = Net.createConnection({ host: "127.0.0.1", port }) |
| 110 | let received = Buffer.alloc(0) |
| 111 | let result: WebSocketFrames | undefined |
| 112 | |
| 113 | socket.on("connect", () => { |
| 114 | socket.write([ |
| 115 | "GET / HTTP/1.1", |
| 116 | `Host: 127.0.0.1:${port}`, |
| 117 | "Connection: Upgrade", |
| 118 | "Upgrade: websocket", |
| 119 | "Sec-WebSocket-Version: 13", |
| 120 | "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==", |
| 121 | ...(perMessageDeflate ? ["Sec-WebSocket-Extensions: permessage-deflate"] : []), |
| 122 | "", |
| 123 | "" |
| 124 | ].join("\r\n")) |
| 125 | }) |
| 126 | socket.on("error", (error) => resume(Effect.fail(error))) |
| 127 | socket.on("close", () => { |
| 128 | if (result) resume(Effect.succeed(result)) |
| 129 | }) |
| 130 | socket.on("data", (chunk) => { |
| 131 | if (result) return |
| 132 | received = Buffer.concat([received, typeof chunk === "string" ? Buffer.from(chunk) : chunk]) |
| 133 | const headerEnd = received.indexOf("\r\n\r\n") |
| 134 | if (headerEnd === -1) return |
| 135 | |
| 136 | const headers = received.subarray(0, headerEnd).toString() |
| 137 | const frames: Array<WebSocketFrame> = [] |
| 138 | let offset = headerEnd + 4 |
| 139 | while (frames.length < 2) { |
| 140 | if (received.length < offset + 2) return |
| 141 | const first = received[offset] |
| 142 | const length = received[offset + 1] & 0x7f |
| 143 | const headerLength = length === 126 ? 4 : 2 |
| 144 | if (received.length < offset + headerLength) return |
| 145 | const payloadLength = length === 126 ? received.readUInt16BE(offset + 2) : length |
| 146 | if (received.length < offset + headerLength + payloadLength) return |
| 147 | frames.push({ |
| 148 | opcode: first & 0x0f, |
| 149 | payload: Uint8Array.from(received.subarray(offset + headerLength, offset + headerLength + payloadLength)), |
| 150 | payloadLength, |
| 151 | rsv1: (first & 0x40) !== 0 |
| 152 | }) |
| 153 | offset += headerLength + payloadLength |
| 154 | } |
| 155 | result = { frames, headers } |
| 156 | socket.write(Buffer.from([0x88, 0x82, 0, 0, 0, 0, 0x03, 0xe8])) |
| 157 | }) |
| 158 | |
| 159 | return Effect.sync(() => socket.destroy()) |
| 160 | }) |
| 161 | |
| 162 | const makeWebSocketServer = Effect.fnUntraced(function*(payload: string, compressionThreshold?: number) { |
| 163 | const server = yield* BunHttpServer.make({ |
| 164 | hostname: "127.0.0.1", |
| 165 | port: 0, |
| 166 | websocket: { perMessageDeflate: true, compressionThreshold } |
| 167 | }) |
| 168 | yield* server.serve(Effect.gen(function*() { |
| 169 | const request = yield* HttpServerRequest.HttpServerRequest |
| 170 | const socket = yield* request.upgrade |
| 171 | yield* Effect.gen(function*() { |
| 172 | const { pull } = yield* socket.reader |
| 173 | const writer = yield* socket.writer |
| 174 | yield* Effect.orDie(writer.write(payload)) |
| 175 | yield* Effect.orDie(writer.write(new TextEncoder().encode(payload))) |
| 176 | while (true) { |
| 177 | yield* pull |
| 178 | } |
| 179 | }).pipe( |
| 180 | Effect.scoped, |
| 181 | Effect.catchTag("SocketError", () => Effect.void), |
| 182 | Effect.orDie |
| 183 | ) |
| 184 | return HttpServerResponse.empty() |
| 185 | })) |
| 186 | return server |
| 187 | }) |
| 188 | |
| 189 | describe("BunHttpServer", () => { |
| 190 | describe("serve scope ownership", { concurrent: false }, () => { |
| 191 | it.live("closes the request scope when a streaming body is cancelled synchronously during construction", () => |
| 192 | Effect.gen(function*() { |
| 193 | let finalized = false |
| 194 | let pulled = false |
| 195 | let cancellation: Promise<void> | undefined |
| 196 | const OriginalResponse = globalThis.Response |
| 197 | yield* Effect.acquireRelease( |
| 198 | Effect.sync(() => { |
| 199 | // Intercept construction: awaiting a response over HTTP lets the first pull run already. |
| 200 | globalThis.Response = class extends OriginalResponse { |
| 201 | constructor(body?: BodyInit | null, init?: ResponseInit) { |
| 202 | if (body instanceof ReadableStream) { |
| 203 | cancellation = body.cancel() |
| 204 | super(null, init) |
| 205 | } else { |
| 206 | super(body, init) |
| 207 | } |
| 208 | } |
| 209 | } |
| 210 | }), |
| 211 | () => |
| 212 | Effect.sync(() => { |
| 213 | globalThis.Response = OriginalResponse |
| 214 | }) |
| 215 | ) |
| 216 | yield* HttpServer.serveEffect(Effect.gen(function*() { |
| 217 | yield* Effect.addFinalizer(() => |
| 218 | Effect.sync(() => { |
| 219 | finalized = true |
| 220 | }) |
| 221 | ) |
| 222 | return HttpServerResponse.stream(Stream.fromEffect(Effect.sync(() => { |
| 223 | pulled = true |
| 224 | return new Uint8Array([1]) |
| 225 | }))) |
| 226 | })) |
| 227 | const response = yield* HttpClient.get("/") |
| 228 | assert.strictEqual(response.status, 200) |
| 229 | yield* response.text |
| 230 | assert.isDefined(cancellation) |
| 231 | yield* Effect.promise(() => cancellation!) |
| 232 | assert.strictEqual(pulled, false) |
| 233 | assert.strictEqual(finalized, true) |
| 234 | }).pipe(Effect.timeout("2 seconds"), Effect.provide(BunHttpServer.layerTest))) |
| 235 | |
| 236 | it.live("interrupts a streaming body suspended during startup when the serve scope closes", () => |
| 237 | Effect.gen(function*() { |
| 238 | let finalized = false |
| 239 | const started = yield* Deferred.make<void>() |
| 240 | const release = yield* Deferred.make<void>() |
| 241 | const server = yield* BunHttpServer.make({ hostname: "127.0.0.1", port: 0, disablePreemptiveShutdown: true }) |
| 242 | // Let the body finish on teardown so the server can stop if it was never interrupted. |
| 243 | yield* Effect.addFinalizer(() => Deferred.succeed(release, undefined)) |
| 244 | const serveScope = yield* Scope.fork(yield* Effect.scope) |
| 245 | yield* server.serve(Effect.gen(function*() { |
| 246 | yield* Effect.addFinalizer(() => |
| 247 | Effect.sync(() => { |
| 248 | finalized = true |
| 249 | }) |
| 250 | ) |
| 251 | // The body suspends during startup, before it can serve a pull. |
| 252 | return HttpServerResponse.stream( |
| 253 | Stream.transformPull( |
| 254 | Stream.empty, |
| 255 | (pull) => |
| 256 | Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)), Effect.as(pull)) |
| 257 | ) |
| 258 | ) |
| 259 | })).pipe(Scope.provide(serveScope)) |
| 260 | // Not awaited: headers may not be sent while the body is suspended. |
| 261 | fetch(NetAddress.formatUrlUnsafe(server.address), { headers: { connection: "close" } }).catch(() => undefined) |
| 262 | yield* Deferred.await(started) |
| 263 | assert.strictEqual(finalized, false) |
| 264 | yield* Scope.close(serveScope, Exit.void) |
| 265 | assert.strictEqual(finalized, true) |
| 266 | }).pipe(Effect.timeout("2 seconds"))) |
| 267 | }) |
| 268 | |
| 269 | for (const kind of ["serveEffect", "uninterruptible route"] as const) { |
| 270 | it.live(`closes the request scope when ${kind} returns a stream after client abort`, () => |
| 271 | Effect.gen(function*() { |
| 272 | const closed = yield* Deferred.make<void>() |
| 273 | const controller = new AbortController() |
| 274 | const handler = Effect.gen(function*() { |
| 275 | yield* Effect.addFinalizer(() => Deferred.succeed(closed, undefined)) |
| 276 | const request = yield* HttpServerRequest.HttpServerRequest |
| 277 | const signal = (request.source as Request).signal |
| 278 | // Wait for Bun to observe the disconnect before returning the response. |
| 279 | yield* Effect.callback<void>((resume) => { |
| 280 | const onAbort = () => resume(Effect.void) |
| 281 | signal.addEventListener("abort", onAbort, { once: true }) |
| 282 | controller.abort() |
| 283 | return Effect.sync(() => signal.removeEventListener("abort", onAbort)) |
| 284 | }) |
| 285 | const chunk = new TextEncoder().encode("body") |
| 286 | return HttpServerResponse.stream(Stream.concat(Stream.succeed(chunk), Stream.succeed(chunk))) |
| 287 | }) |
| 288 | if (kind === "serveEffect") { |
| 289 | yield* HttpServer.serveEffect(handler) |
| 290 | } else { |
| 291 | yield* HttpRouter.add("GET", "/", handler, { uninterruptible: true }).pipe( |
| 292 | HttpRouter.serve, |
| 293 | Layer.build |
| 294 | ) |
| 295 | } |
| 296 | const server = yield* HttpServer.HttpServer |
| 297 | const aborted = yield* Effect.promise(() => |
| 298 | fetch(NetAddress.formatUrlUnsafe(server.address), { signal: controller.signal }).then( |
| 299 | () => false, |
| 300 | () => true |
| 301 | ) |
| 302 | ) |
| 303 | assert.isTrue(aborted) |
| 304 | yield* Deferred.await(closed).pipe(Effect.timeout("2 seconds")) |
| 305 | }).pipe(Effect.provide(BunHttpServer.layerTest)), 5000) |
| 306 | } |
| 307 | |
| 308 | it.live("keeps quiet response streams open unless an idle timeout is configured", () => |
| 309 | Effect.gen(function*() { |
| 310 | const quietStream = Effect.fnUntraced(function*(idleTimeout?: number) { |
| 311 | const server = yield* BunHttpServer.make({ |
| 312 | hostname: "127.0.0.1", |
| 313 | port: 0, |
| 314 | gracefulShutdownTimeout: "100 millis", |
| 315 | ...(idleTimeout === undefined ? {} : { idleTimeout }) |
| 316 | }) |
| 317 | yield* server.serve(Effect.succeed(HttpServerResponse.stream(Stream.concat( |
| 318 | Stream.succeed(new TextEncoder().encode("a")), |
| 319 | // Longer than Bun's 10 second default idle timeout plus its timer granularity. |
| 320 | Stream.fromEffect(Effect.as(Effect.sleep("15 seconds"), new TextEncoder().encode("b"))) |
| 321 | )))) |
| 322 | return yield* Effect.exit(fetchText(NetAddress.formatUrlUnsafe(server.address))) |
| 323 | }) |
| 324 | const [omitted, explicit] = yield* Effect.all([Effect.scoped(quietStream()), Effect.scoped(quietStream(1))], { |
| 325 | concurrency: "unbounded" |
| 326 | }) |
| 327 | assert.deepStrictEqual(omitted, Exit.succeed("ab")) |
| 328 | assert.isTrue(Exit.hasDies(explicit)) |
| 329 | }).pipe(Effect.timeout("25 seconds")), 30000) |
| 330 | |
| 331 | describe("body omission", () => { |
| 332 | for (const status of [204, 205, 304]) { |
| 333 | for (const bodyKind of ["text", "stream"]) { |
| 334 | it.live(`omits ${bodyKind} bodies for status ${status}`, () => |
| 335 | Effect.gen(function*() { |
| 336 | let finalized = false |
| 337 | let streamStarted = false |
| 338 | yield* HttpServer.serveEffect(Effect.gen(function*() { |
| 339 | yield* Effect.addFinalizer(() => |
| 340 | Effect.sync(() => { |
| 341 | finalized = true |
| 342 | }) |
| 343 | ) |
| 344 | const options = { status, contentType: "text/plain", contentLength: 4 } |
| 345 | return bodyKind === "text" |
| 346 | ? HttpServerResponse.text("body", options) |
| 347 | : HttpServerResponse.stream( |
| 348 | Stream.fromEffect(Effect.sync(() => { |
| 349 | streamStarted = true |
| 350 | return new TextEncoder().encode("body") |
| 351 | })), |
| 352 | options |
| 353 | ) |
| 354 | })) |
| 355 | const response = yield* HttpClient.get("/") |
| 356 | assert.strictEqual(response.status, status) |
| 357 | assert.strictEqual(yield* response.text, "") |
| 358 | assert.strictEqual(streamStarted, false) |
| 359 | assert.strictEqual(finalized, true) |
| 360 | if (status === 304) { |
| 361 | assert.strictEqual(response.headers["content-type"], "text/plain") |
| 362 | } |
| 363 | }).pipe( |
| 364 | Effect.timeout("2 seconds"), |
| 365 | Effect.provide(BunHttpServer.layerTest) |
| 366 | ), 5000) |
| 367 | } |
| 368 | } |
| 369 | |
| 370 | for (const [method, status] of [["HEAD", 200], ["GET", 204], ["GET", 205], ["GET", 304]] as const) { |
| 371 | it.live(`cancels raw streams for ${method} status ${status}`, () => |
| 372 | Effect.gen(function*() { |
| 373 | let cancelled = false |
| 374 | const body = new ReadableStream<Uint8Array>({ |
| 375 | pull(controller) { |
| 376 | controller.enqueue(new TextEncoder().encode("body")) |
| 377 | controller.close() |
| 378 | }, |
| 379 | cancel() { |
| 380 | cancelled = true |
| 381 | } |
| 382 | }, { highWaterMark: 0 }) |
| 383 | yield* Effect.addFinalizer(() => Effect.ignoreCause(Effect.promise(() => body.cancel()))) |
| 384 | yield* HttpServer.serveEffect(Effect.succeed(HttpServerResponse.raw(body, { |
| 385 | status, |
| 386 | contentType: "text/plain", |
| 387 | contentLength: 4 |
| 388 | }))) |
| 389 | const response = yield* (method === "HEAD" ? HttpClient.head("/") : HttpClient.get("/")) |
| 390 | assert.strictEqual(response.status, status) |
| 391 | assert.strictEqual(yield* response.text, "") |
| 392 | assert.strictEqual(cancelled, true) |
| 393 | if (method === "HEAD") { |
| 394 | assert.strictEqual(response.headers["content-length"], "4") |
| 395 | } |
| 396 | if (method === "HEAD" || status === 304) { |
| 397 | assert.strictEqual(response.headers["content-type"], "text/plain") |
| 398 | } |
| 399 | }).pipe( |
| 400 | Effect.timeout("2 seconds"), |
| 401 | Effect.provide(BunHttpServer.layerTest) |
| 402 | ), 5000) |
| 403 | } |
| 404 | }) |
| 405 | |
| 406 | for ( |
| 407 | const [name, options, expectedTag, expectedIp] of [ |
| 408 | ["omitted hostname", { port: 0 }, "InetAddressV6", "::"], |
| 409 | ["undefined Unix path and omitted hostname", { port: 0, unix: undefined }, "InetAddressV6", "::"], |
| 410 | ["explicit wildcard hostname", { port: 0, hostname: "0.0.0.0" }, "InetAddressV4", "0.0.0.0"] |
| 411 | ] as const |
| 412 | ) { |
| 413 | it.effect(`starts a layer with ${name}`, () => |
| 414 | Effect.gen(function*() { |
| 415 | const server = yield* HttpServer.HttpServer |
| 416 | if (server.address._tag !== expectedTag) { |
| 417 | return assert.fail(`expected ${expectedTag}, got ${server.address._tag}`) |
| 418 | } |
| 419 | assert.strictEqual(NetAddress.formatIp(server.address.address), expectedIp) |
| 420 | assert.isAbove(server.address.port, 0) |
| 421 | |
| 422 | yield* server.serve(Effect.succeed(HttpServerResponse.text("default hostname"))) |
| 423 | const client = yield* HttpServer.makeTestClient.pipe(Effect.provide(FetchHttpClient.layer)) |
| 424 | const response = yield* client.get("/") |
| 425 | assert.strictEqual(response.status, 200) |
| 426 | assert.strictEqual(yield* response.text, "default hostname") |
| 427 | }).pipe(Effect.provide(BunHttpServer.layer(options)))) |
| 428 | } |
| 429 | |
| 430 | it.effect("treats an undefined Unix path as a TCP listener", () => |
| 431 | Effect.gen(function*() { |
| 432 | for (const hostname of ["localhost", "127.0.0.1"]) { |
| 433 | const server = yield* BunHttpServer.make({ unix: undefined, hostname, port: 0 }) |
| 434 | assert.isTrue(server.address._tag === "InetAddressV4" || server.address._tag === "InetAddressV6") |
| 435 | yield* server.serve(Effect.succeed(HttpServerResponse.text("tcp"))) |
| 436 | const client = yield* HttpServer.makeTestClient.pipe( |
| 437 | Effect.provideService(HttpServer.HttpServer, server), |
| 438 | Effect.provide(FetchHttpClient.layer) |
| 439 | ) |
| 440 | const response = yield* client.get("/") |
| 441 | assert.strictEqual(yield* response.text, "tcp") |
| 442 | } |
| 443 | })) |
| 444 | |
| 445 | it.effect("resolves hostnames and formats Unix socket addresses", () => |
| 446 | Effect.gen(function*() { |
| 447 | const server = yield* BunHttpServer.make({ hostname: "localhost", port: 0 }) |
| 448 | assert.isTrue(server.address._tag === "InetAddressV4" || server.address._tag === "InetAddressV6") |
| 449 | |
| 450 | const directory = yield* Effect.acquireRelease( |
| 451 | Effect.promise(() => mkdtemp(join(tmpdir(), "bun-http-"))), |
| 452 | (directory) => Effect.promise(() => rm(directory, { recursive: true, force: true })) |
| 453 | ) |
| 454 | const path = join(directory, "server.sock") |
| 455 | const unixServer = yield* BunHttpServer.make({ unix: path }) |
| 456 | |
| 457 | assert.strictEqual(unixServer.address._tag, "UnixPathAddress") |
| 458 | assert.strictEqual(unixServer.address._tag === "UnixPathAddress" ? unixServer.address.path : undefined, path) |
| 459 | assert.strictEqual(NetAddress.formatUrlUnsafe(unixServer.address), `unix://${path}`) |
| 460 | })) |
| 461 | |
| 462 | it.effect("returns 413 for a body over MaxBodySize", () => |
| 463 | Effect.gen(function*() { |
| 464 | yield* HttpRouter.add( |
| 465 | "POST", |
| 466 | "/body", |
| 467 | HttpServerRequest.HttpServerRequest.use((request) => Effect.as(request.text, HttpServerResponse.empty())).pipe( |
| 468 | Effect.provideService(HttpIncomingMessage.MaxBodySize, ByteSize.bytes(4)) |
| 469 | ) |
| 470 | ).pipe(HttpRouter.serve, Layer.build) |
| 471 | const response = yield* HttpClient.post("/body", { body: HttpBody.text("12345") }) |
| 472 | assert.strictEqual(response.status, 413) |
| 473 | }).pipe(Effect.provide(BunHttpServer.layerTest))) |
| 474 | |
| 475 | it.effect("answers CONNECT with 501 without running the app", () => |
| 476 | Effect.gen(function*() { |
| 477 | let calls = 0 |
| 478 | yield* HttpRouter.add( |
| 479 | "*", |
| 480 | "*", |
| 481 | Effect.sync(() => { |
| 482 | calls++ |
| 483 | return HttpServerResponse.empty() |
| 484 | }) |
| 485 | ).pipe(HttpRouter.serve, Layer.build) |
| 486 | const server = yield* HttpServer.HttpServer |
| 487 | const port = (server.address as NetAddress.InetAddress).port |
| 488 | // fetch cannot send CONNECT. |
| 489 | const statusLine = yield* Effect.callback<string, Error>((resume) => { |
| 490 | const socket = Net.createConnection({ host: "127.0.0.1", port }) |
| 491 | let received = "" |
| 492 | socket.on("connect", () => socket.write("CONNECT example.test:443 HTTP/1.1\r\nHost: example.test:443\r\n\r\n")) |
| 493 | socket.on("error", (error) => resume(Effect.fail(error))) |
| 494 | socket.on("data", (chunk) => { |
| 495 | received += chunk.toString() |
| 496 | const lineEnd = received.indexOf("\r\n") |
| 497 | if (lineEnd !== -1) resume(Effect.succeed(received.slice(0, lineEnd))) |
| 498 | }) |
| 499 | socket.on("close", () => resume(Effect.succeed(received))) |
| 500 | return Effect.sync(() => socket.destroy()) |
| 501 | }) |
| 502 | assert.strictEqual(statusLine.split(" ")[1], "501") |
| 503 | assert.strictEqual(calls, 0) |
| 504 | }).pipe(Effect.provide(BunHttpServer.layerTest))) |
| 505 | |
| 506 | it.effect("closing an older serve scope keeps the newer handler active", () => |
| 507 | Effect.gen(function*() { |
| 508 | const ownerScope = yield* Effect.scope |
| 509 | const server = yield* BunHttpServer.make({ |
| 510 | hostname: "127.0.0.1", |
| 511 | port: 0 |
| 512 | }) |
| 513 | const firstScope = yield* Scope.fork(ownerScope) |
| 514 | const secondScope = yield* Scope.fork(ownerScope) |
| 515 | |
| 516 | yield* server.serve(Effect.succeed(HttpServerResponse.text("first"))).pipe(Scope.provide(firstScope)) |
| 517 | yield* server.serve(Effect.succeed(HttpServerResponse.text("second"))).pipe(Scope.provide(secondScope)) |
| 518 | const url = NetAddress.formatUrlUnsafe(server.address) |
| 519 | |
| 520 | assert.strictEqual(yield* fetchText(url), "second") |
| 521 | yield* Scope.close(firstScope, Exit.void) |
| 522 | assert.strictEqual(yield* fetchText(url), "second") |
| 523 | })) |
| 524 | |
| 525 | it.effect("closing the newer serve scope restores the older handler", () => |
| 526 | Effect.gen(function*() { |
| 527 | const ownerScope = yield* Effect.scope |
| 528 | const server = yield* BunHttpServer.make({ |
| 529 | hostname: "127.0.0.1", |
| 530 | port: 0 |
| 531 | }) |
| 532 | const firstScope = yield* Scope.fork(ownerScope) |
| 533 | const secondScope = yield* Scope.fork(ownerScope) |
| 534 | |
| 535 | yield* server.serve(Effect.succeed(HttpServerResponse.text("first"))).pipe(Scope.provide(firstScope)) |
| 536 | yield* server.serve(Effect.succeed(HttpServerResponse.text("second"))).pipe(Scope.provide(secondScope)) |
| 537 | const url = NetAddress.formatUrlUnsafe(server.address) |
| 538 | |
| 539 | assert.strictEqual(yield* fetchText(url), "second") |
| 540 | yield* Scope.close(secondScope, Exit.void) |
| 541 | assert.strictEqual(yield* fetchText(url), "first") |
| 542 | })) |
| 543 | |
| 544 | it.effect("preserves configured routes while changing handlers", () => |
| 545 | Effect.gen(function*() { |
| 546 | const ownerScope = yield* Effect.scope |
| 547 | const server = yield* BunHttpServer.make({ |
| 548 | hostname: "127.0.0.1", |
| 549 | port: 0, |
| 550 | routes: { "/static": new Response("static") } |
| 551 | }) |
| 552 | const firstScope = yield* Scope.fork(ownerScope) |
| 553 | const secondScope = yield* Scope.fork(ownerScope) |
| 554 | const url = NetAddress.formatUrlUnsafe(server.address) |
| 555 | |
| 556 | yield* server.serve(Effect.succeed(HttpServerResponse.text("first"))).pipe(Scope.provide(firstScope)) |
| 557 | assert.strictEqual(yield* fetchText(`${url}/static`), "static") |
| 558 | assert.strictEqual(yield* fetchText(`${url}/fallback`), "first") |
| 559 | |
| 560 | yield* server.serve(Effect.succeed(HttpServerResponse.text("second"))).pipe(Scope.provide(secondScope)) |
| 561 | assert.strictEqual(yield* fetchText(`${url}/static`), "static") |
| 562 | assert.strictEqual(yield* fetchText(`${url}/fallback`), "second") |
| 563 | |
| 564 | yield* Scope.close(secondScope, Exit.void) |
| 565 | assert.strictEqual(yield* fetchText(`${url}/static`), "static") |
| 566 | assert.strictEqual(yield* fetchText(`${url}/fallback`), "first") |
| 567 | })) |
| 568 | |
| 569 | it.effect("compresses outgoing WebSocket messages when per-message deflate is negotiated", () => |
| 570 | Effect.gen(function*() { |
| 571 | const payload = "a".repeat(4_096) |
| 572 | const server = yield* makeWebSocketServer(payload) |
| 573 | const port = (server.address as NetAddress.InetAddress).port |
| 574 | const { frames, headers } = yield* readWebSocketFrames(port, true) |
| 575 | |
| 576 | assert.match(headers, /^sec-websocket-extensions:.*permessage-deflate/im) |
| 577 | assert.deepStrictEqual(frames.map((frame) => frame.opcode), [1, 2]) |
| 578 | assert.isTrue(frames.every((frame) => frame.rsv1)) |
| 579 | assert.isTrue(frames.every((frame) => frame.payloadLength < payload.length)) |
| 580 | })) |
| 581 | |
| 582 | it.effect("leaves small WebSocket messages uncompressed even when per-message deflate is negotiated", () => |
| 583 | Effect.gen(function*() { |
| 584 | const payload = "a".repeat(64) |
| 585 | const server = yield* makeWebSocketServer(payload) |
| 586 | const port = (server.address as NetAddress.InetAddress).port |
| 587 | const { frames, headers } = yield* readWebSocketFrames(port, true) |
| 588 | |
| 589 | assert.match(headers, /^sec-websocket-extensions:.*permessage-deflate/im) |
| 590 | assert.deepStrictEqual(frames.map((frame) => frame.opcode), [1, 2]) |
| 591 | assert.isFalse(frames.some((frame) => frame.rsv1)) |
| 592 | assert.isTrue(frames.every((frame) => frame.payloadLength === payload.length)) |
| 593 | })) |
| 594 | |
| 595 | it.effect("compresses small WebSocket messages when below a custom compressionThreshold", () => |
| 596 | Effect.gen(function*() { |
| 597 | const payload = "a".repeat(64) |
| 598 | const server = yield* makeWebSocketServer(payload, 32) |
| 599 | const port = (server.address as NetAddress.InetAddress).port |
| 600 | const { frames } = yield* readWebSocketFrames(port, true) |
| 601 | |
| 602 | assert.deepStrictEqual(frames.map((frame) => frame.opcode), [1, 2]) |
| 603 | assert.isTrue(frames.every((frame) => frame.rsv1)) |
| 604 | assert.isTrue(frames.every((frame) => frame.payloadLength < payload.length)) |
| 605 | })) |
| 606 | |
| 607 | it.effect("supports WebSocket clients without per-message deflate", () => |
| 608 | Effect.gen(function*() { |
| 609 | const payload = "a".repeat(4_096) |
| 610 | const server = yield* makeWebSocketServer(payload) |
| 611 | const port = (server.address as NetAddress.InetAddress).port |
| 612 | const { frames, headers } = yield* readWebSocketFrames(port, false) |
| 613 | |
| 614 | assert.notMatch(headers, /^sec-websocket-extensions:.*permessage-deflate/im) |
| 615 | assert.deepStrictEqual(frames.map((frame) => frame.opcode), [1, 2]) |
| 616 | assert.isFalse(frames.some((frame) => frame.rsv1)) |
| 617 | assert.isTrue(frames.every((frame) => frame.payloadLength === payload.length)) |
| 618 | assert.deepStrictEqual(frames.map((frame) => new TextDecoder().decode(frame.payload)), [payload, payload]) |
| 619 | })) |
| 620 | |
| 621 | for ( |
| 622 | const [name, exit, code] of [ |
| 623 | ["success", "success", 1000], |
| 624 | ["interrupt", "interrupt", 1001], |
| 625 | ["failure", "failure", 1011], |
| 626 | ["defect", "defect", 1011], |
| 627 | ["explicit close before failure", "explicit", 4400] |
| 628 | ] as const |
| 629 | ) { |
| 630 | it.effect(`closes a WebSocket with the handler's ${name} code`, () => |
| 631 | Effect.gen(function*() { |
| 632 | const opened = yield* Deferred.make<void>() |
| 633 | const logged = yield* Deferred.make<unknown>() |
| 634 | const logger = Logger.make((options) => { |
| 635 | const annotations = options.fiber.getRef(References.CurrentLogAnnotations) |
| 636 | if (annotations["http.url"] === "/") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"])) |
| 637 | }) |
| 638 | const { forceStop, server } = yield* makeForceStoppableServer |
| 639 | yield* server.serve( |
| 640 | Effect.gen(function*() { |
| 641 | const request = yield* HttpServerRequest.HttpServerRequest |
| 642 | const socket = yield* request.upgrade |
| 643 | const readerScope = yield* Scope.fork(yield* Effect.scope) |
| 644 | yield* socket.reader.pipe(Scope.provide(readerScope)) |
| 645 | yield* Deferred.await(opened) |
| 646 | if (exit === "explicit") { |
| 647 | const writer = yield* socket.writer |
| 648 | yield* writer.write(new Socket.CloseEvent(4400, "handler closed")) |
| 649 | } |
| 650 | if (exit === "interrupt") return yield* Effect.interrupt |
| 651 | if (exit === "failure" || exit === "explicit") return yield* Effect.fail(new Error("handler failed")) |
| 652 | if (exit === "defect") return yield* Effect.die(new Error("handler defect")) |
| 653 | return HttpServerResponse.empty() |
| 654 | }), |
| 655 | HttpMiddleware.logger |
| 656 | ).pipe(Effect.provide(Logger.layer([logger]))) |
| 657 | yield* Effect.addFinalizer(() => Effect.sync(forceStop)) |
| 658 | const port = (server.address as NetAddress.InetAddress).port |
| 659 | const actual = yield* readWebSocketClose(port, opened) |
| 660 | forceStop() |
| 661 | assert.strictEqual(actual, code) |
| 662 | if (exit === "success") assert.strictEqual(yield* Deferred.await(logged), 101) |
| 663 | }).pipe(Effect.timeout("5 seconds")), 10000) |
| 664 | } |
| 665 | |
| 666 | it.effect("logs status 101 for a WebSocket upgraded through a prefixed route", () => |
| 667 | Effect.gen(function*() { |
| 668 | const opened = yield* Deferred.make<void>() |
| 669 | const logged = yield* Deferred.make<unknown>() |
| 670 | const logger = Logger.make((options) => { |
| 671 | const annotations = options.fiber.getRef(References.CurrentLogAnnotations) |
| 672 | if (annotations["http.url"] === "/ws") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"])) |
| 673 | }) |
| 674 | const app = yield* HttpRouter.toHttpEffect(HttpRouter.use((router) => |
| 675 | router.prefixed("/ws").add( |
| 676 | "GET", |
| 677 | "/", |
| 678 | Effect.gen(function*() { |
| 679 | const request = yield* HttpServerRequest.HttpServerRequest |
| 680 | const socket = yield* request.upgrade |
| 681 | const readerScope = yield* Scope.fork(yield* Effect.scope) |
| 682 | yield* socket.reader.pipe(Scope.provide(readerScope)) |
| 683 | yield* Deferred.await(opened) |
| 684 | return HttpServerResponse.empty() |
| 685 | }) |
| 686 | ) |
| 687 | )) |
| 688 | const { forceStop, server } = yield* makeForceStoppableServer |
| 689 | yield* server.serve(app, HttpMiddleware.logger).pipe(Effect.provide(Logger.layer([logger]))) |
| 690 | yield* Effect.addFinalizer(() => Effect.sync(forceStop)) |
| 691 | const port = (server.address as NetAddress.InetAddress).port |
| 692 | const actual = yield* readWebSocketClose(port, opened, "/ws") |
| 693 | forceStop() |
| 694 | assert.strictEqual(actual, 1000) |
| 695 | assert.strictEqual(yield* Deferred.await(logged), 101) |
| 696 | }).pipe(Effect.timeout("5 seconds")), 10000) |
| 697 | |
| 698 | it.effect("logs status 101 when the client closes an upgraded WebSocket", () => |
| 699 | Effect.gen(function*() { |
| 700 | const logged = yield* Deferred.make<unknown>() |
| 701 | const logger = Logger.make((options) => { |
| 702 | const annotations = options.fiber.getRef(References.CurrentLogAnnotations) |
| 703 | if (annotations["http.url"] === "/") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"])) |
| 704 | }) |
| 705 | const app = yield* HttpRouter.toHttpEffect(HttpRouter.add( |
| 706 | "GET", |
| 707 | "/", |
| 708 | Effect.gen(function*() { |
| 709 | const request = yield* HttpServerRequest.HttpServerRequest |
| 710 | const socket = yield* request.upgrade |
| 711 | const reader = yield* socket.reader |
| 712 | yield* reader.pull.pipe(Effect.forever, Effect.ignore) |
| 713 | return HttpServerResponse.empty() |
| 714 | }) |
| 715 | )) |
| 716 | const { forceStop, server } = yield* makeForceStoppableServer |
| 717 | yield* server.serve(app, HttpMiddleware.logger).pipe(Effect.provide(Logger.layer([logger]))) |
| 718 | yield* Effect.addFinalizer(() => Effect.sync(forceStop)) |
| 719 | const port = (server.address as NetAddress.InetAddress).port |
| 720 | const ws = new WebSocket(`ws://127.0.0.1:${port}/`) |
| 721 | ws.addEventListener("open", () => ws.close(1000)) |
| 722 | assert.strictEqual(yield* Deferred.await(logged), 101) |
| 723 | }).pipe(Effect.timeout("5 seconds")), 10000) |
| 724 | |
| 725 | it.effect("fails a concurrent reader waiting behind a closed reader", () => |
| 726 | Effect.gen(function*() { |
| 727 | const secondReaderFailed = yield* Deferred.make<boolean>() |
| 728 | const server = yield* BunHttpServer.make({ |
| 729 | hostname: "127.0.0.1", |
| 730 | port: 0 |
| 731 | }) |
| 732 | yield* server.serve(Effect.gen(function*() { |
| 733 | const request = yield* HttpServerRequest.HttpServerRequest |
| 734 | const socket = yield* request.upgrade |
| 735 | const ownerScope = yield* Effect.scope |
| 736 | const firstScope = yield* Scope.fork(ownerScope) |
| 737 | const secondScope = yield* Scope.fork(ownerScope) |
| 738 | |
| 739 | const { pull } = yield* socket.reader.pipe(Scope.provide(firstScope)) |
| 740 | const writer = yield* socket.writer |
| 741 | const secondReader = yield* socket.reader.pipe( |
| 742 | Scope.provide(secondScope), |
| 743 | Effect.exit, |
| 744 | Effect.forkChild({ startImmediately: true }) |
| 745 | ) |
| 746 | yield* writer.write("first") |
| 747 | yield* writer.write("second") |
| 748 | yield* Effect.exit(pull) |
| 749 | yield* Scope.close(firstScope, Exit.void) |
| 750 | const secondExit = yield* Fiber.join(secondReader) |
| 751 | yield* Scope.close(secondScope, Exit.void) |
| 752 | yield* Deferred.succeed(secondReaderFailed, Exit.isFailure(secondExit)) |
| 753 | return HttpServerResponse.empty() |
| 754 | })) |
| 755 | |
| 756 | const port = (server.address as NetAddress.InetAddress).port |
| 757 | yield* readWebSocketFrames(port, false) |
| 758 | const failed = yield* Deferred.await(secondReaderFailed) |
| 759 | assert.isTrue(failed) |
| 760 | })) |
| 761 | |
| 762 | it.effect("fails upgrades to protocols other than WebSocket", () => |
| 763 | Effect.gen(function*() { |
| 764 | const server = yield* BunHttpServer.make({ hostname: "127.0.0.1", port: 0 }) |
| 765 | yield* server.serve(Effect.gen(function*() { |
| 766 | const request = yield* HttpServerRequest.HttpServerRequest |
| 767 | const error = yield* Effect.flip(request.upgrade) |
| 768 | return HttpServerResponse.text(error.reason.message, { status: 501 }) |
| 769 | })) |
| 770 | const port = (server.address as NetAddress.InetAddress).port |
| 771 | const response = yield* Effect.promise(() => |
| 772 | fetch(`http://127.0.0.1:${port}/attach`, { |
| 773 | method: "POST", |
| 774 | headers: { connection: "Upgrade", upgrade: "tcp" } |
| 775 | }) |
| 776 | ) |
| 777 | assert.strictEqual(response.status, 501) |
| 778 | assert.include(yield* Effect.promise(() => response.text()), "Bun.serve only supports WebSocket upgrades") |
| 779 | })) |
| 780 | }) |