@effect-gql/bun 0.1.0 → 1.1.0

package/src/serve.ts

@@ -1,182 +0,0 @@
-import { Effect, Layer } from "effect"
-import { HttpApp, HttpRouter, HttpServer } from "@effect/platform"
-import { BunHttpServer, BunRuntime } from "@effect/platform-bun"
-import type { GraphQLSchema } from "graphql"
-import type { GraphQLWSOptions } from "@effect-gql/core"
-
-/**
- * Configuration for WebSocket subscriptions
- */
-export interface SubscriptionsConfig<R> extends GraphQLWSOptions<R> {
-  /**
-   * The GraphQL schema (required for subscriptions).
-   * Must be the same schema used to create the router.
-   */
-  readonly schema: GraphQLSchema
-  /**
-   * Path for WebSocket connections.
-   * @default "/graphql"
-   */
-  readonly path?: string
-}
-
-/**
- * Options for the Bun GraphQL server
- */
-export interface ServeOptions<R = never> {
-  /** Port to listen on (default: 4000) */
-  readonly port?: number
-  /** Hostname to bind to (default: "0.0.0.0") */
-  readonly host?: string
-  /** Callback when server starts */
-  readonly onStart?: (url: string) => void
-  /**
-   * Enable WebSocket subscriptions.
-   * When provided, the server will handle WebSocket upgrade requests
-   * for GraphQL subscriptions using the graphql-ws protocol.
-   */
-  readonly subscriptions?: SubscriptionsConfig<R>
-}
-
-/**
- * Start a Bun HTTP server with the given router.
- *
- * This is the main entry point for running a GraphQL server on Bun.
- * It handles all the Effect runtime setup and server lifecycle.
- *
- * @param router - The HttpRouter to serve (typically from makeGraphQLRouter or toRouter)
- * @param layer - Layer providing the router's service dependencies
- * @param options - Server configuration options
- *
- * @example
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { serve } from "@effect-gql/bun"
- *
- * const schema = GraphQLSchemaBuilder.empty
- *   .query("hello", { type: S.String, resolve: () => Effect.succeed("world") })
- *   .buildSchema()
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- *
- * // Without subscriptions
- * serve(router, serviceLayer, {
- *   port: 4000,
- *   onStart: (url) => console.log(`Server running at ${url}`)
- * })
- *
- * // With subscriptions
- * serve(router, serviceLayer, {
- *   port: 4000,
- *   subscriptions: { schema },
- *   onStart: (url) => console.log(`Server running at ${url}`)
- * })
- * ```
- */
-export const serve = <E, R, RE>(
-  router: HttpRouter.HttpRouter<E, R>,
-  layer: Layer.Layer<R, RE>,
-  options: ServeOptions<R> = {}
-): void => {
-  const { port = 4000, host = "0.0.0.0", onStart, subscriptions } = options
-
-  if (subscriptions) {
-    // With WebSocket subscriptions - use Bun.serve() directly
-    serveWithSubscriptions(router, layer, port, host, subscriptions, onStart)
-  } else {
-    // Without subscriptions - use the standard Effect approach
-    const app = router.pipe(
-      Effect.catchAllCause((cause) => Effect.die(cause)),
-      HttpServer.serve()
-    )
-
-    const serverLayer = BunHttpServer.layer({ port })
-    const fullLayer = Layer.merge(serverLayer, layer)
-
-    if (onStart) {
-      onStart(`http://${host === "0.0.0.0" ? "localhost" : host}:${port}`)
-    }
-
-    BunRuntime.runMain(Layer.launch(Layer.provide(app, fullLayer)))
-  }
-}
-
-/**
- * Internal implementation for serving with WebSocket subscriptions.
- * Uses Bun.serve() directly to enable WebSocket support.
- */
-function serveWithSubscriptions<E, R, RE>(
-  router: HttpRouter.HttpRouter<E, R>,
-  layer: Layer.Layer<R, RE>,
-  port: number,
-  host: string,
-  subscriptions: SubscriptionsConfig<R>,
-  onStart?: (url: string) => void
-): void {
-  // Dynamically import ws module to keep it optional
-  const importWs = Effect.tryPromise({
-    try: () => import("./ws"),
-    catch: (error) => error as Error,
-  })
-
-  Effect.runPromise(
-    importWs.pipe(
-      Effect.catchAll((error) =>
-        Effect.logError("Failed to load WebSocket support", error).pipe(
-          Effect.andThen(Effect.sync(() => process.exit(1))),
-          Effect.andThen(Effect.fail(error))
-        )
-      )
-    )
-  ).then(({ createBunWSHandlers }) => {
-    // Create the web handler from the Effect router
-    const { handler } = HttpApp.toWebHandlerLayer(router, layer)
-
-    // Create WebSocket handlers
-    const { upgrade, websocket } = createBunWSHandlers(
-      subscriptions.schema,
-      layer as Layer.Layer<R>,
-      {
-        path: subscriptions.path,
-        complexity: subscriptions.complexity,
-        fieldComplexities: subscriptions.fieldComplexities,
-        onConnect: subscriptions.onConnect,
-        onDisconnect: subscriptions.onDisconnect,
-        onSubscribe: subscriptions.onSubscribe,
-        onComplete: subscriptions.onComplete,
-        onError: subscriptions.onError,
-      }
-    )
-
-    // Start Bun server with WebSocket support
-    const server = Bun.serve({
-      port,
-      hostname: host,
-      fetch: async (request, server) => {
-        // Try WebSocket upgrade first
-        if (upgrade(request, server)) {
-          return new Response(null, { status: 101 })
-        }
-
-        // Handle HTTP requests
-        return handler(request)
-      },
-      websocket,
-    })
-
-    if (onStart) {
-      onStart(`http://${host === "0.0.0.0" ? "localhost" : host}:${port}`)
-    }
-
-    // Handle shutdown
-    process.on("SIGINT", () => {
-      server.stop()
-      process.exit(0)
-    })
-
-    process.on("SIGTERM", () => {
-      server.stop()
-      process.exit(0)
-    })
-  })
-}

