@effect-gql/express 0.1.0 → 1.1.0

package/src/middleware.ts

@@ -1,65 +0,0 @@
-import { Layer } from "effect"
-import { HttpApp, HttpRouter } from "@effect/platform"
-import type { Request, Response, NextFunction, RequestHandler } from "express"
-import { toWebHeaders } from "./http-utils"
-
-/**
- * Convert an HttpRouter to Express middleware.
- *
- * This creates Express-compatible middleware that can be mounted on any Express app.
- * The middleware converts Express requests to web standard Requests, processes them
- * through the Effect router, and writes the response back to Express.
- *
- * @param router - The HttpRouter to convert (typically from makeGraphQLRouter or toRouter)
- * @param layer - Layer providing any services required by the router
- * @returns Express middleware function
- *
- * @example
- * ```typescript
- * import express from "express"
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toMiddleware } from "@effect-gql/express"
- * import { Layer } from "effect"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- *
- * const app = express()
- * app.use(toMiddleware(router, Layer.empty))
- * app.listen(4000, () => console.log("Server running on http://localhost:4000"))
- * ```
- */
-export const toMiddleware = <E, R, RE>(
-  router: HttpRouter.HttpRouter<E, R>,
-  layer: Layer.Layer<R, RE>
-): RequestHandler => {
-  const { handler } = HttpApp.toWebHandlerLayer(router, layer)
-
-  return async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      // Convert Express request to web standard Request
-      // Use URL constructor for safe URL parsing (avoids Host header injection)
-      const baseUrl = `${req.protocol}://${req.hostname}`
-      const url = new URL(req.originalUrl || "/", baseUrl).href
-      const headers = toWebHeaders(req.headers)
-
-      const webRequest = new Request(url, {
-        method: req.method,
-        headers,
-        body: ["GET", "HEAD"].includes(req.method) ? undefined : JSON.stringify(req.body),
-      })
-
-      // Process through Effect handler
-      const webResponse = await handler(webRequest)
-
-      // Write response back to Express
-      res.status(webResponse.status)
-      webResponse.headers.forEach((value, key) => {
-        res.setHeader(key, value)
-      })
-      const body = await webResponse.text()
-      res.send(body)
-    } catch (error) {
-      next(error)
-    }
-  }
-}

package/src/sse.ts

