import { NodeHttpServer, NodeSocket } from "@effect/platform-node"
import { assert, describe, it } from "@effect/vitest"
import { Effect, Layer, Schema, Stream } from "effect"
import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol } from "effect/graphql"
import { FetchHttpClient, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/http"
import type * as NetAddress from "effect/net/NetAddress"
const Viewer = GraphQL.query("Viewer", {
document: "query Viewer{viewer{login}}",
result: Schema.Struct({ viewer: Schema.Struct({ login: Schema.String }) })
})
const IssueUpdated = GraphQL.subscription("IssueUpdated", {
document: "subscription IssueUpdated($id:ID!){issueUpdated(id:$id){title}}",
variables: { id: Schema.String },
result: Schema.Struct({ issueUpdated: Schema.Struct({ title: Schema.String }) })
})
const Group = GraphQLGroup.make(Viewer, IssueUpdated)
const encoder = new TextEncoder()
const decoder = new TextDecoder()
const viewer = { data: { viewer: { login: "tim" } } }
const issue = (title: string) => ({ data: { issueUpdated: { title } } })
/**
* POST answers queries with JSON and subscriptions with a graphql-sse stream.
*/
const post = Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
if (!(request.headers["accept"] ?? "").includes("text/event-stream")) {
return yield* HttpServerResponse.json(viewer)
}
return HttpServerResponse.stream(
Stream.make(
`event: next\ndata: ${JSON.stringify(issue("over sse"))}\n\n`,
"event: complete\ndata:\n\n"
).pipe(Stream.map((chunk) => encoder.encode(chunk))),
{ contentType: "text/event-stream" }
)
})
/**
* A hand-rolled graphql-transport-ws server that requires an Authorization
* header on the handshake.
*/
const webSocket = Effect.gen(function*() {
const request = yield* HttpServerRequest.HttpServerRequest
if (request.headers["authorization"] !== "Bearer secret") {
return HttpServerResponse.empty({ status: 401 })
}
const socket = yield* request.upgrade
const { write } = yield* socket.writer
const { pull } = yield* socket.reader
const send = (message: unknown) => write(JSON.stringify(message))
while (true) {
for (const frame of yield* pull) {
const message = JSON.parse(typeof frame === "string" ? frame : decoder.decode(frame))
switch (message.type) {
case "connection_init":
yield* send({ type: "connection_ack" })
break
case "ping":
yield* send({ type: "pong" })
break
case "subscribe":
yield* send({ id: message.id, type: "next", payload: issue("over ws") })
yield* send({ id: message.id, type: "complete" })
break
}
}
}
}).pipe(
Effect.scoped,
Effect.catchTag("SocketError", () => Effect.succeed(HttpServerResponse.empty()))
)
describe("GraphQLProtocol over a real server", () => {
it.effect(
"serves a query over POST, a subscription over graphql-ws and one over graphql-sse",
() =>
Effect.gen(function*() {
yield* HttpRouter.add("POST", "/graphql", post).pipe(
Layer.merge(HttpRouter.add("GET", "/graphql", webSocket)),
(layer) => HttpRouter.serve(layer, { disableListenLog: true }),
Layer.build
)
const server = yield* HttpServer.HttpServer
const port = (server.address as NetAddress.InetAddress).port
const url = `http://127.0.0.1:${port}/graphql`
const splitProtocol = yield* Layer.build(GraphQLProtocol.layerHttp({
url,
subscriptions: {
webSocket: { url: `ws://127.0.0.1:${port}/graphql`, headers: { authorization: "Bearer secret" } }
}
}))
const split = yield* GraphQLClient.make(Group).pipe(Effect.provide(splitProtocol))
assert.deepStrictEqual(yield* split.Viewer(), viewer.data)
assert.deepStrictEqual(
yield* Stream.runCollect(split.IssueUpdated({ id: "I_1" })),
[issue("over ws").data]
)
const sseProtocol = yield* Layer.build(GraphQLProtocol.layerHttp({ url }))
const sse = yield* GraphQLClient.make(Group).pipe(Effect.provide(sseProtocol))
assert.deepStrictEqual(
yield* Stream.runCollect(sse.IssueUpdated({ id: "I_1" })),
[issue("over sse").data]
)
}).pipe(
Effect.provide([FetchHttpClient.layer, NodeSocket.layerWebSocketConstructor]),
Effect.provide(NodeHttpServer.layerTest),
Effect.timeout("5 seconds")
),
10000
)
})