package/src/sse.ts

@@ -1,182 +0,0 @@
-import { Effect, Layer, Stream } from "effect"
-import { GraphQLSchema } from "graphql"
-import {
-  makeGraphQLSSEHandler,
-  formatSSEMessage,
-  SSE_HEADERS,
-  type GraphQLSSEOptions,
-  type SSESubscriptionRequest,
-} from "@effect-gql/core"
-
-/**
- * Options for Bun SSE handler
- */
-export interface BunSSEOptions<R> extends GraphQLSSEOptions<R> {
-  /**
-   * Path for SSE connections.
-   * @default "/graphql/stream"
-   */
-  readonly path?: string
-}
-
-/**
- * Create an SSE handler for Bun.serve().
- *
- * This function creates a handler that returns a streaming Response for SSE
- * subscription requests. It's designed to integrate with Bun.serve()'s fetch handler.
- *
- * @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 A function that handles SSE requests and returns a Response
- *
- * @example
- * ```typescript
- * const sseHandler = createBunSSEHandler(schema, serviceLayer, {
- *   path: "/graphql/stream",
- * })
- *
- * Bun.serve({
- *   port: 4000,
- *   fetch(req, server) {
- *     const url = new URL(req.url)
- *
- *     // Handle SSE subscriptions
- *     if (url.pathname === "/graphql/stream" && req.method === "POST") {
- *       return sseHandler(req)
- *     }
- *
- *     // Handle other requests...
- *   },
- * })
- * ```
- */
-export const createBunSSEHandler = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: BunSSEOptions<R>
-): ((request: Request) => Promise<Response>) => {
-  const sseHandler = makeGraphQLSSEHandler(schema, layer, options)
-
-  return async (request: Request): Promise<Response> => {
-    // Check Accept header for SSE support
-    const accept = request.headers.get("accept") ?? ""
-    if (!accept.includes("text/event-stream") && !accept.includes("*/*")) {
-      return new Response(
-        JSON.stringify({
-          errors: [{ message: "Client must accept text/event-stream" }],
-        }),
-        { status: 406, headers: { "Content-Type": "application/json" } }
-      )
-    }
-
-    // Read and parse the request body
-    let subscriptionRequest: SSESubscriptionRequest
-    try {
-      const body = (await request.json()) 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 {
-      return new Response(
-        JSON.stringify({
-          errors: [{ message: "Invalid GraphQL request body" }],
-        }),
-        { status: 400, headers: { "Content-Type": "application/json" } }
-      )
-    }
-
-    // Get the event stream
-    const eventStream = sseHandler(subscriptionRequest, request.headers)
-
-    // Create a ReadableStream from the Effect Stream
-    const readableStream = new ReadableStream({
-      async start(controller) {
-        const encoder = new TextEncoder()
-
-        await Effect.runPromise(
-          Stream.runForEach(eventStream, (event) =>
-            Effect.sync(() => {
-              const message = formatSSEMessage(event)
-              controller.enqueue(encoder.encode(message))
-            })
-          ).pipe(
-            Effect.catchAll((error) => Effect.logWarning("SSE stream error", error)),
-            Effect.ensuring(Effect.sync(() => controller.close()))
-          )
-        )
-      },
-    })
-
-    return new Response(readableStream, {
-      status: 200,
-      headers: SSE_HEADERS,
-    })
-  }
-}
-
-/**
- * Create SSE handlers that integrate with Bun.serve().
- *
- * This returns an object with methods to check if a request should be
- * handled as SSE and to handle it.
- *
- * @param schema - The GraphQL schema with subscription definitions
- * @param layer - Effect layer providing services required by resolvers
- * @param options - Optional lifecycle hooks and configuration
- *
- * @example
- * ```typescript
- * const { upgrade: wsUpgrade, websocket } = createBunWSHandlers(schema, layer)
- * const sse = createBunSSEHandlers(schema, layer)
- *
- * Bun.serve({
- *   port: 4000,
- *   fetch(req, server) {
- *     // Try WebSocket upgrade first
- *     if (wsUpgrade(req, server)) {
- *       return
- *     }
- *
- *     // Try SSE subscriptions
- *     if (sse.shouldHandle(req)) {
- *       return sse.handle(req)
- *     }
- *
- *     // Handle other requests...
- *   },
- *   websocket,
- * })
- * ```
- */
-export const createBunSSEHandlers = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: BunSSEOptions<R>
-): {
-  /** Path this SSE handler responds to */
-  readonly path: string
-  /** Check if a request should be handled as SSE */
-  shouldHandle: (request: Request) => boolean
-  /** Handle an SSE request */
-  handle: (request: Request) => Promise<Response>
-} => {
-  const path = options?.path ?? "/graphql/stream"
-  const handler = createBunSSEHandler(schema, layer, options)
-
-  return {
-    path,
-    shouldHandle: (request: Request) => {
-      if (request.method !== "POST") return false
-      const url = new URL(request.url)
-      return url.pathname === path
-    },
-    handle: handler,
-  }
-}

