@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 764 lines 29.2 KB
Raw
1 import { NodeHttpServer } from "@effect/platform-node"
2 import * as NodeClient from "@effect/platform-node/NodeHttpClient"
3 import Undici from "@effect/platform-node/Undici"
4 import { assert, describe, expect, it } from "@effect/vitest"
5 import { Struct } from "effect"
6 import * as Context from "effect/Context"
7 import * as Deferred from "effect/Deferred"
8 import * as Effect from "effect/Effect"
9 import * as Fiber from "effect/Fiber"
10 import { flow } from "effect/Function"
11 import {
12 FetchHttpClient,
13 HttpBody,
14 HttpClient,
15 HttpClientRequest,
16 HttpClientResponse,
17 HttpRouter,
18 HttpServer,
19 HttpServerRequest,
20 HttpServerResponse,
21 Multipart,
22 UrlParams
23 } from "effect/http"
24 import * as Layer from "effect/Layer"
25 import * as Schedule from "effect/Schedule"
26 import * as Schema from "effect/Schema"
27 import type * as Socket from "effect/socket/Socket"
28 import * as Stream from "effect/Stream"
29 import { mkdtempSync, openAsBlob, rmSync, truncateSync, writeFileSync } from "node:fs"
30 import * as Http from "node:http"
31 import type * as Net from "node:net"
32 import { tmpdir } from "node:os"
33 import { join } from "node:path"
34
35 const Todo = Schema.Struct({
36 userId: Schema.Number,
37 id: Schema.Number,
38 title: Schema.String,
39 completed: Schema.Boolean
40 })
41 const TodoWithoutId = Schema.Struct({
42 ...Struct.omit(Todo.fields, ["id"])
43 })
44 const largeResponseBody = "a".repeat(10 * 1024 * 1024)
45 const responseBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47])
46 const formDataResponses = [
47 {
48 name: "URL-encoded",
49 path: "/form/url-encoded",
50 contentType: "application/x-www-form-urlencoded",
51 body: "tag=one&tag=two"
52 },
53 {
54 name: "multipart",
55 path: "/form/multipart",
56 contentType: "multipart/form-data; boundary=effect-test",
57 body: [
58 "--effect-test",
59 "Content-Disposition: form-data; name=\"tag\"",
60 "",
61 "one",
62 "--effect-test",
63 "Content-Disposition: form-data; name=\"tag\"",
64 "",
65 "two",
66 "--effect-test--",
67 ""
68 ].join("\r\n")
69 }
70 ] as const
71
72 const makeLocalServerClient = Effect.gen(function*() {
73 const client = yield* HttpClient.HttpClient
74 const createTodo = (todo: typeof TodoWithoutId.Type) =>
75 HttpClientRequest.post("/todos").pipe(
76 HttpClientRequest.schemaBodyJson(TodoWithoutId)(todo),
77 Effect.flatMap(client.execute),
78 Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
79 )
80 return {
81 client,
82 createTodo
83 } as const
84 })
85 interface LocalServerClient extends Effect.Success<typeof makeLocalServerClient> {}
86 const LocalServerClient = Context.Service<LocalServerClient>("test/LocalServerClient")
87 const LocalServerClientLayer = Layer.effect(LocalServerClient)(makeLocalServerClient)
88 const LocalServerRoutes = HttpRouter.serve(HttpRouter.addAll([
89 HttpRouter.route(
90 "GET",
91 "/todos/1",
92 Effect.succeed(HttpServerResponse.jsonUnsafe({
93 userId: 1,
94 id: 1,
95 title: "test",
96 completed: false
97 }))
98 ),
99 HttpRouter.route(
100 "POST",
101 "/todos",
102 Effect.gen(function*() {
103 const todo = yield* HttpServerRequest.schemaBodyJson(TodoWithoutId)
104 return HttpServerResponse.jsonUnsafe({ ...todo, id: 201 })
105 })
106 ),
107 HttpRouter.route("GET", "/text", Effect.succeed(HttpServerResponse.text("test"))),
108 HttpRouter.route(
109 "QUERY",
110 "/search",
111 Effect.gen(function*() {
112 const request = yield* HttpServerRequest.HttpServerRequest
113 return HttpServerResponse.jsonUnsafe({
114 method: request.method,
115 contentType: request.headers["content-type"],
116 body: yield* request.text
117 })
118 })
119 ),
120 HttpRouter.route("GET", "/bytes", Effect.succeed(HttpServerResponse.uint8Array(responseBytes))),
121 HttpRouter.route(
122 "POST",
123 "/multipart",
124 Effect.gen(function*() {
125 const request = yield* HttpServerRequest.HttpServerRequest
126 const parts = yield* request.multipartStream.pipe(
127 Stream.mapEffect((part) =>
128 Effect.gen(function*() {
129 if (Multipart.isField(part)) {
130 return { key: part.key, value: part.value }
131 }
132 const content = yield* part.contentEffect
133 return {
134 key: part.key,
135 name: part.name,
136 contentType: part.contentType,
137 content: new TextDecoder().decode(content)
138 }
139 })
140 ),
141 Stream.runCollect
142 )
143 return HttpServerResponse.jsonUnsafe(parts)
144 })
145 ),
146 HttpRouter.route(
147 "POST",
148 "/bom-json",
149 Effect.gen(function*() {
150 const request = yield* HttpServerRequest.HttpServerRequest
151 return HttpServerResponse.text(`\uFEFF${JSON.stringify(yield* request.json)}`, {
152 contentType: "application/json"
153 })
154 })
155 ),
156 HttpRouter.route(
157 "POST",
158 "/question-form",
159 Effect.gen(function*() {
160 const request = yield* HttpServerRequest.HttpServerRequest
161 return HttpServerResponse.text(`?${UrlParams.toString(yield* request.urlParamsBody)}`, {
162 contentType: "application/x-www-form-urlencoded"
163 })
164 })
165 ),
166 ...formDataResponses.map(({ body, contentType, path }) =>
167 HttpRouter.route("GET", path, Effect.succeed(HttpServerResponse.text(body, { contentType })))
168 ),
169 HttpRouter.route("GET", "/large", Effect.succeed(HttpServerResponse.text(largeResponseBody))),
170 HttpRouter.route("GET", "/hang", Effect.never),
171 HttpRouter.route(
172 "GET",
173 "/redirect",
174 Effect.succeed(HttpServerResponse.text("redirecting", {
175 status: 302,
176 headers: { location: "/redirected" }
177 }))
178 ),
179 HttpRouter.route("GET", "/redirected", Effect.succeed(HttpServerResponse.text("redirected"))),
180 HttpRouter.route("HEAD", "/todos", Effect.succeed(HttpServerResponse.empty({ status: 200 }))),
181 HttpRouter.route(
182 "POST",
183 "/upgrade",
184 Effect.succeed(HttpServerResponse.jsonUnsafe({ message: "unauthorized" }, { status: 401 }))
185 )
186 ]))
187 ;[
188 {
189 name: "fetch",
190 layer: NodeClient.layerFetch
191 },
192 {
193 name: "node:http",
194 layer: NodeClient.layerNodeHttp
195 },
196 {
197 name: "undici",
198 layer: NodeClient.layerUndici
199 }
200 ].forEach(({ layer, name }) => {
201 const layerTest = HttpServer.layerTestClient.pipe(
202 Layer.provide(layer),
203 Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
204 )
205 const localServerTestLayer = Layer.merge(LocalServerClientLayer, LocalServerRoutes).pipe(
206 Layer.provideMerge(layerTest)
207 )
208
209 describe(`NodeHttpClient - ${name}`, () => {
210 it.effect("text", () =>
211 Effect.gen(function*() {
212 const response = yield* HttpClient.get("/text?existing=1", {
213 urlParams: { value: "a#b" },
214 hash: "fragment"
215 })
216 const url = new URL(response.url)
217 assert.strictEqual(url.pathname, "/text")
218 assert.strictEqual(url.search, "?existing=1&value=a%23b")
219 assert.strictEqual(url.hash, "")
220 expect(yield* response.text).toBe("test")
221 }).pipe(Effect.provide(localServerTestLayer)))
222
223 it.effect("accessing text preserves response bytes", () =>
224 Effect.gen(function*() {
225 const response = yield* HttpClient.get("/bytes")
226 void response.text
227 assert.deepStrictEqual(new Uint8Array(yield* response.arrayBuffer), responseBytes)
228 }).pipe(Effect.provide(localServerTestLayer)))
229
230 it.effect("request and response json ignore a leading UTF-8 BOM", () =>
231 Effect.gen(function*() {
232 const response = yield* HttpClient.post("/bom-json", {
233 body: HttpBody.text("\uFEFF{\"a\":1}", "application/json")
234 })
235 assert.deepStrictEqual(yield* response.json, { a: 1 })
236 }).pipe(Effect.provide(localServerTestLayer)))
237
238 it.effect("request and response urlParamsBody preserve a leading question mark", () =>
239 Effect.gen(function*() {
240 const response = yield* HttpClient.post("/question-form", {
241 body: HttpBody.text("?name=value", "application/x-www-form-urlencoded")
242 })
243 // the server echoes its parsed key behind another raw question mark
244 assert.deepStrictEqual([...yield* response.urlParamsBody], [["??name", "value"]])
245 }).pipe(Effect.provide(localServerTestLayer)))
246
247 if (name !== "fetch") {
248 it.live("continues uploading while reading a streaming response", () => {
249 const server = Http.createServer((request, response) => {
250 request.on("error", () => {})
251 response.writeHead(200, { "content-type": "text/plain" })
252 response.write("ready\n")
253 request.pipe(response)
254 })
255 const testLayer = HttpServer.layerTestClient.pipe(
256 Layer.provide(layer),
257 Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
258 )
259 return Effect.gen(function*() {
260 const readingResponse = yield* Deferred.make<void>()
261 const encoder = new TextEncoder()
262 const body = Stream.succeed(encoder.encode("first")).pipe(
263 Stream.concat(Stream.fromEffect(
264 Deferred.await(readingResponse).pipe(Effect.as(encoder.encode("second")))
265 ))
266 )
267 const response = yield* HttpClient.post("/", { body: HttpBody.stream(body) })
268 const text = yield* response.stream.pipe(
269 Stream.tap(() => Deferred.succeed(readingResponse, undefined)),
270 Stream.decodeText(),
271 Stream.mkString
272 )
273 assert.strictEqual(text, "ready\nfirstsecond")
274 }).pipe(
275 Effect.timeout("2 seconds"),
276 Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
277 Effect.provide(testLayer)
278 )
279 })
280
281 it.live.each([
282 { source: "global", FormData: globalThis.FormData },
283 { source: "undici", FormData: Undici.FormData }
284 ])("sends $source form data request bodies as multipart", ({ FormData }) =>
285 Effect.gen(function*() {
286 const formData = new FormData()
287 formData.append("title", "effect")
288 formData.append("file", new Blob(["file contents"], { type: "text/plain" }), "notes.txt")
289 const response = yield* HttpClient.post("/multipart", {
290 body: HttpBody.formData(formData as globalThis.FormData),
291 headers: { "content-type": "multipart/form-data; boundary=caller-boundary" }
292 }).pipe(
293 Effect.timeout("2 seconds")
294 )
295 assert.deepStrictEqual(yield* response.json, [
296 { key: "title", value: "effect" },
297 { key: "file", name: "notes.txt", contentType: "text/plain", content: "file contents" }
298 ])
299 }).pipe(Effect.provide(localServerTestLayer)))
300
301 it.live("returns TransportError when a form data file cannot be read", () =>
302 Effect.gen(function*() {
303 const directory = yield* Effect.acquireRelease(
304 Effect.sync(() => mkdtempSync(join(tmpdir(), "effect-form-data-"))),
305 (directory) => Effect.sync(() => rmSync(directory, { recursive: true, force: true }))
306 )
307 const path = join(directory, "notes.txt")
308 writeFileSync(path, "file contents")
309 const blob = yield* Effect.promise(() => openAsBlob(path, { type: "text/plain" }))
310 const formData = new FormData()
311 formData.append("file", blob, "notes.txt")
312 truncateSync(path, 0)
313
314 const error = yield* HttpClient.post("/multipart", { body: HttpBody.formData(formData) }).pipe(
315 Effect.timeout("2 seconds"),
316 Effect.flip
317 )
318 assert(error._tag === "HttpClientError", `Expected HttpClientError, got ${error._tag}`)
319 assert.strictEqual(error.reason._tag, "TransportError")
320 }).pipe(Effect.provide(localServerTestLayer)))
321 }
322
323 if (name === "undici") {
324 it.effect.each(formDataResponses)("parses $name response form data", ({ path }) =>
325 Effect.gen(function*() {
326 const response = yield* HttpClient.get(path)
327 const form = yield* response.formData
328 assert.deepStrictEqual(form.getAll("tag"), ["one", "two"])
329 }).pipe(Effect.provide(localServerTestLayer)))
330 }
331
332 it.effect("local server followRedirects", () =>
333 Effect.gen(function*() {
334 const client = (yield* HttpClient.HttpClient).pipe(
335 HttpClient.followRedirects()
336 )
337 const response = yield* client.get("/redirect")
338 expect(new URL(response.url).pathname).toBe("/redirected")
339 expect(yield* response.text).toBe("redirected")
340 }).pipe(Effect.provide(localServerTestLayer)))
341
342 it.effect("text stream", () =>
343 Effect.gen(function*() {
344 const client = yield* HttpClient.HttpClient
345 const response = yield* client.get("/text").pipe(
346 Effect.map((_) => _.stream),
347 Stream.unwrap,
348 Stream.decodeText(),
349 Stream.mkString
350 )
351 expect(response).toBe("test")
352 }).pipe(Effect.provide(localServerTestLayer)))
353
354 it.effect("local server", () =>
355 Effect.gen(function*() {
356 const local = yield* LocalServerClient
357 const response = yield* local.client.get("/todos/1").pipe(
358 Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo, {
359 reviver: (key, value) => key === "title" ? "revived" : value
360 }))
361 )
362 expect(response.id).toBe(1)
363 expect(response.title).toBe("revived")
364 }).pipe(
365 Effect.provide(localServerTestLayer)
366 ))
367
368 it.effect("local server schemaBodyJson", () =>
369 Effect.gen(function*() {
370 const local = yield* LocalServerClient
371 const response = yield* local.createTodo({
372 userId: 1,
373 title: "test",
374 completed: false
375 })
376 expect(response.title).toBe("test")
377 }).pipe(
378 Effect.provide(localServerTestLayer)
379 ))
380
381 it.effect("round trips QUERY method, body, and content type through the local server", () =>
382 Effect.gen(function*() {
383 const body = JSON.stringify({ query: "effect" })
384 const response = yield* HttpClient.query("/search", {
385 body: HttpBody.text(body, "application/json")
386 })
387
388 assert.strictEqual(response.status, 200)
389 assert.deepStrictEqual(yield* response.json, {
390 method: "QUERY",
391 contentType: "application/json",
392 body
393 })
394 }).pipe(Effect.provide(localServerTestLayer)))
395
396 it.effect("head request with schemaJson", () =>
397 Effect.gen(function*() {
398 const client = yield* HttpClient.HttpClient
399 const response = yield* client.head("/todos").pipe(
400 Effect.flatMap(
401 HttpClientResponse.schemaJson(Schema.Struct({ status: Schema.Literal(200) }))
402 )
403 )
404 expect(response).toEqual({ status: 200 })
405 }).pipe(Effect.provide(localServerTestLayer)))
406
407 it.live("interrupt", () =>
408 Effect.gen(function*() {
409 const client = yield* HttpClient.HttpClient
410 const response = yield* client.get("/hang").pipe(
411 Effect.flatMap((_) => _.text),
412 Effect.timeout(1),
413 Effect.asSome,
414 Effect.catchTag("TimeoutError", () => Effect.succeedNone)
415 )
416 expect(response._tag).toEqual("None")
417 }).pipe(Effect.provide(localServerTestLayer)))
418
419 if (name !== "fetch") {
420 it.effect("reads a refused upgrade as an ordinary response", () =>
421 Effect.gen(function*() {
422 const response = yield* HttpClient.execute(
423 HttpClientRequest.post("/upgrade").pipe(HttpClientRequest.upgrade("tcp"))
424 )
425 assert.strictEqual(response.status, 401)
426 const error = yield* Effect.flip(response.upgrade)
427 assert.strictEqual(error.reason._tag, "StatusCodeError")
428 assert.deepStrictEqual(yield* response.json, { message: "unauthorized" })
429 }).pipe(Effect.provide(localServerTestLayer)))
430 }
431
432 it.effect("close early", () =>
433 Effect.gen(function*() {
434 const response = yield* HttpClient.get("/large")
435 expect(response.status).toBe(200)
436 }).pipe(Effect.provide(localServerTestLayer)))
437 })
438 })
439
440 it.live("followRedirects releases redirect response bodies with a single socket", () =>
441 Effect.gen(function*() {
442 const client = (yield* HttpClient.HttpClient).pipe(HttpClient.followRedirects())
443 const response = yield* client.get("/redirect")
444 expect(yield* response.text).toBe("redirected")
445 }).pipe(
446 Effect.timeout("2 seconds"),
447 Effect.provide(LocalServerRoutes.pipe(
448 Layer.provideMerge(HttpServer.layerTestClient),
449 Layer.provide(NodeClient.layerNodeHttpOptions({ maxSockets: 1 })),
450 Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
451 ))
452 ))
453
454 it.live("followRedirects releases scoped redirect response bodies with a single socket", () =>
455 Effect.gen(function*() {
456 const client = (yield* HttpClient.HttpClient).pipe(HttpClient.withScope, HttpClient.followRedirects())
457 const response = yield* client.get("/redirect")
458 expect(yield* response.text).toBe("redirected")
459 }).pipe(
460 Effect.scoped,
461 Effect.timeout("2 seconds"),
462 Effect.provide(LocalServerRoutes.pipe(
463 Layer.provideMerge(HttpServer.layerTestClient),
464 Layer.provide(NodeClient.layerNodeHttpOptions({ maxSockets: 1 })),
465 Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
466 ))
467 ))
468
469 it.live("releases an immediately failing form data stream and connection before layer teardown", () => {
470 const server = Http.createServer((request) => {
471 request.on("error", () => {})
472 request.resume()
473 })
474 const layer = HttpServer.layerTestClient.pipe(
475 Layer.provide(NodeClient.layerNodeHttp),
476 Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
477 )
478 return Effect.gen(function*() {
479 const streams: Array<ReadableStream<Uint8Array<ArrayBuffer>>> = []
480 class BrokenFile extends File {
481 override stream() {
482 const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
483 start(controller) {
484 controller.error(new Error("file read failed"))
485 }
486 })
487 streams.push(stream)
488 return stream
489 }
490 }
491 const formData = new FormData()
492 formData.append("file", new BrokenFile(["file contents"], "notes.txt"))
493 const error = yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(
494 Effect.timeout("2 seconds"),
495 Effect.match({ onFailure: (error) => error, onSuccess: () => undefined })
496 )
497 assert.strictEqual(streams.length, 1)
498 assert(error?._tag === "HttpClientError", `Expected HttpClientError, got ${error?._tag}`)
499 assert.strictEqual(error.reason._tag, "TransportError")
500 assert.strictEqual(streams[0].locked, false)
501 const connections = yield* Effect.sleep("10 millis").pipe(
502 Effect.andThen(Effect.callback<number, Error>((resume) => {
503 server.getConnections((error, count) => resume(error ? Effect.fail(error) : Effect.succeed(count)))
504 })),
505 Effect.repeat({ while: (count) => count !== 0, schedule: Schedule.spaced("10 millis") }),
506 Effect.timeout("1 second")
507 )
508 assert.strictEqual(connections, 0)
509 }).pipe(
510 Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
511 Effect.provide(layer)
512 )
513 })
514
515 it.live("returns TransportError when a form data file stream cannot be created", () =>
516 Effect.gen(function*() {
517 class ThrowingFile extends File {
518 override stream(): never {
519 throw new Error("file stream failed")
520 }
521 }
522 const formData = new FormData()
523 formData.append("file", new ThrowingFile([], "notes.txt"))
524 const error = yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(Effect.flip)
525 assert.strictEqual(error.reason._tag, "TransportError")
526 }).pipe(Effect.provide(HttpServer.layerTestClient.pipe(
527 Layer.provide(NodeClient.layerNodeHttp),
528 Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
529 ))))
530
531 it.live("reads backpressured form data files on demand and releases them on interruption", () => {
532 const server = Http.createServer((request) => request.pause())
533 let read = 0
534 let stream: ReadableStream | undefined
535 class LargeFile extends File {
536 override stream() {
537 return stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
538 pull(controller) {
539 if (read === 64 * 1024 * 1024) return controller.close()
540 read += 64 * 1024
541 controller.enqueue(new Uint8Array(64 * 1024))
542 }
543 })
544 }
545 }
546 return Effect.gen(function*() {
547 const formData = new FormData()
548 formData.append("file", new LargeFile([], "large.bin"))
549 yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(Effect.timeout("1 second"), Effect.ignore)
550 // The server never reads the upload, so only socket buffers should fill.
551 assert.isBelow(read, 16 * 1024 * 1024)
552 yield* Effect.sync(() => stream?.locked).pipe(
553 Effect.repeat({ while: (locked) => locked !== false, schedule: Schedule.spaced("10 millis") }),
554 Effect.timeout("1 second")
555 )
556 }).pipe(
557 Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
558 Effect.provide(HttpServer.layerTestClient.pipe(
559 Layer.provide(NodeClient.layerNodeHttp),
560 Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
561 ))
562 )
563 })
564
565 it.live.each(["response completion", "response interruption", "upload failure"] as const)(
566 "releases an unfinished keep-alive upload after %s before layer teardown",
567 (mode) =>
568 Effect.gen(function*() {
569 const uploadBlocked = yield* Deferred.make<void>()
570 const uploadFinalized = yield* Deferred.make<void>()
571 const failUpload = yield* Deferred.make<void>()
572 const connectionClosed = yield* Deferred.make<void>()
573 const server = Http.createServer((request, response) => {
574 request.on("error", () => {})
575 request.socket.once("close", () => Deferred.doneUnsafe(connectionClosed, Effect.void))
576 request.once("data", () => {
577 response.writeHead(200, { "content-type": "text/plain" })
578 if (mode === "response completion") {
579 response.end("ready")
580 } else {
581 response.write("ready")
582 }
583 })
584 })
585 const layer = HttpServer.layerTestClient.pipe(
586 Layer.provide(NodeClient.layerNodeHttpNoAgent.pipe(
587 Layer.provide(NodeClient.layerAgentOptions({ keepAlive: true }))
588 )),
589 Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
590 )
591 yield* Effect.gen(function*() {
592 const body = Stream.succeed(new TextEncoder().encode("first")).pipe(
593 Stream.concat(Stream.fromEffect(
594 Deferred.succeed(uploadBlocked, undefined).pipe(
595 Effect.andThen(Deferred.await(failUpload)),
596 Effect.andThen(Effect.fail("upload failed"))
597 )
598 )),
599 Stream.ensuring(Deferred.succeed(uploadFinalized, undefined))
600 )
601 const response = yield* HttpClient.post("/", { body: HttpBody.stream(body) })
602 yield* Deferred.await(uploadBlocked)
603 if (mode === "response completion") {
604 assert.strictEqual(yield* response.text, "ready")
605 } else if (mode === "response interruption") {
606 const reading = yield* Deferred.make<void>()
607 const reader = yield* response.stream.pipe(
608 Stream.tap(() => Deferred.succeed(reading, undefined)),
609 Stream.runDrain,
610 Effect.forkChild
611 )
612 yield* Deferred.await(reading)
613 yield* Fiber.interrupt(reader)
614 } else {
615 const error = yield* response.stream.pipe(
616 Stream.tap(() => Deferred.succeed(failUpload, undefined)),
617 Stream.runDrain,
618 Effect.timeout("1 second"),
619 Effect.flip
620 )
621 assert.strictEqual(error._tag, "HttpClientError")
622 }
623 // Check while the agent is still alive: layer teardown must not mask a leak.
624 yield* Deferred.await(uploadFinalized).pipe(Effect.timeout("1 second"))
625 if (mode !== "response completion") {
626 yield* Deferred.await(connectionClosed).pipe(Effect.timeout("1 second"))
627 }
628 }).pipe(
629 Effect.timeout("2 seconds"),
630 Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
631 Effect.provide(layer)
632 )
633 })
634 )
635
636 it.live("returns a stream body encoding failure", () =>
637 Effect.gen(function*() {
638 yield* Effect.gen(function*() {
639 const request = yield* HttpServerRequest.HttpServerRequest
640 yield* request.text
641 return HttpServerResponse.empty()
642 }).pipe(HttpServer.serveEffect())
643 const error = yield* HttpClient.post("/", {
644 body: HttpBody.stream(Stream.fail("encode failure"))
645 }).pipe(Effect.timeout("1 second"), Effect.flip)
646 assert(error._tag === "HttpClientError")
647 assert.strictEqual(error.reason._tag, "EncodeError")
648 assert.strictEqual(error.reason.cause, "encode failure")
649 }).pipe(Effect.provide(HttpServer.layerTestClient.pipe(
650 Layer.provide(NodeClient.layerNodeHttp),
651 Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
652 ))))
653
654 // Answers upgrade requests by hand, sending bytes in the same write as the
655 // response head, like a Docker Engine attach endpoint.
656 const makeUpgradeServer = (onClose?: () => void) => {
657 const sockets = new Set<Net.Socket>()
658 return Effect.acquireRelease(
659 Effect.callback<Http.Server>((resume) => {
660 const server = Http.createServer()
661 server.on("connection", (socket) => {
662 sockets.add(socket)
663 socket.once("close", () => sockets.delete(socket))
664 })
665 server.on("upgrade", (request: Http.IncomingMessage, socket: Net.Socket) => {
666 if (onClose !== undefined) socket.once("close", onClose)
667 socket.write(
668 "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\n" +
669 `Upgrade: ${request.headers.upgrade}\r\nX-Url: ${request.url}\r\n` +
670 `X-Authorization: ${request.headers.authorization}\r\n\r\nhello|`
671 )
672 socket.on("data", (chunk) => socket.write(`echo:${chunk}|`))
673 socket.on("end", () => socket.end("bye"))
674 })
675 server.listen(0, "127.0.0.1", () => resume(Effect.succeed(server)))
676 }),
677 (server) =>
678 Effect.callback<void>((resume) => {
679 for (const socket of sockets) socket.destroy()
680 server.closeAllConnections()
681 server.close(() => resume(Effect.void))
682 })
683 ).pipe(
684 Effect.map((server) =>
685 HttpClient.mapRequest(flow(
686 HttpClientRequest.prependUrl(`http://127.0.0.1:${(server.address() as Net.AddressInfo).port}/base`),
687 HttpClientRequest.bearerToken("token")
688 ))
689 )
690 )
691 }
692
693 const readUntilClose = Effect.fnUntraced(function*(reader: Socket.Reader) {
694 const decoder = new TextDecoder()
695 let text = ""
696 while (true) {
697 const chunks = yield* reader.pull.pipe(
698 Effect.catchReason("SocketError", "SocketCloseError", () => Effect.succeed(undefined))
699 )
700 if (chunks === undefined) return text
701 for (const chunk of chunks) text += typeof chunk === "string" ? chunk : decoder.decode(chunk)
702 }
703 })
704
705 describe("NodeHttpClient upgrade", () => {
706 ;[
707 { name: "node:http", layer: NodeClient.layerNodeHttp },
708 { name: "undici", layer: NodeClient.layerUndici }
709 ].forEach(({ layer, name }) => {
710 describe(name, () => {
711 it.effect("hands over the connection of a 101 response", () =>
712 Effect.gen(function*() {
713 const client = (yield* HttpClient.HttpClient).pipe(yield* makeUpgradeServer())
714 const response = yield* client.execute(
715 HttpClientRequest.post("/attach").pipe(HttpClientRequest.upgrade("tcp"))
716 )
717 assert.strictEqual(response.status, 101)
718 assert.strictEqual(response.headers["upgrade"], "tcp")
719 assert.strictEqual(response.headers["x-url"], "/base/attach")
720 assert.strictEqual(response.headers["x-authorization"], "Bearer token")
721
722 const socket = yield* response.upgrade
723 const reader = yield* socket.reader
724 // releasing the writer half-closes, so the server answers "bye"
725 yield* Effect.scoped(Effect.flatMap(socket.writer, (writer) => writer.write("ping")))
726 assert.strictEqual(yield* readUntilClose(reader), "hello|echo:ping|bye")
727 }).pipe(Effect.provide(layer)))
728 it.live("closes the upgraded connection when the request scope closes", () =>
729 Effect.gen(function*() {
730 const closed = yield* Deferred.make<void>()
731 const client = (yield* HttpClient.HttpClient).pipe(
732 yield* makeUpgradeServer(() => Deferred.doneUnsafe(closed, Effect.void)),
733 HttpClient.withScope
734 )
735 yield* Effect.scoped(Effect.gen(function*() {
736 const response = yield* client.execute(
737 HttpClientRequest.post("/attach").pipe(HttpClientRequest.upgrade("tcp"))
738 )
739 assert.strictEqual(response.status, 101)
740 }))
741 yield* Deferred.await(closed).pipe(Effect.timeout("1 second"))
742 }).pipe(Effect.provide(layer)))
743 })
744 })
745
746 it.effect("fetch rejects an upgrade request before calling fetch", () =>
747 Effect.gen(function*() {
748 let calls = 0
749 const error = yield* HttpClient.execute(
750 HttpClientRequest.post("http://127.0.0.1:1/attach").pipe(HttpClientRequest.upgrade("tcp"))
751 ).pipe(
752 Effect.provideService(
753 FetchHttpClient.Fetch,
754 Object.assign(() => {
755 calls++
756 return Promise.resolve(new Response(""))
757 }, { preconnect: () => {} })
758 ),
759 Effect.flip
760 )
761 assert.strictEqual(error.reason._tag, "TransportError")
762 assert.strictEqual(calls, 0)
763 }).pipe(Effect.provide(NodeClient.layerFetch)))
764 })