@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

main
ts 780 lines 33.6 KB
Raw
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 })