package/src/ws.ts

@@ -1,247 +0,0 @@
-import { Effect, Stream, Queue, Deferred, Layer } from "effect"
-import { GraphQLSchema } from "graphql"
-import {
-  makeGraphQLWSHandler,
-  type EffectWebSocket,
-  type GraphQLWSOptions,
-  WebSocketError,
-  type CloseEvent,
-} from "@effect-gql/core"
-import type { Server, ServerWebSocket } from "bun"
-
-/**
- * Data attached to each WebSocket connection
- */
-interface WebSocketData {
-  messageQueue: Queue.Queue<string>
-  closedDeferred: Deferred.Deferred<CloseEvent, WebSocketError>
-  effectSocket: EffectWebSocket
-}
-
-/**
- * Options for Bun WebSocket server
- */
-export interface BunWSOptions<R> extends GraphQLWSOptions<R> {
-  /**
-   * Path for WebSocket connections.
-   * @default "/graphql"
-   */
-  readonly path?: string
-}
-
-/**
- * Create WebSocket handlers for Bun.serve().
- *
- * Bun has built-in WebSocket support that's configured as part of Bun.serve().
- * This function returns the handlers needed to integrate GraphQL subscriptions.
- *
- * @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 containing upgrade check and WebSocket handlers
- *
- * @example
- * ```typescript
- * const { upgrade, websocket } = createBunWSHandlers(schema, serviceLayer)
- *
- * Bun.serve({
- *   port: 4000,
- *   fetch(req, server) {
- *     // Try WebSocket upgrade first
- *     if (upgrade(req, server)) {
- *       return // Upgraded to WebSocket
- *     }
- *     // Handle HTTP requests...
- *   },
- *   websocket,
- * })
- * ```
- */
-export const createBunWSHandlers = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: BunWSOptions<R>
-): {
-  /**
-   * Check if request should upgrade to WebSocket and perform upgrade.
-   * Returns true if upgraded, false otherwise.
-   */
-  upgrade: (request: Request, server: Server<WebSocketData>) => boolean
-  /**
-   * WebSocket event handlers for Bun.serve()
-   */
-  websocket: {
-    open: (ws: ServerWebSocket<WebSocketData>) => void
-    message: (ws: ServerWebSocket<WebSocketData>, message: string | Buffer) => void
-    close: (ws: ServerWebSocket<WebSocketData>, code: number, reason: string) => void
-    error: (ws: ServerWebSocket<WebSocketData>, error: Error) => void
-  }
-} => {
-  const path = options?.path ?? "/graphql"
-  const handler = makeGraphQLWSHandler(schema, layer, options)
-
-  // Track active connection handlers for cleanup
-  const activeHandlers = new Map<ServerWebSocket<WebSocketData>, Promise<void>>()
-
-  const upgrade = (request: Request, server: Server<WebSocketData>): boolean => {
-    const url = new URL(request.url)
-
-    // Check if this is a WebSocket upgrade request for the GraphQL path
-    if (url.pathname !== path) {
-      return false
-    }
-
-    const upgradeHeader = request.headers.get("upgrade")
-    if (upgradeHeader?.toLowerCase() !== "websocket") {
-      return false
-    }
-
-    // Check for correct subprotocol
-    const protocol = request.headers.get("sec-websocket-protocol")
-    if (!protocol?.includes("graphql-transport-ws")) {
-      return false
-    }
-
-    // Perform upgrade - data will be set in open handler
-    const success = server.upgrade(request, {
-      data: {} as WebSocketData, // Will be populated in open handler
-    })
-
-    return success
-  }
-
-  const websocket = {
-    open: (ws: ServerWebSocket<WebSocketData>) => {
-      // Create Effect-based socket wrapper
-      const setupEffect = Effect.gen(function* () {
-        const messageQueue = yield* Queue.unbounded<string>()
-        const closedDeferred = yield* Deferred.make<CloseEvent, WebSocketError>()
-
-        const effectSocket: EffectWebSocket = {
-          protocol: ws.data?.effectSocket?.protocol || "graphql-transport-ws",
-
-          send: (data: string) =>
-            Effect.try({
-              try: () => {
-                ws.send(data)
-              },
-              catch: (error) => new WebSocketError({ cause: error }),
-            }),
-
-          close: (code?: number, reason?: string) =>
-            Effect.sync(() => {
-              ws.close(code ?? 1000, reason ?? "")
-            }),
-
-          messages: Stream.fromQueue(messageQueue).pipe(Stream.catchAll(() => Stream.empty)),
-
-          closed: Deferred.await(closedDeferred),
-        }
-
-        // Store in WebSocket data
-        ws.data = {
-          messageQueue,
-          closedDeferred,
-          effectSocket,
-        }
-
-        return effectSocket
-      })
-
-      // Run setup and handler
-      const handlerPromise = Effect.runPromise(
-        setupEffect.pipe(
-          Effect.flatMap((effectSocket) => handler(effectSocket)),
-          Effect.catchAllCause(() => Effect.void)
-        )
-      )
-
-      activeHandlers.set(ws, handlerPromise)
-    },
-
-    message: (ws: ServerWebSocket<WebSocketData>, message: string | Buffer) => {
-      const data = ws.data as WebSocketData | undefined
-      if (data?.messageQueue) {
-        const messageStr = typeof message === "string" ? message : message.toString()
-        Effect.runPromise(Queue.offer(data.messageQueue, messageStr)).catch(() => {
-          // Queue might be shutdown
-        })
-      }
-    },
-
-    close: (ws: ServerWebSocket<WebSocketData>, code: number, reason: string) => {
-      const data = ws.data as WebSocketData | undefined
-      if (data) {
-        Effect.runPromise(
-          Effect.all([
-            Queue.shutdown(data.messageQueue),
-            Deferred.succeed(data.closedDeferred, { code, reason }),
-          ])
-        ).catch(() => {
-          // Already completed
-        })
-      }
-      activeHandlers.delete(ws)
-    },
-
-    error: (ws: ServerWebSocket<WebSocketData>, error: Error) => {
-      const data = ws.data as WebSocketData | undefined
-      if (data) {
-        Effect.runPromise(
-          Deferred.fail(data.closedDeferred, new WebSocketError({ cause: error }))
-        ).catch(() => {
-          // Already completed
-        })
-      }
-    },
-  }
-
-  return { upgrade, websocket }
-}
-
-/**
- * Convert a Bun ServerWebSocket to an EffectWebSocket.
- *
- * This is a lower-level utility for custom WebSocket handling.
- * Most users should use createBunWSHandlers() instead.
- *
- * @param ws - The Bun ServerWebSocket instance
- * @returns An EffectWebSocket that can be used with makeGraphQLWSHandler
- */
-export const toBunEffectWebSocket = (
-  ws: ServerWebSocket<WebSocketData>
-): Effect.Effect<EffectWebSocket, never, never> =>
-  Effect.gen(function* () {
-    const messageQueue = yield* Queue.unbounded<string>()
-    const closedDeferred = yield* Deferred.make<CloseEvent, WebSocketError>()
-
-    const effectSocket: EffectWebSocket = {
-      protocol: "graphql-transport-ws",
-
-      send: (data: string) =>
-        Effect.try({
-          try: () => {
-            ws.send(data)
-          },
-          catch: (error) => new WebSocketError({ cause: error }),
-        }),
-
-      close: (code?: number, reason?: string) =>
-        Effect.sync(() => {
-          ws.close(code ?? 1000, reason ?? "")
-        }),
-
-      messages: Stream.fromQueue(messageQueue).pipe(Stream.catchAll(() => Stream.empty)),
-
-      closed: Deferred.await(closedDeferred),
-    }
-
-    // Store in WebSocket data for event handlers
-    ws.data = {
-      messageQueue,
-      closedDeferred,
-      effectSocket,
-    }
-
-    return effectSocket
-  })