import * as DenoHttpServer from "@effect/platform-deno/DenoHttpServer"
import { assert, describe, it } from "@effect/vitest"
import * as ByteSize from "effect/ByteSize"
import * as Cause from "effect/Cause"
import * as Deferred from "effect/Deferred"
import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import * as Fiber from "effect/Fiber"
import * as HttpApiError from "effect/http-api/HttpApiError"
import * as Cookies from "effect/http/Cookies"
import * as Etag from "effect/http/Etag"
import * as FetchHttpClient from "effect/http/FetchHttpClient"
import * as HttpBody from "effect/http/HttpBody"
import * as HttpClient from "effect/http/HttpClient"
import * as HttpClientRequest from "effect/http/HttpClientRequest"
import * as HttpClientResponse from "effect/http/HttpClientResponse"
import * as HttpIncomingMessage from "effect/http/HttpIncomingMessage"
import * as HttpPlatform from "effect/http/HttpPlatform"
import * as HttpRouter from "effect/http/HttpRouter"
import * as HttpServer from "effect/http/HttpServer"
import * as HttpServerRequest from "effect/http/HttpServerRequest"
import * as HttpServerRespondable from "effect/http/HttpServerRespondable"
import * as HttpServerResponse from "effect/http/HttpServerResponse"
import * as Multipart from "effect/http/Multipart"
import * as UrlParams from "effect/http/UrlParams"
import * as Latch from "effect/Latch"
import * as Layer from "effect/Layer"
import * as Logger from "effect/Logger"
import * as ManagedRuntime from "effect/ManagedRuntime"
import type * as NetAddress from "effect/net/NetAddress"
import * as Option from "effect/Option"
import * as Queue from "effect/Queue"
import * as References from "effect/References"
import * as Schema from "effect/Schema"
import * as Scope from "effect/Scope"
import type * as Socket from "effect/socket/Socket"
import * as Stream from "effect/Stream"
import * as Tracer from "effect/Tracer"
import * as Http from "node:http"
import * as Http2 from "node:http2"
import {
describeHttpServerProtocol,
http2Get,
layerTestClient
} from "../../node-shared/test/HttpServerHttp2.test-utils.ts"
const Todo = Schema.Struct({
id: Schema.Number,
title: Schema.String
})
const IdParams = Schema.Struct({
id: Schema.FiniteFromString
})
const todoResponse = HttpServerResponse.schemaJson(Todo)
const fixture = `${import.meta.dirname}/fixtures/text.txt`
const ca = Deno.readTextFileSync(new URL("./fixtures/tls/ca.pem", import.meta.url))
const cert = Deno.readTextFileSync(new URL("./fixtures/tls/cert.pem", import.meta.url))
const key = Deno.readTextFileSync(new URL("./fixtures/tls/key.pem", import.meta.url))
// Deno's fetch client speaks HTTP/2 with prior knowledge over cleartext
const layerHttp2Client = (options?: Omit<Deno.CreateHttpClientOptions, "http1" | "http2">) =>
FetchHttpClient.layer.pipe(Layer.provide(
Layer.effect(FetchHttpClient.RequestInit)(
Effect.acquireRelease(
Effect.sync(() => Deno.createHttpClient({ ...options, http1: false, http2: true })),
(client) => Effect.sync(() => client.close())
).pipe(Effect.map((client) => ({ client }) as RequestInit))
)
))
describe("DenoHttpServer", () => {
describe("serve scope ownership", { concurrent: false }, () => {
it.live("closes the request scope when a streaming body is cancelled synchronously during construction", () =>
Effect.gen(function*() {
let finalized = false
let pulled = false
let cancellation: Promise<void> | undefined
const OriginalResponse = globalThis.Response
yield* Effect.acquireRelease(
Effect.sync(() => {
// Intercept construction: awaiting a response over HTTP lets the first pull run already.
globalThis.Response = class extends OriginalResponse {
constructor(body?: BodyInit | null, init?: ResponseInit) {
if (body instanceof ReadableStream) {
cancellation = body.cancel()
super(null, init)
} else {
super(body, init)
}
}
}
}),
() =>
Effect.sync(() => {
globalThis.Response = OriginalResponse
})
)
yield* HttpServer.serveEffect(Effect.gen(function*() {
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
finalized = true
})
)
return HttpServerResponse.stream(Stream.fromEffect(Effect.sync(() => {
pulled = true
return new Uint8Array([1])
})))
}))
const response = yield* HttpClient.get("/")
assert.strictEqual(response.status, 200)
yield* response.text
assert.isDefined(cancellation)
yield* Effect.promise(() => cancellation!)
assert.strictEqual(pulled, false)
assert.strictEqual(finalized, true)
}).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
it.live("interrupts a streaming body suspended during startup when the serve scope closes", () =>
Effect.gen(function*() {
let finalized = false
const started = yield* Deferred.make<void>()
const release = yield* Deferred.make<void>()
const server = yield* DenoHttpServer.make({ hostname: "127.0.0.1", port: 0, disablePreemptiveShutdown: true })
// Let the body finish on teardown so the server can stop if it was never interrupted.
yield* Effect.addFinalizer(() => Deferred.succeed(release, undefined))
const serveScope = yield* Scope.fork(yield* Effect.scope)
yield* server.serve(Effect.gen(function*() {
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
finalized = true
})
)
// The body suspends during startup, before it can serve a pull.
return HttpServerResponse.stream(
Stream.transformPull(
Stream.empty,
(pull) =>
Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)), Effect.as(pull))
)
)
})).pipe(Scope.provide(serveScope))
// Not awaited: headers may not be sent while the body is suspended.
fetch(`http://127.0.0.1:${(server.address as NetAddress.InetAddress).port}/`, {
headers: { connection: "close" }
}).catch(() => undefined)
yield* Deferred.await(started)
assert.strictEqual(finalized, false)
yield* Scope.close(serveScope, Exit.void)
assert.strictEqual(finalized, true)
}).pipe(Effect.timeout("2 seconds")))
})
// After the sequential block above, which replaces `globalThis.Response` and cancels streaming bodies
describeHttpServerProtocol("HTTP/1.1", DenoHttpServer.layerTest)
describeHttpServerProtocol(
"h2c",
layerTestClient("http").pipe(
Layer.provide(layerHttp2Client()),
Layer.provideMerge(DenoHttpServer.layerServer({ hostname: "127.0.0.1", port: 0, onListen: () => {} }))
)
)
describeHttpServerProtocol(
"HTTP/2 over TLS",
layerTestClient("https").pipe(
Layer.provide(layerHttp2Client({ caCerts: [ca] })),
Layer.provideMerge(DenoHttpServer.layerServer({ hostname: "127.0.0.1", port: 0, cert, key, onListen: () => {} }))
)
)
describe("body omission", () => {
for (const status of [204, 205, 304]) {
for (const bodyKind of ["text", "stream"]) {
it.live(`omits ${bodyKind} bodies for status ${status}`, () =>
Effect.gen(function*() {
let finalized = false
let streamStarted = false
yield* HttpServer.serveEffect(Effect.gen(function*() {
yield* Effect.addFinalizer(() =>
Effect.sync(() => {
finalized = true
})
)
const options = { status, contentType: "text/plain", contentLength: 4 }
return bodyKind === "text"
? HttpServerResponse.text("body", options)
: HttpServerResponse.stream(
Stream.fromEffect(Effect.sync(() => {
streamStarted = true
return new TextEncoder().encode("body")
})),
options
)
}))
const response = yield* HttpClient.get("/")
assert.strictEqual(response.status, status)
assert.strictEqual(yield* response.text, "")
assert.strictEqual(streamStarted, false)
assert.strictEqual(finalized, true)
if (status === 304) {
assert.strictEqual(response.headers["content-type"], "text/plain")
}
}).pipe(
Effect.timeout("2 seconds"),
Effect.provide(DenoHttpServer.layerTest)
), 5000)
}
}
// Deno strips the header itself over HTTP/1.1, so only HTTP/2 shows it.
for (const status of [204, 205]) {
for (const raw of [false, true]) {
it.live(
`drops content-length for ${raw ? "a raw Response with " : ""}status ${status} over HTTP/2`,
() =>
Effect.gen(function*() {
const client = Deno.createHttpClient({ http1: false, http2: true })
yield* Effect.addFinalizer(() => Effect.sync(() => client.close()))
yield* HttpServer.serveEffect(Effect.sync(() =>
raw
? HttpServerResponse.raw(new Response(null, { status, headers: { "content-length": "4" } }))
: HttpServerResponse.text("body", { status })
))
const response = yield* HttpClient.get("/").pipe(
Effect.provideService(FetchHttpClient.RequestInit, { client } as RequestInit)
)
assert.strictEqual(response.status, status)
assert.strictEqual(response.headers["content-length"], undefined)
assert.strictEqual(yield* response.text, "")
}).pipe(
Effect.timeout("2 seconds"),
Effect.provide(DenoHttpServer.layerTest)
),
5000
)
}
}
for (const [method, status] of [["HEAD", 200], ["GET", 204], ["GET", 205], ["GET", 304]] as const) {
it.live(`cancels raw streams for ${method} status ${status}`, () =>
Effect.gen(function*() {
let cancelled = false
const body = new ReadableStream<Uint8Array>({
pull(controller) {
controller.enqueue(new TextEncoder().encode("body"))
controller.close()
},
cancel() {
cancelled = true
}
}, { highWaterMark: 0 })
yield* Effect.addFinalizer(() => Effect.ignoreCause(Effect.promise(() => body.cancel())))
yield* HttpServer.serveEffect(Effect.succeed(HttpServerResponse.raw(body, {
status,
contentType: "text/plain",
contentLength: 4
})))
const response = yield* (method === "HEAD" ? HttpClient.head("/") : HttpClient.get("/"))
assert.strictEqual(response.status, status)
assert.strictEqual(yield* response.text, "")
assert.strictEqual(cancelled, true)
if (method === "HEAD") {
assert.strictEqual(response.headers["content-length"], "4")
}
if (method === "HEAD" || status === 304) {
assert.strictEqual(response.headers["content-type"], "text/plain")
}
}).pipe(
Effect.timeout("2 seconds"),
Effect.provide(DenoHttpServer.layerTest)
), 5000)
}
})
describe("when the Response can't be built", () => {
it.live("answers 500 and preserves the header defect when raw body cancellation rejects", () =>
Effect.gen(function*() {
let cancelled = false
const body = new ReadableStream<Uint8Array>({
cancel() {
cancelled = true
return Promise.reject(new Error("cancellation failed"))
}
})
const observed = yield* Deferred.make<Exit.Exit<unknown, unknown>>()
yield* HttpServer.serveEffect(
Effect.succeed(HttpServerResponse.raw(body, { headers: { "x-invalid": "a\nb" } })),
(app) => Effect.onExit(app, (exit) => Deferred.succeed(observed, exit))
)
const response = yield* HttpClient.get("/")
assert.strictEqual(response.status, 500)
assert.strictEqual(yield* response.text, "")
assert.isTrue(cancelled)
const exit = yield* Deferred.await(observed)
assert(Exit.isFailure(exit))
assert.strictEqual(exit.cause.reasons.length, 1)
const reason = exit.cause.reasons[0]
assert(Cause.isDieReason(reason))
assert(reason.defect instanceof TypeError)
}).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
it.live("answers 500 and reports the status defect before stream scope cleanup completes", () =>
Effect.gen(function*() {
const finalized = yield* Latch.make()
const release = yield* Latch.make()
const observed = yield* Deferred.make<Exit.Exit<unknown, unknown>>()
yield* HttpServer.serveEffect(
Effect.gen(function*() {
yield* Effect.addFinalizer(() => finalized.open.pipe(Effect.andThen(release.await)))
return HttpServerResponse.stream(Stream.never, { status: 103 })
}),
(app) => Effect.onExit(app, (exit) => Deferred.succeed(observed, exit))
)
yield* Effect.addFinalizer(() => release.open)
const response = yield* HttpClient.get("/")
assert.strictEqual(response.status, 500)
assert.strictEqual(yield* response.text, "")
yield* finalized.await
const exit = yield* Deferred.await(observed)
assert(Exit.isFailure(exit))
assert.strictEqual(exit.cause.reasons.length, 1)
const reason = exit.cause.reasons[0]
assert(Cause.isDieReason(reason))
assert(reason.defect instanceof RangeError)
}).pipe(Effect.timeout("2 seconds"), Effect.provide(DenoHttpServer.layerTest)))
})
it.effect("schema", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"GET",
"/todos/:id",
Effect.flatMap(HttpRouter.schemaParams(IdParams), ({ id }) => todoResponse({ id, title: "test" }))
).pipe(HttpRouter.serve, Layer.build)
const todo = yield* HttpClient.get("/todos/1").pipe(
Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
)
assert.deepStrictEqual(todo, { id: 1, title: "test" })
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("exports a weak ETag generator", () =>
Effect.gen(function*() {
const generator = yield* Etag.Generator
const etag = yield* generator.fromFileWeb(new File(["test"], "test.txt", { lastModified: 0 }))
assert.strictEqual(etag._tag, "Weak")
}).pipe(Effect.provide(DenoHttpServer.layerHttpServices)))
it.effect("formData", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
const formData = yield* request.multipart
const part = formData.file
assert(typeof part !== "string")
const file = part[0]
assert(typeof file !== "string")
assert(file.path.endsWith("/test.txt"))
assert.strictEqual(file.contentType, "text/plain")
assert.strictEqual(yield* Effect.promise(() => Deno.readTextFile(file.path)), "test")
return yield* HttpServerResponse.json({ ok: "file" in formData })
})
).pipe(HttpRouter.serve, Layer.build)
const formData = new FormData()
formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
assert.deepStrictEqual(yield* response.json, { ok: true })
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("multipartStream", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
const parts = yield* Stream.runCollect(request.multipartStream)
assert.strictEqual(parts.length, 2)
const field = parts[0]
const file = parts[1]
assert(Multipart.isField(field))
assert.deepStrictEqual({ key: field.key, value: field.value }, { key: "name", value: "value" })
assert(Multipart.isFile(file))
assert.deepStrictEqual(
{ key: file.key, name: file.name, contentType: file.contentType },
{ key: "file", name: "test.txt", contentType: "text/plain" }
)
assert.strictEqual(new TextDecoder().decode(yield* file.contentEffect), "test")
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const formData = new FormData()
formData.append("name", "value")
formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
assert.strictEqual(response.status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyForm", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const files = yield* HttpServerRequest.schemaBodyForm(Schema.Struct({
file: Multipart.FilesSchema,
test: Schema.String
}))
assert("file" in files)
assert.strictEqual(files.test, "test")
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const formData = new FormData()
formData.append("file", new Blob(["test"], { type: "text/plain" }), "test.txt")
formData.append("test", "test")
const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
assert.strictEqual(response.status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("formData withMaxFileSize", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
yield* request.multipart
return HttpServerResponse.empty()
}).pipe(Effect.catchTag("MultipartError", (error) =>
error.reason._tag === "FileTooLarge"
? Effect.succeed(HttpServerResponse.empty({ status: 413 }))
: Effect.fail(error)))
).pipe(
HttpRouter.serve,
Layer.build,
Effect.provideService(Multipart.MaxFileSize, ByteSize.bytes(100))
)
const formData = new FormData()
formData.append("file", new Blob([new Uint8Array(1000)], { type: "text/plain" }), "test.txt")
const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
assert.strictEqual(response.status, 413)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("formData withMaxFieldSize", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
yield* request.multipart
return HttpServerResponse.empty()
}).pipe(Effect.catchTag("MultipartError", (error) =>
error.reason._tag === "FieldTooLarge"
? Effect.succeed(HttpServerResponse.empty({ status: 413 }))
: Effect.fail(error)))
).pipe(
HttpRouter.serve,
Layer.build,
Effect.provideService(Multipart.MaxFieldSize, ByteSize.bytes(100))
)
const formData = new FormData()
formData.append("file", "x".repeat(1000))
const response = yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })
assert.strictEqual(response.status, 413)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("mountApp", () =>
Effect.gen(function*() {
const child = Effect.map(HttpServerRequest.HttpServerRequest, (_) => HttpServerResponse.text(_.url))
yield* HttpRouter.use((router) => router.prefixed("/child").add("*", "*", child)).pipe(
HttpRouter.serve,
Layer.build
)
assert.strictEqual(yield* HttpClient.get("/child/1").pipe(Effect.flatMap((_) => _.text)), "/1")
assert.strictEqual(yield* HttpClient.get("/child").pipe(Effect.flatMap((_) => _.text)), "/")
assert.strictEqual(yield* HttpClient.get("/child?foo=bar").pipe(Effect.flatMap((_) => _.text)), "/?foo=bar")
assert.strictEqual(yield* HttpClient.get("/child/").pipe(Effect.flatMap((_) => _.text)), "/")
assert.strictEqual(
yield* HttpClient.get("/child1/", { urlParams: { foo: "bar" } }).pipe(Effect.map((_) => _.status)),
404
)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("returns 413 for a body over MaxBodySize", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/body",
HttpServerRequest.HttpServerRequest.use((request) => Effect.as(request.text, HttpServerResponse.empty())).pipe(
Effect.provideService(HttpIncomingMessage.MaxBodySize, ByteSize.bytes(4))
)
).pipe(HttpRouter.serve, Layer.build)
const response = yield* HttpClient.post("/body", { body: HttpBody.text("12345") })
assert.strictEqual(response.status, 413)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("answers CONNECT with 501 without running the app", () =>
Effect.gen(function*() {
let calls = 0
yield* HttpRouter.add(
"*",
"*",
Effect.sync(() => {
calls++
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
// fetch cannot send CONNECT.
const statusLine = yield* Effect.acquireUseRelease(
Effect.promise(() => Deno.connect({ hostname: "127.0.0.1", port })),
(conn) =>
Effect.promise(async () => {
await conn.write(
new TextEncoder().encode("CONNECT example.test:443 HTTP/1.1\r\nHost: example.test:443\r\n\r\n")
)
const decoder = new TextDecoder()
const buffer = new Uint8Array(1024)
let received = ""
while (!received.includes("\r\n")) {
const read = await conn.read(buffer)
if (read === null) break
received += decoder.decode(buffer.subarray(0, read), { stream: true })
}
return received.split("\r\n")[0]
}),
(conn) => Effect.sync(() => conn.close())
)
assert.strictEqual(statusLine.split(" ")[1], "501")
assert.strictEqual(calls, 0)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("file", () =>
Effect.gen(function*() {
yield* (yield* HttpServerResponse.file(fixture).pipe(
Effect.updateService(HttpPlatform.HttpPlatform, (_) => ({
..._,
fileResponse: (path, options) =>
Effect.map(_.fileResponse(path, options), (response) => {
;(response as any).headers.etag = "\"etag\""
return response
})
}))
)).pipe(Effect.succeed, HttpServer.serveEffect())
const response = yield* HttpClient.get("/", {
headers: { "accept-encoding": "identity" }
})
assert.strictEqual(response.status, 200)
assert.strictEqual(response.headers["content-type"], "text/plain; charset=UTF-8")
assert.strictEqual(response.headers.etag, "\"etag\"")
assert.strictEqual((yield* response.text).trim(), "lorem ipsum dolar sit amet")
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("fileWeb", () =>
Effect.gen(function*() {
const now = new Date()
const file = new File([new TextEncoder().encode("test")], "test.txt", {
type: "text/plain",
lastModified: now.getTime()
})
yield* HttpServerResponse.fileWeb(file).pipe(
Effect.updateService(HttpPlatform.HttpPlatform, (_) => ({
..._,
fileWebResponse: (file, options) =>
Effect.map(_.fileWebResponse(file, options), (response) => ({
...response,
headers: { ...response.headers, etag: "W/\"etag\"" }
}))
})),
HttpServer.serveEffect()
)
const response = yield* HttpClient.get("/")
assert.strictEqual(response.status, 200)
assert.strictEqual(response.headers["content-type"], "text/plain")
assert.strictEqual(response.headers["last-modified"], now.toUTCString())
assert.strictEqual(response.headers.etag, "W/\"etag\"")
assert.strictEqual(yield* response.text, "test")
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyUrlParams", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/todos",
Effect.flatMap(
HttpServerRequest.schemaBodyUrlParams(Schema.Struct({
id: Schema.FiniteFromString,
title: Schema.String
})),
({ id, title }) => todoResponse({ id, title })
)
).pipe(HttpRouter.serve, Layer.build)
const todo = yield* HttpClientRequest.post("/todos").pipe(
HttpClientRequest.bodyUrlParams({ id: "1", title: "test" }),
HttpClient.execute,
Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
)
assert.deepStrictEqual(todo, { id: 1, title: "test" })
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyUrlParams error", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"GET",
"/todos",
Effect.flatMap(
HttpServerRequest.schemaBodyUrlParams(Schema.Struct({
id: Schema.FiniteFromString,
title: Schema.String
})),
({ id, title }) => todoResponse({ id, title })
).pipe(Effect.catchTag("SchemaError", (error) =>
Effect.succeed(HttpServerResponse.jsonUnsafe({ error }, { status: 400 }))))
).pipe(HttpRouter.serve, Layer.build)
assert.strictEqual((yield* HttpClient.get("/todos")).status, 400)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyFormJson", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
assert.strictEqual(result.test, "content")
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const formData = new FormData()
formData.append("json", JSON.stringify({ test: "content" }))
assert.strictEqual((yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })).status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyFormJson file", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
assert.strictEqual(result.test, "content")
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const formData = new FormData()
formData.append(
"json",
new Blob([JSON.stringify({ test: "content" })], { type: "application/json" }),
"test.json"
)
assert.strictEqual((yield* HttpClient.post("/upload", { body: HttpBody.formData(formData) })).status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("schemaBodyFormJson url encoded", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"POST",
"/upload",
Effect.gen(function*() {
const result = yield* HttpServerRequest.schemaBodyFormJson(Schema.Struct({ test: Schema.String }))("json")
assert.strictEqual(result.test, "content")
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const response = yield* HttpClient.post("/upload", {
body: HttpBody.urlParams(UrlParams.fromInput({ json: JSON.stringify({ test: "content" }) }))
})
assert.strictEqual(response.status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("tracing", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"GET",
"/",
Effect.flatMap(Effect.currentSpan, (_) => HttpServerResponse.json({ spanId: _.spanId, parent: _.parent }))
).pipe(HttpRouter.serve, Layer.build)
const requestSpan = yield* Effect.makeSpan("client request")
const body = yield* HttpClient.get("/").pipe(
Effect.flatMap((response) => response.json),
Effect.provideService(
Tracer.Tracer,
Tracer.make({
span(options) {
assert.strictEqual(options.name, "GET")
assert.strictEqual(options.kind, "client")
assert(options.parent._tag === "Some")
if (options.parent.value._tag !== "Span") throw new Error("Expected span parent")
assert.strictEqual(options.parent.value.name, "request parent")
return requestSpan
}
})
),
Effect.withSpan("request parent"),
Effect.repeat({ times: 2 })
)
assert.strictEqual((body as any).parent._tag, "Some")
assert.strictEqual((body as any).parent.value.spanId, requestSpan.spanId)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("html", () =>
Effect.gen(function*() {
yield* HttpRouter.addAll([
HttpRouter.route("GET", "/home", HttpServerResponse.html("<html />")),
HttpRouter.route(
"GET",
"/about",
HttpServerResponse.html`<html>${Effect.succeed("<body />")}</html>`
),
HttpRouter.route(
"GET",
"/stream",
HttpServerResponse.htmlStream`<html>${Stream.make("<body />", 123, "hello")}</html>`
)
]).pipe(HttpRouter.serve, Layer.build)
assert.strictEqual(yield* HttpClient.get("/home").pipe(Effect.flatMap((_) => _.text)), "<html />")
assert.strictEqual(yield* HttpClient.get("/about").pipe(Effect.flatMap((_) => _.text)), "<html><body /></html>")
assert.strictEqual(
yield* HttpClient.get("/stream").pipe(Effect.flatMap((_) => _.text)),
"<html><body />123hello</html>"
)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("setCookie", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"GET",
"/home",
HttpServerResponse.empty().pipe(
HttpServerResponse.setCookieUnsafe("test", "value"),
HttpServerResponse.setCookieUnsafe("test2", "value2", {
httpOnly: true,
secure: true,
sameSite: "lax",
partitioned: true,
path: "/",
domain: "example.com",
expires: new Date(2022, 1, 1),
maxAge: "5 minutes"
})
)
).pipe(HttpRouter.serve, Layer.build)
const response = yield* HttpClient.get("/home")
assert.deepStrictEqual(
response.cookies.toJSON(),
Cookies.fromReadonlyRecord({
test: Cookies.makeCookieUnsafe("test", "value"),
test2: Cookies.makeCookieUnsafe("test2", "value2", {
httpOnly: true,
secure: true,
sameSite: "lax",
partitioned: true,
path: "/",
domain: "example.com",
expires: new Date(2022, 1, 1),
maxAge: Duration.minutes(5)
})
}).toJSON()
)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.live("uninterruptible routes", () =>
Effect.gen(function*() {
yield* HttpRouter.add(
"GET",
"/home",
Effect.gen(function*() {
const fiber = Fiber.getCurrent()!
setTimeout(() => fiber.interruptUnsafe(fiber.id), 10)
yield* Effect.sleep(50)
return HttpServerResponse.empty()
}),
{ uninterruptible: true }
).pipe(HttpRouter.serve, Layer.build)
assert.strictEqual((yield* HttpClient.get("/home")).status, 204)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.live("disposes after a client aborts a handler awaiting an upstream request", () =>
Effect.gen(function*() {
const upstreamStarted = Latch.makeUnsafe()
const upstream = yield* Effect.acquireRelease(
Effect.sync(() => {
const controller = new AbortController()
const server = Deno.serve(
{ hostname: "127.0.0.1", port: 0, onListen: () => {}, signal: controller.signal },
(request) => {
upstreamStarted.openUnsafe()
return new Promise<Response>((resolve) => {
request.signal.addEventListener("abort", () => resolve(new Response()), { once: true })
controller.signal.addEventListener("abort", () => resolve(new Response()), { once: true })
})
}
)
return { controller, server }
}),
({ controller, server }) =>
Effect.sync(() => controller.abort()).pipe(Effect.andThen(Effect.promise(() => server.finished)))
)
const upstreamPort = (upstream.server.addr as Deno.NetAddr).port
const router = HttpRouter.use((router) =>
router.add(
"GET",
"/",
Effect.gen(function*() {
yield* HttpClient.head(`http://127.0.0.1:${upstreamPort}`)
return HttpServerResponse.empty()
})
)
)
const serverLayer = DenoHttpServer.layer({
hostname: "127.0.0.1",
port: 0,
onListen: () => {},
gracefulShutdownTimeout: "100 millis"
})
const services = Layer.merge(serverLayer, FetchHttpClient.layer)
const runtime = yield* Effect.acquireRelease(
Effect.sync(() =>
ManagedRuntime.make(Layer.merge(
services,
HttpRouter.serve(router).pipe(Layer.provide(services))
))
),
(runtime) => Effect.promise(() => runtime.dispose())
)
yield* Effect.promise(() => runtime.context())
const downstreamServer = yield* Effect.promise(() => runtime.runPromise(HttpServer.HttpServer))
const downstreamPort = (downstreamServer.address as NetAddress.InetAddress).port
const controller = new AbortController()
const downstream = fetch(`http://127.0.0.1:${downstreamPort}`, {
signal: controller.signal
}).catch(() => undefined)
yield* upstreamStarted.await
controller.abort()
yield* Effect.promise(() => downstream)
const disposed = yield* Effect.promise(() => runtime.dispose()).pipe(Effect.timeoutOption("2 seconds"))
assert.strictEqual(disposed._tag, "Some")
}))
describe("HttpServerRespondable", () => {
it.effect("error/schema", () =>
Effect.gen(function*() {
class CustomError extends Schema.Error<CustomError>("CustomError")({
_tag: Schema.tag("CustomError"),
name: Schema.String
}) {
[HttpServerRespondable.symbol]() {
return HttpServerResponse.schemaJson(CustomError)(this, { status: 599 })
}
}
yield* HttpRouter.add("GET", "/home", new CustomError({ name: "test" })).pipe(
HttpRouter.serve,
Layer.build
)
const response = yield* HttpClient.get("/home")
assert.strictEqual(response.status, 599)
assert.deepStrictEqual(
yield* HttpClientResponse.schemaBodyJson(CustomError)(response),
new CustomError({ name: "test" })
)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("httpapi error", () =>
Effect.gen(function*() {
yield* HttpRouter.add("GET", "/home", new HttpApiError.BadRequest({})).pipe(
HttpRouter.serve,
Layer.build
)
assert.strictEqual((yield* HttpClient.get("/home")).status, 400)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
})
it.effect("takes the host header from the HTTP/2 authority", () =>
Effect.gen(function*() {
yield* HttpServer.serveEffect(
HttpServerRequest.HttpServerRequest.use((request) =>
Effect.succeed(HttpServerResponse.text(
`${request.headers.host} ${Option.getOrThrow(HttpServerRequest.toURL(request)).href}`
))
)
)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
for (const host of [undefined, "client.test"]) {
assert.strictEqual(
yield* http2Get(port, { ":path": "/info", ":authority": "example.test:4573", host }),
"example.test:4573 http://example.test:4573/info"
)
}
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
// Deno 2.8.3 to 2.9.2 panic when a cancelled HTTP/2 request is answered (denoland/deno#36053).
it.live("keeps serving after an HTTP/2 client cancels a request in flight", () =>
Effect.gen(function*() {
const started = Latch.makeUnsafe()
const interrupted = Latch.makeUnsafe()
yield* HttpRouter.use((router) =>
Effect.andThen(
router.add(
"GET",
"/slow",
Effect.andThen(started.open, Effect.never).pipe(Effect.onInterrupt(() => interrupted.open))
),
router.add("GET", "/", Effect.succeed(HttpServerResponse.text("ok")))
)
).pipe(HttpRouter.serve, Layer.build)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
yield* Effect.acquireUseRelease(
Effect.sync(() => Http2.connect(`http://127.0.0.1:${port}`)),
(session) =>
Effect.gen(function*() {
const stream = session.request({ ":path": "/slow" }).end()
stream.on("error", () => {})
yield* started.await
stream.close(Http2.constants.NGHTTP2_CANCEL)
yield* interrupted.await
}),
(session) => Effect.sync(() => session.destroy())
)
assert.strictEqual(yield* http2Get(port, { ":path": "/" }), "ok")
}).pipe(
Effect.timeout("2 seconds"),
Effect.provide(DenoHttpServer.layerTest)
), 5000)
it.effect("excludes a query from the host of an absolute-form HTTP/1.1 target", () =>
Effect.gen(function*() {
yield* HttpServer.serveEffect(
HttpServerRequest.HttpServerRequest.use((request) =>
Effect.succeed(HttpServerResponse.text(request.headers.host))
)
)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const host = yield* Effect.callback<string, Error>((resume) => {
const request = Http.get({
hostname: "127.0.0.1",
port,
path: "http://Target.TEST:80?q=/info",
headers: { host: "client.test" }
}, (response) => {
let body = ""
response.setEncoding("utf8")
response.on("data", (chunk: string) => {
body += chunk
})
response.on("end", () => resume(Effect.succeed(body)))
response.on("error", (error) => resume(Effect.fail(error)))
})
request.on("error", (error) => resume(Effect.fail(error)))
return Effect.sync(() => {
request.destroy()
})
})
assert.strictEqual(host, "Target.TEST:80")
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("RouterConfig", () =>
Effect.gen(function*() {
yield* HttpRouter.add("GET", "/:param", Effect.succeed(HttpServerResponse.empty())).pipe(
HttpRouter.serve,
Layer.build
)
assert.strictEqual((yield* HttpClient.get("/123456")).status, 404)
assert.strictEqual((yield* HttpClient.get("/12345")).status, 204)
}).pipe(
Effect.provide([
DenoHttpServer.layerTest,
Layer.succeed(HttpRouter.RouterConfig)({ maxParamLength: 5 })
])
))
it.effect("HttpRouter prefixed", () =>
Effect.gen(function*() {
const handler = HttpRouter.serve(HttpRouter.use(Effect.fnUntraced(function*(router_) {
const router = router_.prefixed("/todos")
yield* router.add(
"GET",
"/:id",
Effect.flatMap(HttpRouter.schemaParams(IdParams), ({ id }) => todoResponse({ id, title: "test" }))
)
yield* router.addAll([
HttpRouter.route("GET", "/", Effect.succeed(HttpServerResponse.text("root")))
])
})))
yield* Layer.build(handler)
assert.deepStrictEqual(
yield* HttpClient.get("/todos/1").pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))),
{ id: 1, title: "test" }
)
assert.strictEqual(yield* HttpClient.get("/todos").pipe(Effect.flatMap((_) => _.text)), "root")
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("cancels a file body for HEAD requests", () =>
Effect.gen(function*() {
let cancelled = false
const fileResponse = yield* HttpServerResponse.file(fixture).pipe(
Effect.updateService(HttpPlatform.HttpPlatform, (platform) => ({
...platform,
fileResponse: (path, options) =>
Effect.map(platform.fileResponse(path, options), (response) => {
assert.strictEqual(response.body._tag, "Raw")
const source = (response.body as HttpBody.Raw).body
assert(source instanceof ReadableStream)
const reader = source.getReader()
const body = new ReadableStream<Uint8Array>({
pull(controller) {
return reader.read().then(({ done, value }) => {
if (done) controller.close()
else controller.enqueue(value)
})
},
cancel(reason) {
cancelled = true
return reader.cancel(reason)
}
})
return HttpServerResponse.raw(body, {
status: response.status,
statusText: response.statusText,
headers: response.headers,
cookies: response.cookies
})
})
}))
)
yield* fileResponse.pipe(
Effect.succeed,
HttpServer.serveEffect()
)
const response = yield* HttpClient.head("/")
assert.strictEqual(response.status, 200)
assert(cancelled)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("ignores cancellation errors for HEAD response bodies", () => {
const body = new ReadableStream<Uint8Array>()
const reader = body.getReader()
return Effect.gen(function*() {
yield* HttpServerResponse.raw(body).pipe(
Effect.succeed,
HttpServer.serveEffect()
)
const response = yield* HttpClient.head("/")
assert.strictEqual(response.status, 200)
}).pipe(
Effect.ensuring(Effect.sync(() => reader.releaseLock())),
Effect.provide(DenoHttpServer.layerTest)
)
})
it.effect("round trips WebSocket frames and closes cleanly", () =>
Effect.gen(function*() {
const logged = yield* Deferred.make<unknown>()
const logger = Logger.make((options) => {
const annotations = options.fiber.getRef(References.CurrentLogAnnotations)
if (annotations["http.url"] === "/") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"]))
})
yield* serveWebSocket(echoWebSocket).pipe(Effect.provide(Logger.layer([logger])))
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/`, (socket) => socket.send("hello"), 1)
assert.deepStrictEqual(messages, ["hello"])
assert.strictEqual(yield* Deferred.await(logged), 101)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("logs status 101 for a WebSocket upgraded through a prefixed route", () =>
Effect.gen(function*() {
const logged = yield* Deferred.make<unknown>()
const logger = Logger.make((options) => {
const annotations = options.fiber.getRef(References.CurrentLogAnnotations)
if (annotations["http.url"] === "/ws") Deferred.doneUnsafe(logged, Effect.succeed(annotations["http.status"]))
})
yield* HttpRouter.use((router) =>
router.prefixed("/ws").add(
"GET",
"/",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
yield* echoWebSocket(yield* request.upgrade)
return HttpServerResponse.empty()
})
)
).pipe(HttpRouter.serve, Layer.provide(Logger.layer([logger])), Layer.build)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/ws`, (socket) => socket.send("hello"), 1)
assert.deepStrictEqual(messages, ["hello"])
assert.strictEqual(yield* Deferred.await(logged), 101)
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("fails upgrades to protocols other than WebSocket", () =>
Effect.gen(function*() {
// Deno.serve answers upgrade requests with a body method with 400 itself
yield* HttpRouter.add(
"GET",
"/attach",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
const error = yield* Effect.flip(request.upgrade)
return HttpServerResponse.text(error.reason.message, { status: 501 })
})
).pipe(HttpRouter.serve, Layer.build)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
// Deno's fetch sends the upgrade headers that the Effect fetch client refuses
const response = yield* Effect.promise(() =>
fetch(`http://127.0.0.1:${port}/attach`, { headers: { connection: "Upgrade", upgrade: "tcp" } })
)
assert.strictEqual(response.status, 501)
assert.include(yield* Effect.promise(() => response.text()), "Deno.serve only supports WebSocket upgrades")
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("preserves eager WebSocket frames across an async boundary", () =>
Effect.gen(function*() {
yield* serveWebSocket((socket) =>
Effect.promise(() => new Promise<void>((resolve) => setTimeout(resolve, 0))).pipe(
Effect.andThen(echoWebSocket(socket))
)
)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const messages = yield* connectWebSocket(`ws://127.0.0.1:${port}/`, (socket) => {
socket.send("first")
socket.send("second")
}, 2)
assert.deepStrictEqual(messages, ["first", "second"])
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
it.effect("delivers binary WebSocket frames as Uint8Array", () =>
Effect.gen(function*() {
const received = yield* Queue.unbounded<Uint8Array>()
yield* serveWebSocket((socket) =>
Effect.gen(function*() {
const { pull } = yield* socket.reader
while (true) {
const chunk = yield* pull
for (const message of chunk) {
assert(message instanceof Uint8Array)
yield* Queue.offer(received, message)
}
}
}).pipe(
Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
Effect.orDie
)
)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const socket = yield* openWebSocket(`ws://127.0.0.1:${port}/`)
socket.send(new Uint8Array([1, 2, 3]))
assert.deepStrictEqual(yield* Queue.take(received), new Uint8Array([1, 2, 3]))
socket.close()
}).pipe(Effect.provide(DenoHttpServer.layerTest)))
})
const echoWebSocket = (socket: Socket.Socket) =>
Effect.gen(function*() {
const writer = yield* socket.writer
const { pull } = yield* socket.reader
while (true) {
yield* writer.writeAll(yield* pull)
}
}).pipe(
Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
Effect.orDie
)
const serveWebSocket = (
run: (socket: Socket.Socket) => Effect.Effect<void, Socket.SocketError, Scope.Scope>
) =>
HttpRouter.add(
"GET",
"/",
Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
const socket = yield* request.upgrade
yield* run(socket)
return HttpServerResponse.empty()
})
).pipe(HttpRouter.serve, Layer.build)
const openWebSocket = (url: string) =>
Effect.acquireRelease(
Effect.callback<WebSocket, Error>((resume) => {
const socket = new WebSocket(url)
socket.addEventListener("open", () => resume(Effect.succeed(socket)), { once: true })
socket.addEventListener("error", () => resume(Effect.fail(new Error("WebSocket connection failed"))), {
once: true
})
}),
(socket) => Effect.sync(() => socket.close())
)
const connectWebSocket = (url: string, onOpen: (socket: WebSocket) => void, messageCount: number) =>
Effect.acquireUseRelease(
openWebSocket(url),
(socket) =>
Effect.gen(function*() {
const messages: Array<string> = []
const fiber = yield* Effect.callback<void, Error>((resume) => {
socket.addEventListener("message", (event) => {
messages.push(event.data)
if (messages.length === messageCount) resume(Effect.void)
})
socket.addEventListener("error", () => resume(Effect.fail(new Error("WebSocket connection failed"))), {
once: true
})
onOpen(socket)
}).pipe(Effect.forkChild)
yield* Fiber.join(fiber)
return messages
}),
(socket) => Effect.sync(() => socket.close())
)