@@ -1,285 +0,0 @@
-import { Effect, Layer, Stream, Deferred } from "effect"
-import type { Request, Response, NextFunction, RequestHandler } from "express"
-import { GraphQLSchema } from "graphql"
-import {
-  makeGraphQLSSEHandler,
-  formatSSEMessage,
-  SSE_HEADERS,
-  type GraphQLSSEOptions,
-  type SSESubscriptionRequest,
-  SSEError,
-} from "@effect-gql/core"
-import { toWebHeaders } from "./http-utils"
-
-/**
- * Options for Express SSE middleware
- */
-export interface ExpressSSEOptions<R> extends GraphQLSSEOptions<R> {
-  /**
-   * Path for SSE connections.
-   * @default "/graphql/stream"
-   */
-  readonly path?: string
-}
-
-/**
- * Create an Express middleware for SSE subscriptions.
- *
- * This middleware handles POST requests to the configured path and streams
- * GraphQL subscription events as Server-Sent Events.
- *
- * @param schema - The GraphQL schema with subscription definitions
- * @param layer - Effect layer providing services required by resolvers
- * @param options - Optional lifecycle hooks and configuration
- * @returns An Express middleware function
- *
- * @example
- * ```typescript
- * import express from "express"
- * import { createServer } from "node:http"
- * import { toMiddleware, sseMiddleware, attachWebSocket } from "@effect-gql/express"
- * import { makeGraphQLRouter } from "@effect-gql/core"
- *
- * const app = express()
- * app.use(express.json())
- *
- * // Regular GraphQL endpoint
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * app.use(toMiddleware(router, Layer.empty))
- *
- * // SSE subscriptions endpoint
- * app.use(sseMiddleware(schema, Layer.empty, {
- *   path: "/graphql/stream",
- *   onConnect: (request, headers) => Effect.gen(function* () {
- *     const token = headers.get("authorization")
- *     const user = yield* AuthService.validateToken(token)
- *     return { user }
- *   }),
- * }))
- *
- * const server = createServer(app)
- *
- * // Optional: Also attach WebSocket subscriptions
- * attachWebSocket(server, schema, Layer.empty)
- *
- * server.listen(4000)
- * ```
- */
-export const sseMiddleware = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: ExpressSSEOptions<R>
-): RequestHandler => {
-  const path = options?.path ?? "/graphql/stream"
-  const sseHandler = makeGraphQLSSEHandler(schema, layer, options)
-
-  return async (req: Request, res: Response, next: NextFunction): Promise<void> => {
-    // Check if this request is for our path
-    if (req.path !== path) {
-      next()
-      return
-    }
-
-    // Only handle POST requests
-    if (req.method !== "POST") {
-      next()
-      return
-    }
-
-    // Check Accept header for SSE support
-    const accept = req.headers.accept ?? ""
-    if (!accept.includes("text/event-stream") && !accept.includes("*/*")) {
-      res.status(406).json({
-        errors: [{ message: "Client must accept text/event-stream" }],
-      })
-      return
-    }
-
-    // Parse the GraphQL request from the body
-    let subscriptionRequest: SSESubscriptionRequest
-    try {
-      const body = req.body as Record<string, unknown>
-      if (typeof body.query !== "string") {
-        throw new Error("Missing query")
-      }
-      subscriptionRequest = {
-        query: body.query,
-        variables: body.variables as Record<string, unknown> | undefined,
-        operationName: body.operationName as string | undefined,
-        extensions: body.extensions as Record<string, unknown> | undefined,
-      }
-    } catch {
-      res.status(400).json({
-        errors: [{ message: "Invalid GraphQL request body" }],
-      })
-      return
-    }
-
-    // Convert Express headers to web Headers
-    const headers = toWebHeaders(req.headers)
-
-    // Set SSE headers
-    res.writeHead(200, SSE_HEADERS)
-
-    // Get the event stream
-    const eventStream = sseHandler(subscriptionRequest, headers)
-
-    // Create the streaming effect
-    const streamEffect = Effect.gen(function* () {
-      // Track client disconnection
-      const clientDisconnected = yield* Deferred.make<void, SSEError>()
-
-      req.on("close", () => {
-        Effect.runPromise(Deferred.succeed(clientDisconnected, undefined)).catch(() => {})
-      })
-
-      req.on("error", (error) => {
-        Effect.runPromise(Deferred.fail(clientDisconnected, new SSEError({ cause: error }))).catch(
-          () => {}
-        )
-      })
-
-      // Stream events to the client
-      const runStream = Stream.runForEach(eventStream, (event) =>
-        Effect.async<void, SSEError>((resume) => {
-          const message = formatSSEMessage(event)
-          res.write(message, (error) => {
-            if (error) {
-              resume(Effect.fail(new SSEError({ cause: error })))
-            } else {
-              resume(Effect.succeed(undefined))
-            }
-          })
-        })
-      )
-
-      // Race between stream completion and client disconnection
-      yield* Effect.race(
-        runStream.pipe(Effect.catchAll((error) => Effect.logWarning("SSE stream error", error))),
-        Deferred.await(clientDisconnected)
-      )
-    })
-
-    await Effect.runPromise(
-      streamEffect.pipe(
-        Effect.ensuring(Effect.sync(() => res.end())),
-        Effect.catchAll(() => Effect.void)
-      )
-    )
-  }
-}
-
-/**
- * Create a standalone Express route handler for SSE subscriptions.
- *
- * Use this if you want more control over routing than the middleware provides.
- *
- * @param schema - The GraphQL schema with subscription definitions
- * @param layer - Effect layer providing services required by resolvers
- * @param options - Optional lifecycle hooks and configuration
- * @returns An Express request handler
- *
- * @example
- * ```typescript
- * import express from "express"
- * import { createSSEHandler } from "@effect-gql/express"
- *
- * const app = express()
- * app.use(express.json())
- *
- * const sseHandler = createSSEHandler(schema, Layer.empty)
- * app.post("/graphql/stream", sseHandler)
- *
- * app.listen(4000)
- * ```
- */
-export const createSSEHandler = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: Omit<ExpressSSEOptions<R>, "path">
-): RequestHandler => {
-  const sseHandler = makeGraphQLSSEHandler(schema, layer, options)
-
-  return async (req: Request, res: Response, _next: NextFunction): Promise<void> => {
-    // Check Accept header for SSE support
-    const accept = req.headers.accept ?? ""
-    if (!accept.includes("text/event-stream") && !accept.includes("*/*")) {
-      res.status(406).json({
-        errors: [{ message: "Client must accept text/event-stream" }],
-      })
-      return
-    }
-
-    // Parse the GraphQL request from the body
-    let subscriptionRequest: SSESubscriptionRequest
-    try {
-      const body = req.body as Record<string, unknown>
-      if (typeof body.query !== "string") {
-        throw new Error("Missing query")
-      }
-      subscriptionRequest = {
-        query: body.query,
-        variables: body.variables as Record<string, unknown> | undefined,
-        operationName: body.operationName as string | undefined,
-        extensions: body.extensions as Record<string, unknown> | undefined,
-      }
-    } catch {
-      res.status(400).json({
-        errors: [{ message: "Invalid GraphQL request body" }],
-      })
-      return
-    }
-
-    // Convert Express headers to web Headers
-    const headers = toWebHeaders(req.headers)
-
-    // Set SSE headers
-    res.writeHead(200, SSE_HEADERS)
-
-    // Get the event stream
-    const eventStream = sseHandler(subscriptionRequest, headers)
-
-    // Create the streaming effect
-    const streamEffect = Effect.gen(function* () {
-      // Track client disconnection
-      const clientDisconnected = yield* Deferred.make<void, SSEError>()
-
-      req.on("close", () => {
-        Effect.runPromise(Deferred.succeed(clientDisconnected, undefined)).catch(() => {})
-      })
-
-      req.on("error", (error) => {
-        Effect.runPromise(Deferred.fail(clientDisconnected, new SSEError({ cause: error }))).catch(
-          () => {}
-        )
-      })
-
-      // Stream events to the client
-      const runStream = Stream.runForEach(eventStream, (event) =>
-        Effect.async<void, SSEError>((resume) => {
-          const message = formatSSEMessage(event)
-          res.write(message, (error) => {
-            if (error) {
-              resume(Effect.fail(new SSEError({ cause: error })))
-            } else {
-              resume(Effect.succeed(undefined))
-            }
-          })
-        })
-      )
-
-      // Race between stream completion and client disconnection
-      yield* Effect.race(
-        runStream.pipe(Effect.catchAll((error) => Effect.logWarning("SSE stream error", error))),
-        Deferred.await(clientDisconnected)
-      )
-    })
-
-    await Effect.runPromise(
-      streamEffect.pipe(
-        Effect.ensuring(Effect.sync(() => res.end())),
-        Effect.catchAll(() => Effect.void)
-      )
-    )
-  }
-}

