@effect-gql/bun 0.1.0

package/dist/ws.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBunEffectWebSocket = exports.createBunWSHandlers = void 0;
+const effect_1 = require("effect");
+const core_1 = require("@effect-gql/core");
+/**
+ * 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,
+ * })
+ * ```
+ */
+const createBunWSHandlers = (schema, layer, options) => {
+    const path = options?.path ?? "/graphql";
+    const handler = (0, core_1.makeGraphQLWSHandler)(schema, layer, options);
+    // Track active connection handlers for cleanup
+    const activeHandlers = new Map();
+    const upgrade = (request, server) => {
+        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: {}, // Will be populated in open handler
+        });
+        return success;
+    };
+    const websocket = {
+        open: (ws) => {
+            // Create Effect-based socket wrapper
+            const setupEffect = effect_1.Effect.gen(function* () {
+                const messageQueue = yield* effect_1.Queue.unbounded();
+                const closedDeferred = yield* effect_1.Deferred.make();
+                const effectSocket = {
+                    protocol: ws.data?.effectSocket?.protocol || "graphql-transport-ws",
+                    send: (data) => effect_1.Effect.try({
+                        try: () => {
+                            ws.send(data);
+                        },
+                        catch: (error) => new core_1.WebSocketError({ cause: error }),
+                    }),
+                    close: (code, reason) => effect_1.Effect.sync(() => {
+                        ws.close(code ?? 1000, reason ?? "");
+                    }),
+                    messages: effect_1.Stream.fromQueue(messageQueue).pipe(effect_1.Stream.catchAll(() => effect_1.Stream.empty)),
+                    closed: effect_1.Deferred.await(closedDeferred),
+                };
+                // Store in WebSocket data
+                ws.data = {
+                    messageQueue,
+                    closedDeferred,
+                    effectSocket,
+                };
+                return effectSocket;
+            });
+            // Run setup and handler
+            const handlerPromise = effect_1.Effect.runPromise(setupEffect.pipe(effect_1.Effect.flatMap((effectSocket) => handler(effectSocket)), effect_1.Effect.catchAllCause(() => effect_1.Effect.void)));
+            activeHandlers.set(ws, handlerPromise);
+        },
+        message: (ws, message) => {
+            const data = ws.data;
+            if (data?.messageQueue) {
+                const messageStr = typeof message === "string" ? message : message.toString();
+                effect_1.Effect.runPromise(effect_1.Queue.offer(data.messageQueue, messageStr)).catch(() => {
+                    // Queue might be shutdown
+                });
+            }
+        },
+        close: (ws, code, reason) => {
+            const data = ws.data;
+            if (data) {
+                effect_1.Effect.runPromise(effect_1.Effect.all([
+                    effect_1.Queue.shutdown(data.messageQueue),
+                    effect_1.Deferred.succeed(data.closedDeferred, { code, reason }),
+                ])).catch(() => {
+                    // Already completed
+                });
+            }
+            activeHandlers.delete(ws);
+        },
+        error: (ws, error) => {
+            const data = ws.data;
+            if (data) {
+                effect_1.Effect.runPromise(effect_1.Deferred.fail(data.closedDeferred, new core_1.WebSocketError({ cause: error }))).catch(() => {
+                    // Already completed
+                });
+            }
+        },
+    };
+    return { upgrade, websocket };
+};
+exports.createBunWSHandlers = createBunWSHandlers;
+/**
+ * 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
+ */
+const toBunEffectWebSocket = (ws) => effect_1.Effect.gen(function* () {
+    const messageQueue = yield* effect_1.Queue.unbounded();
+    const closedDeferred = yield* effect_1.Deferred.make();
+    const effectSocket = {
+        protocol: "graphql-transport-ws",
+        send: (data) => effect_1.Effect.try({
+            try: () => {
+                ws.send(data);
+            },
+            catch: (error) => new core_1.WebSocketError({ cause: error }),
+        }),
+        close: (code, reason) => effect_1.Effect.sync(() => {
+            ws.close(code ?? 1000, reason ?? "");
+        }),
+        messages: effect_1.Stream.fromQueue(messageQueue).pipe(effect_1.Stream.catchAll(() => effect_1.Stream.empty)),
+        closed: effect_1.Deferred.await(closedDeferred),
+    };
+    // Store in WebSocket data for event handlers
+    ws.data = {
+        messageQueue,
+        closedDeferred,
+        effectSocket,
+    };
+    return effectSocket;
+});
+exports.toBunEffectWebSocket = toBunEffectWebSocket;
+//# sourceMappingURL=ws.js.map

package/dist/ws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws.js","sourceRoot":"","sources":["../src/ws.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@effect-gql/bun",
+  "version": "0.1.0",
+  "description": "Bun HTTP server integration for @effect-gql/core",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "peerDependencies": {
+    "@effect-gql/core": "^0.1.0",
+    "@effect/platform": "^0.94.0",
+    "@effect/platform-bun": "^0.87.0",
+    "effect": "^3.19.0",
+    "graphql": "^16.0.0"
+  },
+  "devDependencies": {
+    "@effect-gql/core": "*",
+    "@effect/platform": "^0.94.0",
+    "@effect/platform-bun": "^0.87.0",
+    "@types/bun": "latest",
+    "effect": "^3.19.13",
+    "graphql": "^16.0.0",
+    "graphql-ws": "^6.0.6",
+    "ws": "^8.18.0",
+    "@types/ws": "^8.5.0"
+  },
+  "keywords": [
+    "effect",
+    "graphql",
+    "bun",
+    "http",
+    "server"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:unit": "vitest run test/unit",
+    "test:integration": "vitest run test/integration",
+    "test:watch": "vitest"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { serve, type ServeOptions, type SubscriptionsConfig } from "./serve"
+
+// WebSocket subscription support
+export { createBunWSHandlers, toBunEffectWebSocket, type BunWSOptions } from "./ws"
+
+// SSE (Server-Sent Events) subscription support
+export { createBunSSEHandler, createBunSSEHandlers, type BunSSEOptions } from "./sse"

package/src/serve.ts

@@ -0,0 +1,182 @@
+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

@@ -0,0 +1,182 @@
+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,
+  }
+}