The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }) |