package/src/ws.ts

@@ -1,152 +0,0 @@
-import { Effect, Layer } from "effect"
-import type { Server } from "node:http"
-import type { IncomingMessage } from "node:http"
-import type { Duplex } from "node:stream"
-import { WebSocket, WebSocketServer } from "ws"
-import { GraphQLSchema } from "graphql"
-import {
-  makeGraphQLWSHandler,
-  toEffectWebSocketFromWs,
-  type GraphQLWSOptions,
-} from "@effect-gql/core"
-
-/**
- * Options for Express WebSocket server
- */
-export interface ExpressWSOptions<R> extends GraphQLWSOptions<R> {
-  /**
-   * Path for WebSocket connections.
-   * @default "/graphql"
-   */
-  readonly path?: string
-}
-
-/**
- * Attach WebSocket subscription support to an Express HTTP server.
- *
- * Since Express middleware doesn't own the HTTP server, this function
- * must be called separately with the HTTP server instance to enable
- * WebSocket subscriptions.
- *
- * @param server - The HTTP server running the Express app
- * @param schema - The GraphQL schema with subscription definitions
- * @param layer - Effect layer providing services required by resolvers
- * @param options - Optional configuration and lifecycle hooks
- * @returns Object with cleanup function
- *
- * @example
- * ```typescript
- * import express from "express"
- * import { createServer } from "node:http"
- * import { toMiddleware, attachWebSocket } from "@effect-gql/express"
- * import { makeGraphQLRouter, GraphQLSchemaBuilder } from "@effect-gql/core"
- * import { Layer, Effect, Stream } from "effect"
- * import * as S from "effect/Schema"
- *
- * // Build schema with subscriptions
- * const schema = GraphQLSchemaBuilder.empty
- *   .query("hello", { type: S.String, resolve: () => Effect.succeed("world") })
- *   .subscription("counter", {
- *     type: S.Int,
- *     subscribe: () => Effect.succeed(Stream.fromIterable([1, 2, 3]))
- *   })
- *   .buildSchema()
- *
- * // Create Express app with middleware
- * const app = express()
- * app.use(express.json())
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * app.use(toMiddleware(router, Layer.empty))
- *
- * // Create HTTP server and attach WebSocket support
- * const server = createServer(app)
- * const ws = attachWebSocket(server, schema, Layer.empty, {
- *   path: "/graphql"
- * })
- *
- * server.listen(4000, () => {
- *   console.log("Server running on http://localhost:4000")
- *   console.log("WebSocket subscriptions available at ws://localhost:4000/graphql")
- * })
- *
- * // Cleanup on shutdown
- * process.on("SIGINT", async () => {
- *   await ws.close()
- *   server.close()
- * })
- * ```
- */
-export const attachWebSocket = <R>(
-  server: Server,
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: ExpressWSOptions<R>
-): { close: () => Promise<void> } => {
-  const wss = new WebSocketServer({ noServer: true })
-  const path = options?.path ?? "/graphql"
-
-  // Create the handler from core
-  const handler = makeGraphQLWSHandler(schema, layer, options)
-
-  // Track active connections for cleanup
-  const activeConnections = new Set<WebSocket>()
-
-  wss.on("connection", (ws) => {
-    activeConnections.add(ws)
-
-    const effectSocket = toEffectWebSocketFromWs(ws)
-
-    // Run the handler
-    Effect.runPromise(
-      handler(effectSocket).pipe(
-        Effect.catchAll((error) => Effect.logError("GraphQL WebSocket handler error", error))
-      )
-    ).finally(() => {
-      activeConnections.delete(ws)
-    })
-  })
-
-  const handleUpgrade = (request: IncomingMessage, socket: Duplex, head: Buffer) => {
-    // Check if this is the GraphQL WebSocket path
-    const url = new URL(request.url ?? "/", `http://${request.headers.host}`)
-    if (url.pathname !== path) {
-      socket.destroy()
-      return
-    }
-
-    // Check for correct WebSocket subprotocol
-    const protocol = request.headers["sec-websocket-protocol"]
-    if (!protocol?.includes("graphql-transport-ws")) {
-      socket.write("HTTP/1.1 400 Bad Request\r\n\r\n")
-      socket.destroy()
-      return
-    }
-
-    wss.handleUpgrade(request, socket, head, (ws) => {
-      wss.emit("connection", ws, request)
-    })
-  }
-
-  // Attach upgrade handler to server
-  server.on("upgrade", (request, socket, head) => {
-    handleUpgrade(request, socket as Duplex, head)
-  })
-
-  const close = async () => {
-    // Close all active connections
-    for (const ws of activeConnections) {
-      ws.close(1001, "Server shutting down")
-    }
-    activeConnections.clear()
-
-    // Close the WebSocket server
-    return new Promise<void>((resolve, reject) => {
-      wss.close((error) => {
-        if (error) reject(error)
-        else resolve()
-      })
-    })
-  }
-
-  return { close }
-}