@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 1,231 lines 50 KB
Raw
1 import * as DenoHttpServer from "@effect/platform-deno/DenoHttpServer"
2 import { assert, describe, it } from "@effect/vitest"
3 import * as ByteSize from "effect/ByteSize"
4 import * as Cause from "effect/Cause"
5 import * as Deferred from "effect/Deferred"
6 import * as Duration from "effect/Duration"
7 import * as Effect from "effect/Effect"
8 import * as Exit from "effect/Exit"
9 import * as Fiber from "effect/Fiber"
10 import * as HttpApiError from "effect/http-api/HttpApiError"
11 import * as Cookies from "effect/http/Cookies"
12 import * as Etag from "effect/http/Etag"
13 import * as FetchHttpClient from "effect/http/FetchHttpClient"
14 import * as HttpBody from "effect/http/HttpBody"
15 import * as HttpClient from "effect/http/HttpClient"
16 import * as HttpClientRequest from "effect/http/HttpClientRequest"
17 import * as HttpClientResponse from "effect/http/HttpClientResponse"
18 import * as HttpIncomingMessage from "effect/http/HttpIncomingMessage"
19 import * as HttpPlatform from "effect/http/HttpPlatform"
20 import * as HttpRouter from "effect/http/HttpRouter"
21 import * as HttpServer from "effect/http/HttpServer"
22 import * as HttpServerRequest from "effect/http/HttpServerRequest"
23 import * as HttpServerRespondable from "effect/http/HttpServerRespondable"
24 import * as HttpServerResponse from "effect/http/HttpServerResponse"
25 import * as Multipart from "effect/http/Multipart"
26 import * as UrlParams from "effect/http/UrlParams"
27 import * as Latch from "effect/Latch"
28 import * as Layer from "effect/Layer"
29 import * as Logger from "effect/Logger"
30 import * as ManagedRuntime from "effect/ManagedRuntime"
31 import type * as NetAddress from "effect/net/NetAddress"
32 import * as Option from "effect/Option"
33 import * as Queue from "effect/Queue"
34 import * as References from "effect/References"
35 import * as Schema from "effect/Schema"
36 import * as Scope from "effect/Scope"
37 import type * as Socket from "effect/socket/Socket"
38 import * as Stream from "effect/Stream"
39 import * as Tracer from "effect/Tracer"
40 import * as Http from "node:http"
41 import * as Http2 from "node:http2"
42 import {
43 describeHttpServerProtocol,
44 http2Get,
45 layerTestClient
46 } from "../../node-shared/test/HttpServerHttp2.test-utils.ts"
47
48 const Todo = Schema.Struct({
49 id: Schema.Number,
50 title: Schema.String
51 })
52 const IdParams = Schema.Struct({
53 id: Schema.FiniteFromString
54 })
55 const todoResponse = HttpServerResponse.schemaJson(Todo)
56 const fixture = `${import.meta.dirname}/fixtures/text.txt`
57
58 const ca = Deno.readTextFileSync(new URL("./fixtures/tls/ca.pem", import.meta.url))
59 const cert = Deno.readTextFileSync(new URL("./fixtures/tls/cert.pem", import.meta.url))
60 const key = Deno.readTextFileSync(new URL("./fixtures/tls/key.pem", import.meta.url))
61
62 // Deno's fetch client speaks HTTP/2 with prior knowledge over cleartext
63 const layerHttp2Client = (options?: Omit<Deno.CreateHttpClientOptions, "http1" | "http2">) =>
64 FetchHttpClient.layer.pipe(Layer.provide(
65 Layer.effect(FetchHttpClient.RequestInit)(
66 Effect.acquireRelease(
67 Effect.sync(() => Deno.createHttpClient({ ...options, http1: false, http2: true })),
68 (client) => Effect.sync(() => client.close())
69 ).pipe(Effect.map((client) => ({ client }) as RequestInit))
70 )
71 ))
72
73 describe("DenoHttpServer", () => {
74 describe("serve scope ownership", { concurrent: false }, () => {
75 it.live("closes the request scope when a streaming body is cancelled synchronously during construction", () =>
76 Effect.gen(function*() {
77 let finalized = false
78 let pulled = false
79 let cancellation: Promise<void> | undefined
80 const OriginalResponse = globalThis.Response
81 yield* Effect.acquireRelease(
82 Effect.sync(() => {
83 // Intercept construction: awaiting a response over HTTP lets the first pull run already.
84 globalThis.Response = class extends OriginalResponse {
85 constructor(body?: BodyInit | null, init?: ResponseInit) {
86 if (body instanceof ReadableStream) {
87 cancellation = body.cancel()
88 super(null, init)
89 } else {
90 super(body, init)
91 }
92 }
93 }
94 }),
95 () =>
96 Effect.sync(() => {
97 globalThis.Response = OriginalResponse
98 })
99 )
100 yield* HttpServer.serveEffect(Effect.gen(function*() {
101 yield* Effect.addFinalizer(() =>
102 Effect.sync(() => {
103 finalized = true
104 })
105 )
106 return HttpServerResponse.stream(Stream.fromEffect(Effect.sync(() => {
107 pulled = true
108 return new Uint8Array([1])
109 })))
110 }))
111 const response = yield* HttpClient.get("/")
112 assert.strictEqual(response.status, 200)
113 yield* response.text
114 assert.isDefined(cancellation)
115 yield* Effect.promise(() => cancellation!)
116 assert.strictEqual(pulled, false)
117 assert.strictEqual(finalized, true)
118 }).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
119
120 it.live("interrupts a streaming body suspended during startup when the serve scope closes", () =>
121 Effect.gen(function*() {
122 let finalized = false
123 const started = yield* Deferred.make<void>()
124 const release = yield* Deferred.make<void>()
125 const server = yield* DenoHttpServer.make({ hostname: "127.0.0.1", port: 0, disablePreemptiveShutdown: true })
126 // Let the body finish on teardown so the server can stop if it was never interrupted.
127 yield* Effect.addFinalizer(() => Deferred.succeed(release, undefined))
128 const serveScope = yield* Scope.fork(yield* Effect.scope)
129 yield* server.serve(Effect.gen(function*() {
130 yield* Effect.addFinalizer(() =>
131 Effect.sync(() => {
132 finalized = true
133 })
134 )
135 // The body suspends during startup, before it can serve a pull.
136 return HttpServerResponse.stream(
137 Stream.transformPull(
138 Stream.empty,
139 (pull) =>
140 Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)), Effect.as(pull))
141 )
142 )
143 })).pipe(Scope.provide(serveScope))
144 // Not awaited: headers may not be sent while the body is suspended.
145 fetch(`http://127.0.0.1:${(server.address as NetAddress.InetAddress).port}/`, {
146 headers: { connection: "close" }
147 }).catch(() => undefined)
148 yield* Deferred.await(started)
149 assert.strictEqual(finalized, false)
150 yield* Scope.close(serveScope, Exit.void)
151 assert.strictEqual(finalized, true)
152 }).pipe(Effect.timeout("2 seconds")))
153 })
154
155 // After the sequential block above, which replaces `globalThis.Response` and cancels streaming bodies
156 describeHttpServerProtocol("HTTP/1.1", DenoHttpServer.layerTest)
157 describeHttpServerProtocol(
158 "h2c",
159 layerTestClient("http").pipe(
160 Layer.provide(layerHttp2Client()),
161 Layer.provideMerge(DenoHttpServer.layerServer({ hostname: "127.0.0.1", port: 0, onListen: () => {} }))
162 )
163 )
164 describeHttpServerProtocol(
165 "HTTP/2 over TLS",
166 layerTestClient("https").pipe(
167 Layer.provide(layerHttp2Client({ caCerts: [ca] })),
168 Layer.provideMerge(DenoHttpServer.layerServer({ hostname: "127.0.0.1", port: 0, cert, key, onListen: () => {} }))
169 )
170 )
171
172 describe("body omission", () => {
173 for (const status of [204, 205, 304]) {
174 for (const bodyKind of ["text", "stream"]) {
175 it.live(`omits ${bodyKind} bodies for status ${status}`, () =>
176 Effect.gen(function*() {
177 let finalized = false
178 let streamStarted = false
179 yield* HttpServer.serveEffect(Effect.gen(function*() {
180 yield* Effect.addFinalizer(() =>
181 Effect.sync(() => {
182 finalized = true
183 })
184 )
185 const options = { status, contentType: "text/plain", contentLength: 4 }
186 return bodyKind === "text"
187 ? HttpServerResponse.text("body", options)
188 : HttpServerResponse.stream(
189 Stream.fromEffect(Effect.sync(() => {
190 streamStarted = true
191 return new TextEncoder().encode("body")
192 })),
193 options
194 )
195 }))
196 const response = yield* HttpClient.get("/")
197 assert.strictEqual(response.status, status)
198 assert.strictEqual(yield* response.text, "")
199 assert.strictEqual(streamStarted, false)
200 assert.strictEqual(finalized, true)
201 if (status === 304) {
202 assert.strictEqual(response.headers["content-type"], "text/plain")
203 }
204 }).pipe(
205 Effect.timeout("2 seconds"),
206 Effect.provide(DenoHttpServer.layerTest)
207 ), 5000)
208 }
209 }
210
211 // Deno strips the header itself over HTTP/1.1, so only HTTP/2 shows it.
212 for (const status of [204, 205]) {
213 for (const raw of [false, true]) {
214 it.live(
215 `drops content-length for ${raw ? "a raw Response with " : ""}status ${status} over HTTP/2`,
216 () =>
217 Effect.gen(function*() {
218 const client = Deno.createHttpClient({ http1: false, http2: true })
219 yield* Effect.addFinalizer(() => Effect.sync(() => client.close()))
220 yield* HttpServer.serveEffect(Effect.sync(() =>
221 raw
222 ? HttpServerResponse.raw(new Response(null, { status, headers: { "content-length": "4" } }))
223 : HttpServerResponse.text("body", { status })
224 ))
225 const response = yield* HttpClient.get("/").pipe(
226 Effect.provideService(FetchHttpClient.RequestInit, { client } as RequestInit)
227 )
228 assert.strictEqual(response.status, status)
229 assert.strictEqual(response.headers["content-length"], undefined)
230 assert.strictEqual(yield* response.text, "")
231 }).pipe(
232 Effect.timeout("2 seconds"),
233 Effect.provide(DenoHttpServer.layerTest)
234 ),
235 5000
236 )
237 }
238 }
239
240 for (const [method, status] of [["HEAD", 200], ["GET", 204], ["GET", 205], ["GET", 304]] as const) {
241 it.live(`cancels raw streams for ${method} status ${status}`, () =>
242 Effect.gen(function*() {
243 let cancelled = false
244 const body = new ReadableStream<Uint8Array>({
245 pull(controller) {
246 controller.enqueue(new TextEncoder().encode("body"))
247 controller.close()
248 },
249 cancel() {
250 cancelled = true
251 }
252 }, { highWaterMark: 0 })
253 yield* Effect.addFinalizer(() => Effect.ignoreCause(Effect.promise(() => body.cancel())))
254 yield* HttpServer.serveEffect(Effect.succeed(HttpServerResponse.raw(body, {
255 status,
256 contentType: "text/plain",
257 contentLength: 4
258 })))
259 const response = yield* (method === "HEAD" ? HttpClient.head("/") : HttpClient.get("/"))
260 assert.strictEqual(response.status, status)
261 assert.strictEqual(yield* response.text, "")
262 assert.strictEqual(cancelled, true)
263 if (method === "HEAD") {
264 assert.strictEqual(response.headers["content-length"], "4")
265 }
266 if (method === "HEAD" || status === 304) {
267 assert.strictEqual(response.headers["content-type"], "text/plain")
268 }
269 }).pipe(
270 Effect.timeout("2 seconds"),
271 Effect.provide(DenoHttpServer.layerTest)
272 ), 5000)
273 }
274 })
275
276 describe("when the Response can't be built", () => {
277 it.live("answers 500 and preserves the header defect when raw body cancellation rejects", () =>
278 Effect.gen(function*() {
279 let cancelled = false
280 const body = new ReadableStream<Uint8Array>({
281 cancel() {
282 cancelled = true
283 return Promise.reject(new Error("cancellation failed"))
284 }
285 })
286 const observed = yield* Deferred.make<Exit.Exit<unknown, unknown>>()
287 yield* HttpServer.serveEffect(
288 Effect.succeed(HttpServerResponse.raw(body, { headers: { "x-invalid": "a\nb" } })),
289 (app) => Effect.onExit(app, (exit) => Deferred.succeed(observed, exit))
290 )
291 const response = yield* HttpClient.get("/")
292 assert.strictEqual(response.status, 500)
293 assert.strictEqual(yield* response.text, "")
294 assert.isTrue(cancelled)
295 const exit = yield* Deferred.await(observed)
296 assert(Exit.isFailure(exit))
297 assert.strictEqual(exit.cause.reasons.length, 1)
298 const reason = exit.cause.reasons[0]
299 assert(Cause.isDieReason(reason))
300 assert(reason.defect instanceof TypeError)
301 }).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
302
303 it.live("answers 500 and reports the status defect before stream scope cleanup completes", () =>
304 Effect.gen(function*() {
305 const finalized = yield* Latch.make()
306 const release = yield* Latch.make()
307 const observed = yield* Deferred.make<Exit.Exit<unknown, unknown>>()
308 yield* HttpServer.serveEffect(
309 Effect.gen(function*() {
310 yield* Effect.addFinalizer(() => finalized.open.pipe(Effect.andThen(release.await)))
311 return HttpServerResponse.stream(Stream.never, { status: 103 })
312 }),
313 (app) => Effect.onExit(app, (exit) => Deferred.succeed(observed, exit))
314 )
315 yield* Effect.addFinalizer(() => release.open)
316 const response = yield* HttpClient.get("/")
317 assert.strictEqual(response.status, 500)
318 assert.strictEqual(yield* response.text, "")
319 yield* finalized.await
320 const exit = yield* Deferred.await(observed)
321 assert(Exit.isFailure(exit))
322 assert.strictEqual(exit.cause.reasons.length, 1)
323 const reason = exit.cause.reasons[0]
324 assert(Cause.isDieReason(reason))
325 assert(reason.defect instanceof RangeError)
326 }).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
327 })
328
329 it.effect("schema", () =>
330 Effect.gen(function*() {
331 yield* HttpRouter.add(
332 "GET",
333 "/todos/:id",
334 Effect.flatMap(HttpRouter.schemaParams(IdParams), ({ id }) => todoResponse({ id, title: "test" }))
335 ).pipe(HttpRouter.serve, Layer.build)
336 const todo = yield* HttpClient.get("/todos/1").pipe(
337 Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
338 )
339 assert.deepStrictEqual(todo, { id: 1, title: "test" })
340 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
341
342 it.effect("exports a weak ETag generator", () =>
343 Effect.gen(function*() {
344 const generator = yield* Etag.Generator
345 const etag = yield* generator.fromFileWeb(new File(["test"], "test.txt", { lastModified: 0 }))
346 assert.strictEqual(etag._tag, "Weak")
347 }).pipe(Effect.provide(DenoHttpServer.layerHttpServices)))
348
349 it.effect("formData", () =>
350 Effect.gen(function*() {
351 yield* HttpRouter.add(
352 "POST",
353 "/upload",
354 Effect.gen(function*() {
355 const request = yield* HttpServerRequest.HttpServerRequest
356 const formData = yield* request.multipart
357 const part = formData.file
358 assert(typeof part !== "string")
359 const file = part[0]
360 assert(typeof file !== "string")
361 assert(file.path.endsWith("/test.txt"))
362 assert.strictEqual(file.contentType, "text/plain")
363 assert.strictEqual(yield* Effect.promise(() => Deno.readTextFile(file.path)), "test")
364 return yield* HttpServerResponse.json({ ok: "file" in formData })
365 })
366 ).pipe(HttpRouter.serve, Layer.build)
367 const formData = new FormData()
368 formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
369 const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
370 assert.deepStrictEqual(yield* response.json, { ok: true })
371 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
372
373 it.effect("multipartStream", () =>
374 Effect.gen(function*() {
375 yield* HttpRouter.add(
376 "POST",
377 "/upload",
378 Effect.gen(function*() {
379 const request = yield* HttpServerRequest.HttpServerRequest
380 const parts = yield* Stream.runCollect(request.multipartStream)
381 assert.strictEqual(parts.length, 2)
382 const field = parts[0]
383 const file = parts[1]
384 assert(Multipart.isField(field))
385 assert.deepStrictEqual({ key: field.key, value: field.value }, { key: "name", value: "value" })
386 assert(Multipart.isFile(file))
387 assert.deepStrictEqual(
388 { key: file.key, name: file.name, contentType: file.contentType },
389 { key: "file", name: "test.txt", contentType: "text/plain" }
390 )
391 assert.strictEqual(new TextDecoder().decode(yield* file.contentEffect), "test")
392 return HttpServerResponse.empty()
393 })
394 ).pipe(HttpRouter.serve, Layer.build)
395 const formData = new FormData()
396 formData.append("name", "value")
397 formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
398 const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
399 assert.strictEqual(response.status, 204)
400 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
401
402 it.effect("schemaBodyForm", () =>
403 Effect.gen(function*() {
404 yield* HttpRouter.add(
405 "POST",
406 "/upload",
407 Effect.gen(function*() {
408 const files = yield* HttpServerRequest.schemaBodyForm(Schema.Struct({
409 file: Multipart.FilesSchema,
410 test: Schema.String
411 }))
412 assert("file" in files)
413 assert.strictEqual(files.test, "test")
414 return HttpServerResponse.empty()
415 })
416 ).pipe(HttpRouter.serve, Layer.build)
417 const formData = new FormData()
418 formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
419 formData.append("test", "test")
420 const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
421 assert.strictEqual(response.status, 204)
422 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
423
424 it.effect("formData withMaxFileSize", () =>
425 Effect.gen(function*() {
426 yield* HttpRouter.add(
427 "POST",
428 "/upload",
429 Effect.gen(function*() {
430 const request = yield* HttpServerRequest.HttpServerRequest
431 yield* request.multipart
432 return HttpServerResponse.empty()
433 }).pipe(Effect.catchTag("MultipartError", (error) =>
434 error.reason._tag === "FileTooLarge"
435 ? Effect.succeed(HttpServerResponse.empty({ status: 413 }))
436 : Effect.fail(error)))
437 ).pipe(
438 HttpRouter.serve,
439 Layer.build,
440 Effect.provideService(Multipart.MaxFileSize, ByteSize.bytes(100))
441 )
442 const formData = new FormData()
443 formData.append("file", new Blob([new Uint8Array(1000)], { type: "text/plain" }), "test.txt")
444 const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
445 assert.strictEqual(response.status, 413)
446 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
447
448 it.effect("formData withMaxFieldSize", () =>
449 Effect.gen(function*() {
450 yield* HttpRouter.add(
451 "POST",
452 "/upload",
453 Effect.gen(function*() {
454 const request = yield* HttpServerRequest.HttpServerRequest
455 yield* request.multipart
456 return HttpServerResponse.empty()
457 }).pipe(Effect.catchTag("MultipartError", (error) =>
458 error.reason._tag === "FieldTooLarge"
459 ? Effect.succeed(HttpServerResponse.empty({ status: 413 }))
460 : Effect.fail(error)))
461 ).pipe(
462 HttpRouter.serve,
463 Layer.build,
464 Effect.provideService(Multipart.MaxFieldSize, ByteSize.bytes(100))
465 )
466 const formData = new FormData()
467 formData.append("file", "x".repeat(1000))
468 const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
469 assert.strictEqual(response.status, 413)
470 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
471
472 it.effect("mountApp", () =>
473 Effect.gen(function*() {
474 const child = Effect.map(HttpServerRequest.HttpServerRequest, (_) => HttpServerResponse.text(_.url))
475 yield* HttpRouter.use((router) => router.prefixed("/child").add("*", "*", child)).pipe(
476 HttpRouter.serve,
477 Layer.build
478 )
479 assert.strictEqual(yield* HttpClient.get("/child/1").pipe(Effect.flatMap((_) => _.text)), "/1")
480 assert.strictEqual(yield* HttpClient.get("/child").pipe(Effect.flatMap((_) => _.text)), "/")
481 assert.strictEqual(yield* HttpClient.get("/child?foo=bar").pipe(Effect.flatMap((_) => _.text)), "/?foo=bar")
482 assert.strictEqual(yield* HttpClient.get("/child/").pipe(Effect.flatMap((_) => _.text)), "/")
483 assert.strictEqual(
484 yield* HttpClient.get("/child1/", { urlParams: { foo: "bar" } }).pipe(Effect.map((_) => _.status)),
485 404
486 )
487 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
488
489 it.effect("returns 413 for a body over MaxBodySize", () =>
490 Effect.gen(function*() {
491 yield* HttpRouter.add(
492 "POST",
493 "/body",
494 HttpServerRequest.HttpServerRequest.use((request) => Effect.as(request.text, HttpServerResponse.empty())).pipe(
495 Effect.provideService(HttpIncomingMessage.MaxBodySize, ByteSize.bytes(4))
496 )
497 ).pipe(HttpRouter.serve, Layer.build)
498 const response = yield* HttpClient.post("/body", { body: HttpBody.text("12345") })
499 assert.strictEqual(response.status, 413)
500 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
501
502 it.effect("answers CONNECT with 501 without running the app", () =>
503 Effect.gen(function*() {
504 let calls = 0
505 yield* HttpRouter.add(
506 "*",
507 "*",
508 Effect.sync(() => {
509 calls++
510 return HttpServerResponse.empty()
511 })
512 ).pipe(HttpRouter.serve, Layer.build)
513 const server = yield* HttpServer.HttpServer
514 const port = (server.address as NetAddress.InetAddress).port
515 // fetch cannot send CONNECT.
516 const statusLine = yield* Effect.acquireUseRelease(
517 Effect.promise(() => Deno.connect({ hostname: "127.0.0.1", port })),
518 (conn) =>
519 Effect.promise(async () => {
520 await conn.write(
521 new TextEncoder().encode("CONNECT example.test:443 HTTP/1.1\r\nHost: example.test:443\r\n\r\n")
522 )
523 const decoder = new TextDecoder()
524 const buffer = new Uint8Array(1024)
525 let received = ""
526 while (!received.includes("\r\n")) {
527 const read = await conn.read(buffer)
528 if (read === null) break
529 received += decoder.decode(buffer.subarray(0, read), { stream: true })
530 }
531 return received.split("\r\n")[0]
532 }),
533 (conn) => Effect.sync(() => conn.close())
534 )
535 assert.strictEqual(statusLine.split(" ")[1], "501")
536 assert.strictEqual(calls, 0)
537 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
538
539 it.effect("file", () =>
540 Effect.gen(function*() {
541 yield* (yield* HttpServerResponse.file(fixture).pipe(
542 Effect.updateService(HttpPlatform.HttpPlatform, (_) => ({
543 ..._,
544 fileResponse: (path, options) =>
545 Effect.map(_.fileResponse(path, options), (response) => {
546 ;(response as any).headers.etag = "\"etag\""
547 return response
548 })
549 }))
550 )).pipe(Effect.succeed, HttpServer.serveEffect())
551 const response = yield* HttpClient.get("/", {
552 headers: { "accept-encoding": "identity" }
553 })
554 assert.strictEqual(response.status, 200)
555 assert.strictEqual(response.headers["content-type"], "text/plain; charset=UTF-8")
556 assert.strictEqual(response.headers.etag, "\"etag\"")
557 assert.strictEqual((yield* response.text).trim(), "lorem ipsum dolar sit amet")
558 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
559
560 it.effect("fileWeb", () =>
561 Effect.gen(function*() {
562 const now = new Date()
563 const file = new File([new TextEncoder().encode("test")], "test.txt", {
564 type: "text/plain",
565 lastModified: now.getTime()
566 })
567 yield* HttpServerResponse.fileWeb(file).pipe(
568 Effect.updateService(HttpPlatform.HttpPlatform, (_) => ({
569 ..._,
570 fileWebResponse: (file, options) =>
571 Effect.map(_.fileWebResponse(file, options), (response) => ({
572 ...response,
573 headers: { ...response.headers, etag: "W/\"etag\"" }
574 }))
575 })),
576 HttpServer.serveEffect()
577 )
578 const response = yield* HttpClient.get("/")
579 assert.strictEqual(response.status, 200)
580 assert.strictEqual(response.headers["content-type"], "text/plain")
581 assert.strictEqual(response.headers["last-modified"], now.toUTCString())
582 assert.strictEqual(response.headers.etag, "W/\"etag\"")
583 assert.strictEqual(yield* response.text, "test")
584 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
585
586 it.effect("schemaBodyUrlParams", () =>
587 Effect.gen(function*() {
588 yield* HttpRouter.add(
589 "POST",
590 "/todos",
591 Effect.flatMap(
592 HttpServerRequest.schemaBodyUrlParams(Schema.Struct({
593 id: Schema.FiniteFromString,
594 title: Schema.String
595 })),
596 ({ id, title }) => todoResponse({ id, title })
597 )
598 ).pipe(HttpRouter.serve, Layer.build)
599 const todo = yield* HttpClientRequest.post("/todos").pipe(
600 HttpClientRequest.bodyUrlParams({ id: "1", title: "test" }),
601 HttpClient.execute,
602 Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
603 )
604 assert.deepStrictEqual(todo, { id: 1, title: "test" })
605 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
606
607 it.effect("schemaBodyUrlParams error", () =>
608 Effect.gen(function*() {
609 yield* HttpRouter.add(
610 "GET",
611 "/todos",
612 Effect.flatMap(
613 HttpServerRequest.schemaBodyUrlParams(Schema.Struct({
614 id: Schema.FiniteFromString,
615 title: Schema.String
616 })),
617 ({ id, title }) => todoResponse({ id, title })
618 ).pipe(Effect.catchTag("SchemaError", (error) =>
619 Effect.succeed(HttpServerResponse.jsonUnsafe({ error }, { status: 400 }))))
620 ).pipe(HttpRouter.serve, Layer.build)
621 assert.strictEqual((yield* HttpClient.get("/todos")).status, 400)
622 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
623
624 it.effect("schemaBodyFormJson", () =>
625 Effect.gen(function*() {
626 yield* HttpRouter.add(
627 "POST",
628 "/upload",
629 Effect.gen(function*() {
630 const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
631 assert.strictEqual(result.test, "content")
632 return HttpServerResponse.empty()
633 })
634 ).pipe(HttpRouter.serve, Layer.build)
635 const formData = new FormData()
636 formData.append("json", JSON.stringify({ test: "content" }))
637 assert.strictEqual((yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })).status, 204)
638 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
639
640 it.effect("schemaBodyFormJson file", () =>
641 Effect.gen(function*() {
642 yield* HttpRouter.add(
643 "POST",
644 "/upload",
645 Effect.gen(function*() {
646 const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
647 assert.strictEqual(result.test, "content")
648 return HttpServerResponse.empty()
649 })
650 ).pipe(HttpRouter.serve, Layer.build)
651 const formData = new FormData()
652 formData.append(
653 "json",
654 new Blob([JSON.stringify({ test: "content" })], { type: "application/json" }),
655 "test.json"
656 )
657 assert.strictEqual((yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })).status, 204)
658 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
659
660 it.effect("schemaBodyFormJson url encoded", () =>
661 Effect.gen(function*() {
662 yield* HttpRouter.add(
663 "POST",
664 "/upload",
665 Effect.gen(function*() {
666 const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
667 assert.strictEqual(result.test, "content")
668 return HttpServerResponse.empty()
669 })
670 ).pipe(HttpRouter.serve, Layer.build)
671 const response = yield* HttpClient.post("/upload", {
672 body: HttpBody.urlParams(UrlParams.fromInput({ json: JSON.stringify({ test: "content" }) }))
673 })
674 assert.strictEqual(response.status, 204)
675 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
676
677 it.effect("tracing", () =>
678 Effect.gen(function*() {
679 yield* HttpRouter.add(
680 "GET",
681 "/",
682 Effect.flatMap(Effect.currentSpan, (_) => HttpServerResponse.json({ spanId: _.spanId, parent: _.parent }))
683 ).pipe(HttpRouter.serve, Layer.build)
684 const requestSpan = yield* Effect.makeSpan("client request")
685 const body = yield* HttpClient.get("/").pipe(
686 Effect.flatMap((response) => response.json),
687 Effect.provideService(
688 Tracer.Tracer,
689 Tracer.make({
690 span(options) {
691 assert.strictEqual(options.name, "GET")
692 assert.strictEqual(options.kind, "client")
693 assert(options.parent._tag === "Some")
694 if (options.parent.value._tag !== "Span") throw new Error("Expected span parent")
695 assert.strictEqual(options.parent.value.name, "request parent")
696 return requestSpan
697 }
698 })
699 ),
700 Effect.withSpan("request parent"),
701 Effect.repeat({ times: 2 })
702 )
703 assert.strictEqual((body as any).parent._tag, "Some")
704 assert.strictEqual((body as any).parent.value.spanId, requestSpan.spanId)
705 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
706
707 it.effect("html", () =>
708 Effect.gen(function*() {
709 yield* HttpRouter.addAll([
710 HttpRouter.route("GET", "/home", HttpServerResponse.html("<html />")),
711 HttpRouter.route(
712 "GET",
713 "/about",
714 HttpServerResponse.html`<html>${Effect.succeed("<body />")}</html>`
715 ),
716 HttpRouter.route(
717 "GET",
718 "/stream",
719 HttpServerResponse.htmlStream`<html>${Stream.make("<body />", 123, "hello")}</html>`
720 )
721 ]).pipe(HttpRouter.serve, Layer.build)
722 assert.strictEqual(yield* HttpClient.get("/home").pipe(Effect.flatMap((_) => _.text)), "<html />")
723 assert.strictEqual(yield* HttpClient.get("/about").pipe(Effect.flatMap((_) => _.text)), "<html><body /></html>")
724 assert.strictEqual(
725 yield* HttpClient.get("/stream").pipe(Effect.flatMap((_) => _.text)),
726 "<html><body />123hello</html>"
727 )
728 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
729
730 it.effect("setCookie", () =>
731 Effect.gen(function*() {
732 yield* HttpRouter.add(
733 "GET",
734 "/home",
735 HttpServerResponse.empty().pipe(
736 HttpServerResponse.setCookieUnsafe("test", "value"),
737 HttpServerResponse.setCookieUnsafe("test2", "value2", {
738 httpOnly: true,
739 secure: true,
740 sameSite: "lax",
741 partitioned: true,
742 path: "/",
743 domain: "example.com",
744 expires: new Date(2022, 1, 1),
745 maxAge: "5 minutes"
746 })
747 )
748 ).pipe(HttpRouter.serve, Layer.build)
749 const response = yield* HttpClient.get("/home")
750 assert.deepStrictEqual(
751 response.cookies.toJSON(),
752 Cookies.fromReadonlyRecord({
753 test: Cookies.makeCookieUnsafe("test", "value"),
754 test2: Cookies.makeCookieUnsafe("test2", "value2", {
755 httpOnly: true,
756 secure: true,
757 sameSite: "lax",
758 partitioned: true,
759 path: "/",
760 domain: "example.com",
761 expires: new Date(2022, 1, 1),
762 maxAge: Duration.minutes(5)
763 })
764 }).toJSON()
765 )
766 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
767
768 it.live("uninterruptible routes", () =>
769 Effect.gen(function*() {
770 yield* HttpRouter.add(
771 "GET",
772 "/home",
773 Effect.gen(function*() {
774 const fiber = Fiber.getCurrent()!
775 setTimeout(() => fiber.interruptUnsafe(fiber.id), 10)
776 yield* Effect.sleep(50)
777 return HttpServerResponse.empty()
778 }),
779 { uninterruptible: true }
780 ).pipe(HttpRouter.serve, Layer.build)
781 assert.strictEqual((yield* HttpClient.get("/home")).status, 204)
782 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
783
784 it.live("disposes after a client aborts a handler awaiting an upstream request", () =>
785 Effect.gen(function*() {
786 const upstreamStarted = Latch.makeUnsafe()
787 const upstream = yield* Effect.acquireRelease(
788 Effect.sync(() => {
789 const controller = new AbortController()
790 const server = Deno.serve(
791 { hostname: "127.0.0.1", port: 0, onListen: () => {}, signal: controller.signal },
792 (request) => {
793 upstreamStarted.openUnsafe()
794 return new Promise<Response>((resolve) => {
795 request.signal.addEventListener("abort", () => resolve(new Response()), { once: true })
796 controller.signal.addEventListener("abort", () => resolve(new Response()), { once: true })
797 })
798 }
799 )
800 return { controller, server }
801 }),
802 ({ controller, server }) =>
803 Effect.sync(() => controller.abort()).pipe(Effect.andThen(Effect.promise(() => server.finished)))
804 )
805 const upstreamPort = (upstream.server.addr as Deno.NetAddr).port
806 const router = HttpRouter.use((router) =>
807 router.add(
808 "GET",
809 "/",
810 Effect.gen(function*() {
811 yield* HttpClient.head(`http://127.0.0.1:${upstreamPort}`)
812 return HttpServerResponse.empty()
813 })
814 )
815 )
816 const serverLayer = DenoHttpServer.layer({
817 hostname: "127.0.0.1",
818 port: 0,
819 onListen: () => {},
820 gracefulShutdownTimeout: "100 millis"
821 })
822 const services = Layer.merge(serverLayer, FetchHttpClient.layer)
823 const runtime = yield* Effect.acquireRelease(
824 Effect.sync(() =>
825 ManagedRuntime.make(Layer.merge(
826 services,
827 HttpRouter.serve(router).pipe(Layer.provide(services))
828 ))
829 ),
830 (runtime) => Effect.promise(() => runtime.dispose())
831 )
832 yield* Effect.promise(() => runtime.context())
833 const downstreamServer = yield* Effect.promise(() => runtime.runPromise(HttpServer.HttpServer))
834 const downstreamPort = (downstreamServer.address as NetAddress.InetAddress).port
835
836 const controller = new AbortController()
837 const downstream = fetch(`http://127.0.0.1:${downstreamPort}`, {
838 signal: controller.signal
839 }).catch(() => undefined)
840 yield* upstreamStarted.await
841 controller.abort()
842 yield* Effect.promise(() => downstream)
843
844 const disposed = yield* Effect.promise(() => runtime.dispose()).pipe(Effect.timeoutOption("2 seconds"))
845 assert.strictEqual(disposed._tag, "Some")
846 }))
847
848 describe("HttpServerRespondable", () => {
849 it.effect("error/schema", () =>
850 Effect.gen(function*() {
851 class CustomError extends Schema.Error<CustomError>("CustomError")({
852 _tag: Schema.tag("CustomError"),
853 name: Schema.String
854 }) {
855 [HttpServerRespondable.symbol]() {
856 return HttpServerResponse.schemaJson(CustomError)(this, { status: 599 })
857 }
858 }
859 yield* HttpRouter.add("GET", "/home", new CustomError({ name: "test" })).pipe(
860 HttpRouter.serve,
861 Layer.build
862 )
863 const response = yield* HttpClient.get("/home")
864 assert.strictEqual(response.status, 599)
865 assert.deepStrictEqual(
866 yield* HttpClientResponse.schemaBodyJson(CustomError)(response),
867 new CustomError({ name: "test" })
868 )
869 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
870
871 it.effect("httpapi error", () =>
872 Effect.gen(function*() {
873 yield* HttpRouter.add("GET", "/home", new HttpApiError.BadRequest({})).pipe(
874 HttpRouter.serve,
875 Layer.build
876 )
877 assert.strictEqual((yield* HttpClient.get("/home")).status, 400)
878 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
879 })
880
881 it.effect("takes the host header from the HTTP/2 authority", () =>
882 Effect.gen(function*() {
883 yield* HttpServer.serveEffect(
884 HttpServerRequest.HttpServerRequest.use((request) =>
885 Effect.succeed(HttpServerResponse.text(
886 `${request.headers.host} ${Option.getOrThrow(HttpServerRequest.toURL(request)).href}`
887 ))
888 )
889 )
890 const server = yield* HttpServer.HttpServer
891 const port = (server.address as NetAddress.InetAddress).port
892
893 for (const host of [undefined, "client.test"]) {
894 assert.strictEqual(
895 yield* http2Get(port, { ":path": "/info", ":authority": "example.test:4573", host }),
896 "example.test:4573 http://example.test:4573/info"
897 )
898 }
899 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
900
901 // Deno 2.8.3 to 2.9.2 panic when a cancelled HTTP/2 request is answered (denoland/deno#36053).
902 it.live("keeps serving after an HTTP/2 client cancels a request in flight", () =>
903 Effect.gen(function*() {
904 const started = Latch.makeUnsafe()
905 const interrupted = Latch.makeUnsafe()
906 yield* HttpRouter.use((router) =>
907 Effect.andThen(
908 router.add(
909 "GET",
910 "/slow",
911 Effect.andThen(started.open, Effect.never).pipe(Effect.onInterrupt(() => interrupted.open))
912 ),
913 router.add("GET", "/", Effect.succeed(HttpServerResponse.text("ok")))
914 )
915 ).pipe(HttpRouter.serve, Layer.build)
916 const server = yield* HttpServer.HttpServer
917 const port = (server.address as NetAddress.InetAddress).port
918
919 yield* Effect.acquireUseRelease(
920 Effect.sync(() => Http2.connect(`http://127.0.0.1:${port}`)),
921 (session) =>
922 Effect.gen(function*() {
923 const stream = session.request({ ":path": "/slow" }).end()
924 stream.on("error", () => {})
925 yield* started.await
926 stream.close(Http2.constants.NGHTTP2_CANCEL)
927 yield* interrupted.await
928 }),
929 (session) => Effect.sync(() => session.destroy())
930 )
931
932 assert.strictEqual(yield* http2Get(port, { ":path": "/" }), "ok")
933 }).pipe(
934 Effect.timeout("2 seconds"),
935 Effect.provide(DenoHttpServer.layerTest)
936 ), 5000)
937
938 it.effect("excludes a query from the host of an absolute-form HTTP/1.1 target", () =>
939 Effect.gen(function*() {
940 yield* HttpServer.serveEffect(
941 HttpServerRequest.HttpServerRequest.use((request) =>
942 Effect.succeed(HttpServerResponse.text(request.headers.host))
943 )
944 )
945 const server = yield* HttpServer.HttpServer
946 const port = (server.address as NetAddress.InetAddress).port
947 const host = yield* Effect.callback<string, Error>((resume) => {
948 const request = Http.get({
949 hostname: "127.0.0.1",
950 port,
951 path: "http://Target.TEST:80?q=/info",
952 headers: { host: "client.test" }
953 }, (response) => {
954 let body = ""
955 response.setEncoding("utf8")
956 response.on("data", (chunk: string) => {
957 body += chunk
958 })
959 response.on("end", () => resume(Effect.succeed(body)))
960 response.on("error", (error) => resume(Effect.fail(error)))
961 })
962 request.on("error", (error) => resume(Effect.fail(error)))
963 return Effect.sync(() => {
964 request.destroy()
965 })
966 })
967 assert.strictEqual(host, "Target.TEST:80")
968 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
969
970 it.effect("RouterConfig", () =>
971 Effect.gen(function*() {
972 yield* HttpRouter.add("GET", "/:param", Effect.succeed(HttpServerResponse.empty())).pipe(
973 HttpRouter.serve,
974 Layer.build
975 )
976 assert.strictEqual((yield* HttpClient.get("/123456")).status, 404)
977 assert.strictEqual((yield* HttpClient.get("/12345")).status, 204)
978 }).pipe(
979 Effect.provide([
980 DenoHttpServer.layerTest,
981 Layer.succeed(HttpRouter.RouterConfig)({ maxParamLength: 5 })
982 ])
983 ))
984
985 it.effect("HttpRouter prefixed", () =>
986 Effect.gen(function*() {
987 const handler = HttpRouter.serve(HttpRouter.use(Effect.fnUntraced(function*(router_) {
988 const router = router_.prefixed("/todos")
989 yield* router.add(
990 "GET",
991 "/:id",
992 Effect.flatMap(HttpRouter.schemaParams(IdParams), ({ id }) => todoResponse({ id, title: "test" }))
993 )
994 yield* router.addAll([
995 HttpRouter.route("GET", "/", Effect.succeed(HttpServerResponse.text("root")))
996 ])
997 })))
998 yield* Layer.build(handler)
999 assert.deepStrictEqual(
1000 yield* HttpClient.get("/todos/1").pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))),
1001 { id: 1, title: "test" }
1002 )
1003 assert.strictEqual(yield* HttpClient.get("/todos").pipe(Effect.flatMap((_) => _.text)), "root")
1004 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1005
1006 it.effect("cancels a file body for HEAD requests", () =>
1007 Effect.gen(function*() {
1008 let cancelled = false
1009 const fileResponse = yield* HttpServerResponse.file(fixture).pipe(
1010 Effect.updateService(HttpPlatform.HttpPlatform, (platform) => ({
1011 ...platform,
1012 fileResponse: (path, options) =>
1013 Effect.map(platform.fileResponse(path, options), (response) => {
1014 assert.strictEqual(response.body._tag, "Raw")
1015 const source = (response.body as HttpBody.Raw).body
1016 assert(source instanceof ReadableStream)
1017 const reader = source.getReader()
1018 const body = new ReadableStream<Uint8Array>({
1019 pull(controller) {
1020 return reader.read().then(({ done, value }) => {
1021 if (done) controller.close()
1022 else controller.enqueue(value)
1023 })
1024 },
1025 cancel(reason) {
1026 cancelled = true
1027 return reader.cancel(reason)
1028 }
1029 })
1030 return HttpServerResponse.raw(body, {
1031 status: response.status,
1032 statusText: response.statusText,
1033 headers: response.headers,
1034 cookies: response.cookies
1035 })
1036 })
1037 }))
1038 )
1039 yield* fileResponse.pipe(
1040 Effect.succeed,
1041 HttpServer.serveEffect()
1042 )
1043 const response = yield* HttpClient.head("/")
1044 assert.strictEqual(response.status, 200)
1045 assert(cancelled)
1046 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1047
1048 it.effect("ignores cancellation errors for HEAD response bodies", () => {
1049 const body = new ReadableStream<Uint8Array>()
1050 const reader = body.getReader()
1051 return Effect.gen(function*() {
1052 yield* HttpServerResponse.raw(body).pipe(
1053 Effect.succeed,
1054 HttpServer.serveEffect()
1055 )
1056 const response = yield* HttpClient.head("/")
1057 assert.strictEqual(response.status, 200)
1058 }).pipe(
1059 Effect.ensuring(Effect.sync(() => reader.releaseLock())),
1060 Effect.provide(DenoHttpServer.layerTest)
1061 )
1062 })
1063
1064 it.effect("round trips WebSocket frames and closes cleanly", () =>
1065 Effect.gen(function*() {
1066 const logged = yield* Deferred.make<unknown>()
1067 const logger = Logger.make((options) => {
1068 const annotations = options.fiber.getRef(References.CurrentLogAnnotations)
1069 if (annotations["http.url"] === "/") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"]))
1070 })
1071 yield* serveWebSocket(echoWebSocket).pipe(Effect.provide(Logger.layer([logger])))
1072 const server = yield* HttpServer.HttpServer
1073 const port = (server.address as NetAddress.InetAddress).port
1074 const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/`, (socket) => socket.send("hello"), 1)
1075 assert.deepStrictEqual(messages, ["hello"])
1076 assert.strictEqual(yield* Deferred.await(logged), 101)
1077 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1078
1079 it.effect("logs status 101 for a WebSocket upgraded through a prefixed route", () =>
1080 Effect.gen(function*() {
1081 const logged = yield* Deferred.make<unknown>()
1082 const logger = Logger.make((options) => {
1083 const annotations = options.fiber.getRef(References.CurrentLogAnnotations)
1084 if (annotations["http.url"] === "/ws") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"]))
1085 })
1086 yield* HttpRouter.use((router) =>
1087 router.prefixed("/ws").add(
1088 "GET",
1089 "/",
1090 Effect.gen(function*() {
1091 const request = yield* HttpServerRequest.HttpServerRequest
1092 yield* echoWebSocket(yield* request.upgrade)
1093 return HttpServerResponse.empty()
1094 })
1095 )
1096 ).pipe(HttpRouter.serve, Layer.provide(Logger.layer([logger])), Layer.build)
1097 const server = yield* HttpServer.HttpServer
1098 const port = (server.address as NetAddress.InetAddress).port
1099 const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/ws`, (socket) => socket.send("hello"), 1)
1100 assert.deepStrictEqual(messages, ["hello"])
1101 assert.strictEqual(yield* Deferred.await(logged), 101)
1102 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1103
1104 it.effect("fails upgrades to protocols other than WebSocket", () =>
1105 Effect.gen(function*() {
1106 // Deno.serve answers upgrade requests with a body method with 400 itself
1107 yield* HttpRouter.add(
1108 "GET",
1109 "/attach",
1110 Effect.gen(function*() {
1111 const request = yield* HttpServerRequest.HttpServerRequest
1112 const error = yield* Effect.flip(request.upgrade)
1113 return HttpServerResponse.text(error.reason.message, { status: 501 })
1114 })
1115 ).pipe(HttpRouter.serve, Layer.build)
1116 const server = yield* HttpServer.HttpServer
1117 const port = (server.address as NetAddress.InetAddress).port
1118 // Deno's fetch sends the upgrade headers that the Effect fetch client refuses
1119 const response = yield* Effect.promise(() =>
1120 fetch(`http://127.0.0.1:${port}/attach`, { headers: { connection: "Upgrade", upgrade: "tcp" } })
1121 )
1122 assert.strictEqual(response.status, 501)
1123 assert.include(yield* Effect.promise(() => response.text()), "Deno.serve only supports WebSocket upgrades")
1124 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1125
1126 it.effect("preserves eager WebSocket frames across an async boundary", () =>
1127 Effect.gen(function*() {
1128 yield* serveWebSocket((socket) =>
1129 Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, 0))).pipe(
1130 Effect.andThen(echoWebSocket(socket))
1131 )
1132 )
1133
1134 const server = yield* HttpServer.HttpServer
1135 const port = (server.address as NetAddress.InetAddress).port
1136 const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/`, (socket) => {
1137 socket.send("first")
1138 socket.send("second")
1139 }, 2)
1140
1141 assert.deepStrictEqual(messages, ["first", "second"])
1142 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1143
1144 it.effect("delivers binary WebSocket frames as Uint8Array", () =>
1145 Effect.gen(function*() {
1146 const received = yield* Queue.unbounded<Uint8Array>()
1147 yield* serveWebSocket((socket) =>
1148 Effect.gen(function*() {
1149 const { pull } = yield* socket.reader
1150 while (true) {
1151 const chunk = yield* pull
1152 for (const message of chunk) {
1153 assert(message instanceof Uint8Array)
1154 yield* Queue.offer(received, message)
1155 }
1156 }
1157 }).pipe(
1158 Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
1159 Effect.orDie
1160 )
1161 )
1162
1163 const server = yield* HttpServer.HttpServer
1164 const port = (server.address as NetAddress.InetAddress).port
1165 const socket = yield* openWebSocket(`ws://127.0.0.1:${port}/`)
1166 socket.send(new Uint8Array([1, 2, 3]))
1167
1168 assert.deepStrictEqual(yield* Queue.take(received), new Uint8Array([1, 2, 3]))
1169 socket.close()
1170 }).pipe(Effect.provide(DenoHttpServer.layerTest)))
1171 })
1172
1173 const echoWebSocket = (socket: Socket.Socket) =>
1174 Effect.gen(function*() {
1175 const writer = yield* socket.writer
1176 const { pull } = yield* socket.reader
1177 while (true) {
1178 yield* writer.writeAll(yield* pull)
1179 }
1180 }).pipe(
1181 Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
1182 Effect.orDie
1183 )
1184
1185 const serveWebSocket = (
1186 run: (socket: Socket.Socket) => Effect.Effect<void, Socket.SocketError, Scope.Scope>
1187 ) =>
1188 HttpRouter.add(
1189 "GET",
1190 "/",
1191 Effect.gen(function*() {
1192 const request = yield* HttpServerRequest.HttpServerRequest
1193 const socket = yield* request.upgrade
1194 yield* run(socket)
1195 return HttpServerResponse.empty()
1196 })
1197 ).pipe(HttpRouter.serve, Layer.build)
1198
1199 const openWebSocket = (url: string) =>
1200 Effect.acquireRelease(
1201 Effect.callback<WebSocket, Error>((resume) => {
1202 const socket = new WebSocket(url)
1203 socket.addEventListener("open", () => resume(Effect.succeed(socket)), { once: true })
1204 socket.addEventListener("error", () => resume(Effect.fail(new Error("WebSocket connection failed"))), {
1205 once: true
1206 })
1207 }),
1208 (socket) => Effect.sync(() => socket.close())
1209 )
1210
1211 const connectWebSocket = (url: string, onOpen: (socket: WebSocket) => void, messageCount: number) =>
1212 Effect.acquireUseRelease(
1213 openWebSocket(url),
1214 (socket) =>
1215 Effect.gen(function*() {
1216 const messages: Array<string> = []
1217 const fiber = yield* Effect.callback<void, Error>((resume) => {
1218 socket.addEventListener("message", (event) => {
1219 messages.push(event.data)
1220 if (messages.length === messageCount) resume(Effect.void)
1221 })
1222 socket.addEventListener("error", () => resume(Effect.fail(new Error("WebSocket connection failed"))), {
1223 once: true
1224 })
1225 onOpen(socket)
1226 }).pipe(Effect.forkChild)
1227 yield* Fiber.join(fiber)
1228 return messages
1229 }),
1230 (socket) => Effect.sync(() => socket.close())
1231 )