Merge commit '3c60637c1a27da8ba66888de518d58d5707801f2' as 'repos/effect-smol'
This commit is contained in:
-Puter
@@ -0,0 +1,683 @@
|
||||
import { assert, describe, it } from "@effect/vitest"
|
||||
import { strictEqual } from "@effect/vitest/utils"
|
||||
import { Cause, Effect, Schema, Stream } from "effect"
|
||||
import { Sse } from "effect/unstable/encoding"
|
||||
import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
|
||||
import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi"
|
||||
|
||||
describe("HttpApiClient", () => {
|
||||
describe("streaming responses", () => {
|
||||
it.effect("decodes StreamSse events incrementally", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(
|
||||
textStream([
|
||||
"event: first\ndata: one\n\n",
|
||||
"event: second\ndata: two\n\n"
|
||||
]),
|
||||
{ status: 200 }
|
||||
)
|
||||
)
|
||||
})
|
||||
|
||||
const stream = yield* client.test.events({})
|
||||
const first = yield* stream.pipe(Stream.take(1), Stream.runCollect)
|
||||
assert.deepStrictEqual(first, [{ event: "first", data: "one" }])
|
||||
}))
|
||||
|
||||
it.effect("keeps StreamSse parser state isolated between responses", () =>
|
||||
Effect.gen(function*() {
|
||||
const bodies = [
|
||||
"event: first\ndata: one\n\n",
|
||||
"event: second\ndata: two\n\n"
|
||||
]
|
||||
let index = 0
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() => new Response(textStream([bodies[index++]!]), { status: 200 }))
|
||||
})
|
||||
|
||||
const first = yield* client.test.events({}).pipe(Effect.flatMap(Stream.runCollect))
|
||||
const second = yield* client.test.events({}).pipe(Effect.flatMap(Stream.runCollect))
|
||||
|
||||
assert.deepStrictEqual(first, [{ event: "first", data: "one" }])
|
||||
assert.deepStrictEqual(second, [{ event: "second", data: "two" }])
|
||||
}))
|
||||
|
||||
it.effect("decodes StreamSse reserved failure events as full causes", () =>
|
||||
Effect.gen(function*() {
|
||||
const expectedCause = Cause.fail({ reason: "boom" })
|
||||
const FailureSchema = Schema.toCodecJson(Schema.Cause(StreamError, Schema.Defect()))
|
||||
const encodeCause = Schema.encodeUnknownEffect(Schema.fromJsonString(FailureSchema))
|
||||
const encodedCause = yield* encodeCause(expectedCause)
|
||||
const failureEvent = Sse.encoder.write({
|
||||
_tag: "Event",
|
||||
event: "effect/httpapi/stream/failure",
|
||||
id: undefined,
|
||||
data: encodedCause
|
||||
})
|
||||
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() => new Response(textStream([failureEvent]), { status: 200 }))
|
||||
})
|
||||
|
||||
const stream = yield* client.test.events({})
|
||||
const exit = yield* Effect.exit(Stream.runCollect(stream))
|
||||
|
||||
assert.strictEqual(exit._tag, "Failure")
|
||||
if (exit._tag === "Failure") {
|
||||
assert.deepStrictEqual(exit.cause, expectedCause)
|
||||
}
|
||||
}))
|
||||
|
||||
it.effect("emits StreamSse reserved names with non-Cause data as user events", () =>
|
||||
Effect.gen(function*() {
|
||||
const failureEvent = Sse.encoder.write({
|
||||
_tag: "Event",
|
||||
event: "effect/httpapi/stream/failure",
|
||||
id: undefined,
|
||||
data: "not-json"
|
||||
})
|
||||
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() => new Response(textStream([failureEvent]), { status: 200 }))
|
||||
})
|
||||
|
||||
const stream = yield* client.test.events({})
|
||||
const events = yield* Stream.runCollect(stream)
|
||||
|
||||
assert.deepStrictEqual(events, [{
|
||||
event: "effect/httpapi/stream/failure",
|
||||
data: "not-json"
|
||||
}])
|
||||
}))
|
||||
|
||||
it.effect("returns StreamUint8Array response bytes incrementally", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(byteStream([new Uint8Array([1, 2]), new Uint8Array([3])]), { status: 200 })
|
||||
)
|
||||
})
|
||||
|
||||
const stream = yield* client.test.download({})
|
||||
const first = yield* stream.pipe(Stream.take(1), Stream.runCollect)
|
||||
assert.deepStrictEqual(first.map((chunk) => Array.from(chunk)), [[1, 2]])
|
||||
}))
|
||||
|
||||
it.effect("decodes StreamSse successes at the annotated status", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(AnnotatedStreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(textStream(["event: annotated\ndata: ok\n\n"]), { status: 202 })
|
||||
)
|
||||
})
|
||||
|
||||
const stream = yield* client.test.events({})
|
||||
const events = yield* Stream.runCollect(stream)
|
||||
assert.deepStrictEqual(events, [{ event: "annotated", data: "ok" }])
|
||||
}))
|
||||
|
||||
it.effect("decodes StreamUint8Array successes at the annotated status", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(AnnotatedStreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() => new Response(byteStream([new Uint8Array([4, 5])]), { status: 206 }))
|
||||
})
|
||||
|
||||
const stream = yield* client.test.download({})
|
||||
const chunks = yield* Stream.runCollect(stream)
|
||||
assert.deepStrictEqual(chunks.map((chunk) => Array.from(chunk)), [[4, 5]])
|
||||
}))
|
||||
|
||||
it.effect("decodes non-success responses through endpoint error schemas before returning a stream", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(JSON.stringify({ _tag: "EndpointError", message: "bad request" }), {
|
||||
status: 400,
|
||||
headers: { "content-type": "application/json" }
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
const error = yield* Effect.flip(client.test.events({}))
|
||||
assert.deepStrictEqual(error, new EndpointError({ message: "bad request" }))
|
||||
}))
|
||||
|
||||
it.effect("preserves response-only raw response stream access", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(StreamingApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(
|
||||
byteStream([
|
||||
new Uint8Array([1]),
|
||||
new Uint8Array([2, 3])
|
||||
]),
|
||||
{ status: 200 }
|
||||
)
|
||||
)
|
||||
})
|
||||
|
||||
const response = yield* client.test.download({ responseMode: "response-only" })
|
||||
const chunks = yield* Stream.runCollect(response.stream)
|
||||
assert.deepStrictEqual(chunks.map((chunk) => Array.from(chunk)), [[1], [2, 3]])
|
||||
}))
|
||||
|
||||
it.effect("selects a buffered response by content type when a stream uses the same status", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(MixedSuccessApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(JSON.stringify({ message: "done" }), {
|
||||
status: 200,
|
||||
headers: { "content-type": "application/json" }
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
const response = yield* client.test.chat({})
|
||||
assert.deepStrictEqual(response, { message: "done" })
|
||||
}))
|
||||
|
||||
it.effect("selects a stream response by content type when buffered success uses the same status", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* HttpApiClient.makeWith(MixedSuccessApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(() =>
|
||||
new Response(textStream([`event: token\ndata: {"text":"hello"}\n\n`]), {
|
||||
status: 200,
|
||||
headers: { "content-type": "text/event-stream; charset=utf-8" }
|
||||
})
|
||||
)
|
||||
})
|
||||
|
||||
const stream = yield* client.test.chat({})
|
||||
if (!Stream.isStream(stream)) {
|
||||
throw new Error("Expected stream response")
|
||||
}
|
||||
const events = yield* Stream.runCollect(stream)
|
||||
assert.deepStrictEqual(events, [{ text: "hello" }])
|
||||
}))
|
||||
})
|
||||
|
||||
describe("error responses", () => {
|
||||
const makeClient = (response: () => Response) =>
|
||||
HttpApiClient.makeWith(ErrorContentTypeApi, {
|
||||
baseUrl: "http://test",
|
||||
httpClient: clientFromResponse(response)
|
||||
})
|
||||
|
||||
it.effect("selects schemas by normalized content type regardless of declaration order", () =>
|
||||
Effect.gen(function*() {
|
||||
for (const endpoint of ["textFirst", "jsonFirst"] as const) {
|
||||
const jsonClient = yield* makeClient(() =>
|
||||
new Response(JSON.stringify({ _tag: "JsonError", message: "bad request" }), {
|
||||
status: 400,
|
||||
headers: { "content-type": "Application/JSON; charset=utf-8" }
|
||||
})
|
||||
)
|
||||
const jsonError = yield* Effect.flip(jsonClient.test[endpoint]({}))
|
||||
assert.deepStrictEqual(jsonError, { _tag: "JsonError", message: "bad request" })
|
||||
|
||||
const textClient = yield* makeClient(() =>
|
||||
new Response("bad request", {
|
||||
status: 400,
|
||||
headers: { "content-type": "text/plain" }
|
||||
})
|
||||
)
|
||||
const textError = yield* Effect.flip(textClient.test[endpoint]({}))
|
||||
assert.strictEqual(textError, "bad request")
|
||||
}
|
||||
}))
|
||||
|
||||
it.effect("reports unsupported error response content types", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* makeClient(() =>
|
||||
new Response("<error />", {
|
||||
status: 400,
|
||||
headers: { "content-type": "application/xml" }
|
||||
})
|
||||
)
|
||||
|
||||
const exit = yield* Effect.exit(client.test.textFirst({}))
|
||||
assert.strictEqual(exit._tag, "Failure")
|
||||
if (exit._tag === "Failure") {
|
||||
const errors: Array<unknown> = []
|
||||
for (const reason of exit.cause.reasons) {
|
||||
if (Cause.isFailReason(reason)) {
|
||||
errors.push(reason.error)
|
||||
}
|
||||
}
|
||||
assert.ok(
|
||||
errors.some((error) => HttpClientError.isHttpClientError(error) && error.reason._tag === "StatusCodeError")
|
||||
)
|
||||
const decodeError = errors.find((error) =>
|
||||
HttpClientError.isHttpClientError(error) && error.reason._tag === "DecodeError"
|
||||
)
|
||||
assert.ok(HttpClientError.isHttpClientError(decodeError))
|
||||
assert.strictEqual(decodeError.reason._tag, "DecodeError")
|
||||
assert.ok(decodeError.reason.description?.includes("Unsupported response content-type"))
|
||||
}
|
||||
}))
|
||||
|
||||
it.effect("decodes no-content errors without a content-type header", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* makeClient(() => new Response(null, { status: 400 }))
|
||||
|
||||
const error = yield* Effect.flip(client.test.noContent({}))
|
||||
assert.strictEqual(error, "NoContentError")
|
||||
}))
|
||||
|
||||
it.effect("groups schemas by normalized declared content type", () =>
|
||||
Effect.gen(function*() {
|
||||
const client = yield* makeClient(() =>
|
||||
new Response(JSON.stringify({ _tag: "SecondJsonError", message: "bad request" }), {
|
||||
status: 400,
|
||||
headers: { "content-type": "application/problem+json" }
|
||||
})
|
||||
)
|
||||
|
||||
const error = yield* Effect.flip(client.test.equivalentJson({}))
|
||||
assert.deepStrictEqual(error, { _tag: "SecondJsonError", message: "bad request" })
|
||||
}))
|
||||
})
|
||||
|
||||
describe("urlBuilder", () => {
|
||||
const Api = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("users")
|
||||
.add(
|
||||
HttpApiEndpoint.get("getUser", "/users/:id", {
|
||||
params: {
|
||||
id: Schema.Finite
|
||||
},
|
||||
query: {
|
||||
page: Schema.Finite,
|
||||
tags: Schema.Array(Schema.Finite)
|
||||
}
|
||||
}),
|
||||
HttpApiEndpoint.get("health", "/health")
|
||||
)
|
||||
)
|
||||
|
||||
it("builds urls using endpoint schemas", () => {
|
||||
const builder = HttpApiClient.urlBuilder(Api, {
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
strictEqual(
|
||||
builder.users.getUser({
|
||||
params: {
|
||||
id: 123
|
||||
},
|
||||
query: {
|
||||
page: 1,
|
||||
tags: [1, 2]
|
||||
}
|
||||
}),
|
||||
"https://api.example.com/users/123?page=1&tags=1&tags=2"
|
||||
)
|
||||
})
|
||||
|
||||
it("encodes path parameters", () => {
|
||||
const Api = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("stacks")
|
||||
.add(
|
||||
HttpApiEndpoint.get("listResources", "/state/stacks/:stack/stages/:stage/resources", {
|
||||
params: {
|
||||
stack: Schema.String,
|
||||
stage: Schema.String
|
||||
}
|
||||
})
|
||||
)
|
||||
)
|
||||
const builder = HttpApiClient.urlBuilder(Api, {
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
strictEqual(
|
||||
builder.stacks.listResources({
|
||||
params: {
|
||||
stack: "a/b",
|
||||
stage: "prod/blue"
|
||||
}
|
||||
}),
|
||||
"https://api.example.com/state/stacks/a%2Fb/stages/prod%2Fblue/resources"
|
||||
)
|
||||
})
|
||||
|
||||
it("omits missing optional path parameters", () => {
|
||||
const Api = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("files")
|
||||
.add(
|
||||
HttpApiEndpoint.get("download", "/files/:path?", {
|
||||
params: {
|
||||
path: Schema.optional(Schema.String)
|
||||
}
|
||||
})
|
||||
)
|
||||
)
|
||||
const builder = HttpApiClient.urlBuilder(Api, {
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
strictEqual(
|
||||
builder.files.download({ params: {} }),
|
||||
"https://api.example.com/files"
|
||||
)
|
||||
strictEqual(
|
||||
builder.files.download({ params: { path: "a/b" } }),
|
||||
"https://api.example.com/files/a%2Fb"
|
||||
)
|
||||
})
|
||||
|
||||
it("returns relative urls when baseUrl is omitted", () => {
|
||||
const builder = HttpApiClient.urlBuilder(Api)
|
||||
|
||||
strictEqual(builder.users.health(), "/health")
|
||||
})
|
||||
|
||||
it("supports top-level endpoints", () => {
|
||||
const TopLevelApi = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("top", { topLevel: true })
|
||||
.add(
|
||||
HttpApiEndpoint.get("health", "/health")
|
||||
)
|
||||
)
|
||||
.prefix("/v1")
|
||||
|
||||
const builder = HttpApiClient.urlBuilder(TopLevelApi, {
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
strictEqual(builder.health(), "https://api.example.com/v1/health")
|
||||
})
|
||||
|
||||
it("stores __proto__ identifiers as own properties", () => {
|
||||
const Api = HttpApi.make("Api").add(
|
||||
HttpApiGroup.make("__proto__").add(
|
||||
HttpApiEndpoint.get("__proto__", "/proto")
|
||||
)
|
||||
)
|
||||
const builder = HttpApiClient.urlBuilder(Api)
|
||||
|
||||
assert.isTrue(Object.hasOwn(builder, "__proto__"))
|
||||
assert.isTrue(Object.hasOwn(builder["__proto__"], "__proto__"))
|
||||
strictEqual(builder["__proto__"]["__proto__"](), "/proto")
|
||||
})
|
||||
})
|
||||
|
||||
it.effect("stores __proto__ client identifiers as own properties", () =>
|
||||
Effect.gen(function*() {
|
||||
const Api = HttpApi.make("Api").add(
|
||||
HttpApiGroup.make("__proto__").add(
|
||||
HttpApiEndpoint.get("__proto__", "/proto")
|
||||
)
|
||||
)
|
||||
const httpClient = clientFromResponse(() => new Response(null, { status: 204 }))
|
||||
const client = yield* HttpApiClient.makeWith(Api, { httpClient })
|
||||
const groupClient = yield* HttpApiClient.group(Api, {
|
||||
group: "__proto__",
|
||||
httpClient
|
||||
})
|
||||
|
||||
assert.isTrue(Object.hasOwn(client, "__proto__"))
|
||||
assert.isTrue(Object.hasOwn(client["__proto__"], "__proto__"))
|
||||
assert.strictEqual(typeof client["__proto__"]["__proto__"], "function")
|
||||
assert.isTrue(Object.hasOwn(groupClient, "__proto__"))
|
||||
assert.strictEqual(typeof groupClient["__proto__"], "function")
|
||||
}))
|
||||
|
||||
it.effect("applies transformClient to endpoint clients exactly once", () =>
|
||||
Effect.gen(function*() {
|
||||
const Api = HttpApi.make("Api").add(
|
||||
HttpApiGroup.make("test").add(HttpApiEndpoint.get("health", "/health"))
|
||||
)
|
||||
let transformations = 0
|
||||
const httpClient = HttpClient.make((request, url) =>
|
||||
Effect.sync(() => {
|
||||
strictEqual(url.toString(), "https://api.example.com/health")
|
||||
return HttpClientResponse.fromWeb(request, new Response(null, { status: 204 }))
|
||||
})
|
||||
)
|
||||
const health = yield* HttpApiClient.endpoint(Api, {
|
||||
group: "test",
|
||||
endpoint: "health",
|
||||
httpClient,
|
||||
transformClient: (client) => {
|
||||
transformations++
|
||||
return client.pipe(
|
||||
HttpClient.mapRequest(HttpClientRequest.prependUrl("https://api.example.com"))
|
||||
)
|
||||
}
|
||||
})
|
||||
|
||||
yield* health({ responseMode: "response-only" })
|
||||
yield* health({ responseMode: "response-only" })
|
||||
|
||||
strictEqual(transformations, 1)
|
||||
}))
|
||||
|
||||
it.effect("encodes path parameters when executing requests", () =>
|
||||
Effect.gen(function*() {
|
||||
const Api = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("stacks")
|
||||
.add(
|
||||
HttpApiEndpoint.get("listResources", "/state/stacks/:stack/stages/:stage/resources", {
|
||||
params: {
|
||||
stack: Schema.String,
|
||||
stage: Schema.String
|
||||
}
|
||||
})
|
||||
)
|
||||
)
|
||||
const httpClient = HttpClient.make((request, url) =>
|
||||
Effect.sync(() => {
|
||||
strictEqual(url.toString(), "https://api.example.com/state/stacks/a%2Fb/stages/prod%2Fblue/resources")
|
||||
return HttpClientResponse.fromWeb(request, new Response(null, { status: 204 }))
|
||||
})
|
||||
)
|
||||
const client = yield* HttpApiClient.makeWith(Api, {
|
||||
httpClient,
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
yield* client.stacks.listResources({
|
||||
params: {
|
||||
stack: "a/b",
|
||||
stage: "prod/blue"
|
||||
},
|
||||
responseMode: "response-only"
|
||||
})
|
||||
}))
|
||||
|
||||
it.effect("omits optional path parameters when executing requests", () =>
|
||||
Effect.gen(function*() {
|
||||
const Api = HttpApi.make("Api")
|
||||
.add(
|
||||
HttpApiGroup.make("files")
|
||||
.add(
|
||||
HttpApiEndpoint.get("download", "/files/:path?", {
|
||||
params: {
|
||||
path: Schema.optional(Schema.String)
|
||||
}
|
||||
})
|
||||
)
|
||||
)
|
||||
const urls: Array<string> = []
|
||||
const httpClient = HttpClient.make((request, url) =>
|
||||
Effect.sync(() => {
|
||||
urls.push(url.toString())
|
||||
return HttpClientResponse.fromWeb(request, new Response(null, { status: 204 }))
|
||||
})
|
||||
)
|
||||
const client = yield* HttpApiClient.makeWith(Api, {
|
||||
httpClient,
|
||||
baseUrl: "https://api.example.com"
|
||||
})
|
||||
|
||||
yield* client.files.download({
|
||||
params: {},
|
||||
responseMode: "response-only"
|
||||
})
|
||||
yield* client.files.download({
|
||||
params: { path: "a/b" },
|
||||
responseMode: "response-only"
|
||||
})
|
||||
|
||||
strictEqual(urls[0], "https://api.example.com/files")
|
||||
strictEqual(urls[1], "https://api.example.com/files/a%2Fb")
|
||||
}))
|
||||
})
|
||||
|
||||
const textEncoder = new TextEncoder()
|
||||
|
||||
const StreamError = Schema.Struct({ reason: Schema.String })
|
||||
|
||||
const Events = Schema.Struct({
|
||||
event: Schema.String,
|
||||
data: Schema.String
|
||||
})
|
||||
|
||||
class EndpointError extends Schema.TaggedErrorClass<EndpointError>()("EndpointError", {
|
||||
message: Schema.String
|
||||
}, { httpApiStatus: 400 }) {}
|
||||
|
||||
const MixedSuccess = Schema.Struct({
|
||||
message: Schema.String
|
||||
})
|
||||
|
||||
const MixedEventData = Schema.Struct({
|
||||
text: Schema.String
|
||||
})
|
||||
|
||||
const StreamingApi = HttpApi.make("StreamingApi").add(
|
||||
HttpApiGroup.make("test")
|
||||
.add(
|
||||
HttpApiEndpoint.get("events", "/events", {
|
||||
success: HttpApiSchema.StreamSse({ events: Events, error: StreamError }),
|
||||
error: EndpointError
|
||||
}),
|
||||
HttpApiEndpoint.get("download", "/download", {
|
||||
success: HttpApiSchema.StreamUint8Array(),
|
||||
error: EndpointError
|
||||
})
|
||||
)
|
||||
)
|
||||
|
||||
const AnnotatedStreamingApi = HttpApi.make("AnnotatedStreamingApi").add(
|
||||
HttpApiGroup.make("test")
|
||||
.add(
|
||||
HttpApiEndpoint.get("events", "/events", {
|
||||
success: HttpApiSchema.status(202)(HttpApiSchema.StreamSse({ events: Events, error: StreamError }))
|
||||
}),
|
||||
HttpApiEndpoint.get("download", "/download", {
|
||||
success: HttpApiSchema.status(206)(HttpApiSchema.StreamUint8Array())
|
||||
})
|
||||
)
|
||||
)
|
||||
|
||||
const MixedSuccessApi = HttpApi.make("MixedSuccessApi").add(
|
||||
HttpApiGroup.make("test")
|
||||
.add(
|
||||
HttpApiEndpoint.get("chat", "/chat", {
|
||||
success: [
|
||||
MixedSuccess,
|
||||
HttpApiSchema.StreamSse({ data: MixedEventData, error: StreamError })
|
||||
]
|
||||
})
|
||||
)
|
||||
)
|
||||
|
||||
const JsonResponseError = Schema.Struct({
|
||||
_tag: Schema.Literal("JsonError"),
|
||||
message: Schema.String
|
||||
}).pipe(HttpApiSchema.status(400))
|
||||
|
||||
const TextResponseError = Schema.String.pipe(
|
||||
HttpApiSchema.asText(),
|
||||
HttpApiSchema.status(400)
|
||||
)
|
||||
|
||||
const NoContentResponseError = Schema.Literal("NoContentError").pipe(
|
||||
HttpApiSchema.asNoContent({ decode: () => "NoContentError" as const }),
|
||||
HttpApiSchema.status(400)
|
||||
)
|
||||
|
||||
const FirstJsonResponseError = Schema.Struct({
|
||||
_tag: Schema.Literal("FirstJsonError"),
|
||||
code: Schema.Number
|
||||
}).pipe(
|
||||
HttpApiSchema.asJson({ contentType: "Application/Problem+JSON" }),
|
||||
HttpApiSchema.status(400)
|
||||
)
|
||||
|
||||
const SecondJsonResponseError = Schema.Struct({
|
||||
_tag: Schema.Literal("SecondJsonError"),
|
||||
message: Schema.String
|
||||
}).pipe(
|
||||
HttpApiSchema.asJson({ contentType: "application/problem+json; charset=utf-8" }),
|
||||
HttpApiSchema.status(400)
|
||||
)
|
||||
|
||||
const ErrorContentTypeApi = HttpApi.make("ErrorContentTypeApi").add(
|
||||
HttpApiGroup.make("test")
|
||||
.add(
|
||||
HttpApiEndpoint.get("textFirst", "/text-first", {
|
||||
error: [TextResponseError, JsonResponseError]
|
||||
}),
|
||||
HttpApiEndpoint.get("jsonFirst", "/json-first", {
|
||||
error: [JsonResponseError, TextResponseError]
|
||||
}),
|
||||
HttpApiEndpoint.get("noContent", "/no-content", {
|
||||
error: [NoContentResponseError, TextResponseError]
|
||||
}),
|
||||
HttpApiEndpoint.get("equivalentJson", "/equivalent-json", {
|
||||
error: [FirstJsonResponseError, SecondJsonResponseError]
|
||||
})
|
||||
)
|
||||
)
|
||||
|
||||
const clientFromResponse = (response: () => Response): HttpClient.HttpClient =>
|
||||
HttpClient.make((request): Effect.Effect<HttpClientResponse.HttpClientResponse, never, never> =>
|
||||
Effect.succeed(HttpClientResponse.fromWeb(request, response()))
|
||||
)
|
||||
|
||||
const textStream = (chunks: ReadonlyArray<string>): ReadableStream<Uint8Array> => {
|
||||
let index = 0
|
||||
return new ReadableStream<Uint8Array>({
|
||||
pull(controller) {
|
||||
if (index === chunks.length) {
|
||||
controller.close()
|
||||
} else {
|
||||
controller.enqueue(textEncoder.encode(chunks[index++]!))
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
const byteStream = (chunks: ReadonlyArray<Uint8Array>): ReadableStream<Uint8Array> => {
|
||||
let index = 0
|
||||
return new ReadableStream<Uint8Array>({
|
||||
pull(controller) {
|
||||
if (index === chunks.length) {
|
||||
controller.close()
|
||||
} else {
|
||||
controller.enqueue(chunks[index++]!)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user