@effect-gql/web 0.1.0 → 1.1.0

package/README.md

@@ -0,0 +1,100 @@
+# Effect GraphQL
+
+A GraphQL framework for Effect-TS that brings full type safety, composability, and functional programming to your GraphQL servers.
+
+> **Note:** This is an experimental prototype exploring the integration between Effect Schema, Effect's service system, and GraphQL.
+
+## Features
+
+- **Type-Safe End-to-End** - Define schemas once with Effect Schema, get TypeScript types and GraphQL types automatically
+- **Effect-Powered Resolvers** - Resolvers are Effect programs with built-in error handling and service injection
+- **Immutable Builder** - Fluent, pipe-able API for composing schemas from reusable parts
+- **Service Integration** - Use Effect's Layer system for dependency injection
+
+## Installation
+
+```bash
+npm install @effect-gql/core effect graphql
+```
+
+## Quick Start
+
+```typescript
+import { Effect, Layer } from "effect"
+import * as S from "effect/Schema"
+import { GraphQLSchemaBuilder, execute } from "@effect-gql/core"
+
+// Define your schema with Effect Schema
+const UserSchema = S.Struct({
+  id: S.String,
+  name: S.String,
+  email: S.String,
+})
+
+// Build your GraphQL schema
+const schema = GraphQLSchemaBuilder.empty
+  .objectType({ name: "User", schema: UserSchema })
+  .query("users", {
+    type: S.Array(UserSchema),
+    resolve: () => Effect.succeed([
+      { id: "1", name: "Alice", email: "alice@example.com" },
+      { id: "2", name: "Bob", email: "bob@example.com" },
+    ]),
+  })
+  .query("user", {
+    type: UserSchema,
+    args: S.Struct({ id: S.String }),
+    resolve: (args) => Effect.succeed({
+      id: args.id,
+      name: "Alice",
+      email: "alice@example.com",
+    }),
+  })
+  .buildSchema()
+
+// Execute a query
+const result = await Effect.runPromise(
+  execute(schema, Layer.empty)(`
+    query {
+      users { id name email }
+    }
+  `)
+)
+```
+
+## Documentation
+
+For full documentation, guides, and API reference, visit the [documentation site](https://nrf110.github.io/effect-gql/).
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run tests
+npm test
+
+# Development mode with watch
+npm run dev
+```
+
+## Contributing
+
+Contributions are welcome! Here's how you can help:
+
+1. **Report bugs** - Open an issue describing the problem and steps to reproduce
+2. **Suggest features** - Open an issue describing your idea
+3. **Submit PRs** - Fork the repo, make your changes, and open a pull request
+
+Please ensure your code:
+- Passes all existing tests (`npm test`)
+- Includes tests for new functionality
+- Follows the existing code style
+
+## License
+
+MIT

package/index.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+var platform = require('@effect/platform');
+var effect = require('effect');
+var core = require('@effect-gql/core');
+
+// src/handler.ts
+var toHandler = (router, layer) => {
+  return platform.HttpApp.toWebHandlerLayer(router, layer);
+};
+var createSSEHandler = (schema, layer, options) => {
+  const sseHandler = core.makeGraphQLSSEHandler(schema, layer, options);
+  return async (request) => {
+    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" } }
+      );
+    }
+    let subscriptionRequest;
+    try {
+      const body = await request.json();
+      if (typeof body.query !== "string") {
+        throw new Error("Missing query");
+      }
+      subscriptionRequest = {
+        query: body.query,
+        variables: body.variables,
+        operationName: body.operationName,
+        extensions: body.extensions
+      };
+    } catch {
+      return new Response(
+        JSON.stringify({
+          errors: [{ message: "Invalid GraphQL request body" }]
+        }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const eventStream = sseHandler(subscriptionRequest, request.headers);
+    const readableStream = new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder();
+        await effect.Effect.runPromise(
+          effect.Stream.runForEach(
+            eventStream,
+            (event) => effect.Effect.sync(() => {
+              const message = core.formatSSEMessage(event);
+              controller.enqueue(encoder.encode(message));
+            })
+          ).pipe(
+            effect.Effect.catchAll((error) => effect.Effect.logWarning("SSE stream error", error)),
+            effect.Effect.ensuring(effect.Effect.sync(() => controller.close()))
+          )
+        );
+      }
+    });
+    return new Response(readableStream, {
+      status: 200,
+      headers: core.SSE_HEADERS
+    });
+  };
+};
+var createSSEHandlers = (schema, layer, options) => {
+  const path = options?.path ?? "/graphql/stream";
+  const handler = createSSEHandler(schema, layer, options);
+  return {
+    path,
+    shouldHandle: (request) => {
+      if (request.method !== "POST") return false;
+      const url = new URL(request.url);
+      return url.pathname === path;
+    },
+    handle: handler
+  };
+};
+
+exports.createSSEHandler = createSSEHandler;
+exports.createSSEHandlers = createSSEHandlers;
+exports.toHandler = toHandler;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/handler.ts","../src/sse.ts"],"names":["HttpApp","makeGraphQLSSEHandler","Effect","Stream","formatSSEMessage","SSE_HEADERS"],"mappings":"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","file":"index.cjs","sourcesContent":["import { Context, Layer } from \"effect\"\nimport { HttpApp, HttpRouter } from \"@effect/platform\"\n\n/**\n * Result of creating a web handler\n */\nexport interface WebHandler {\n  /**\n   * Handle a web standard Request and return a Response.\n   * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.\n   */\n  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>\n\n  /**\n   * Dispose of the handler and clean up resources.\n   * Call this when shutting down the worker.\n   */\n  readonly dispose: () => Promise<void>\n}\n\n/**\n * Create a web standard Request/Response handler from an HttpRouter.\n *\n * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes\n * that use the Web standard fetch API.\n *\n * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)\n * @param layer - Layer providing any services required by the router\n * @returns A handler object with handler() and dispose() methods\n *\n * @example Cloudflare Workers\n * ```typescript\n * import { makeGraphQLRouter } from \"@effect-gql/core\"\n * import { toHandler } from \"@effect-gql/web\"\n * import { Layer } from \"effect\"\n *\n * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })\n * const { handler } = toHandler(router, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     return await handler(request)\n *   }\n * }\n * ```\n *\n * @example Deno\n * ```typescript\n * import { makeGraphQLRouter } from \"@effect-gql/core\"\n * import { toHandler } from \"@effect-gql/web\"\n *\n * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })\n * const { handler } = toHandler(router, Layer.empty)\n *\n * Deno.serve((request) => handler(request))\n * ```\n */\nexport const toHandler = <E, R, RE>(\n  router: HttpRouter.HttpRouter<E, R>,\n  layer: Layer.Layer<R, RE>\n): WebHandler => {\n  return HttpApp.toWebHandlerLayer(router, layer)\n}\n","import { Effect, Layer, Stream } from \"effect\"\nimport { GraphQLSchema } from \"graphql\"\nimport {\n  makeGraphQLSSEHandler,\n  formatSSEMessage,\n  SSE_HEADERS,\n  type GraphQLSSEOptions,\n  type SSESubscriptionRequest,\n} from \"@effect-gql/core\"\n\n/**\n * Options for Web SSE handler\n */\nexport interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {\n  /**\n   * Path for SSE connections.\n   * @default \"/graphql/stream\"\n   */\n  readonly path?: string\n}\n\n/**\n * Create an SSE handler for web standard environments.\n *\n * This handler is designed for Cloudflare Workers, Deno, and other runtimes\n * that use the Web standard fetch API. It returns a streaming Response for\n * SSE subscription requests.\n *\n * @param schema - The GraphQL schema with subscription definitions\n * @param layer - Effect layer providing services required by resolvers\n * @param options - Optional lifecycle hooks and configuration\n * @returns A function that handles SSE requests and returns a Response\n *\n * @example Cloudflare Workers\n * ```typescript\n * import { toHandler } from \"@effect-gql/web\"\n * import { createSSEHandler } from \"@effect-gql/web\"\n *\n * const graphqlHandler = toHandler(router, Layer.empty)\n * const sseHandler = createSSEHandler(schema, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     const url = new URL(request.url)\n *\n *     // Handle SSE subscriptions\n *     if (url.pathname === \"/graphql/stream\" && request.method === \"POST\") {\n *       return await sseHandler(request)\n *     }\n *\n *     // Handle regular GraphQL requests\n *     return await graphqlHandler.handler(request)\n *   }\n * }\n * ```\n *\n * @example Deno\n * ```typescript\n * import { toHandler, createSSEHandler } from \"@effect-gql/web\"\n *\n * const graphqlHandler = toHandler(router, Layer.empty)\n * const sseHandler = createSSEHandler(schema, Layer.empty)\n *\n * Deno.serve((request) => {\n *   const url = new URL(request.url)\n *\n *   if (url.pathname === \"/graphql/stream\" && request.method === \"POST\") {\n *     return sseHandler(request)\n *   }\n *\n *   return graphqlHandler.handler(request)\n * })\n * ```\n */\nexport const createSSEHandler = <R>(\n  schema: GraphQLSchema,\n  layer: Layer.Layer<R>,\n  options?: WebSSEOptions<R>\n): ((request: Request) => Promise<Response>) => {\n  const sseHandler = makeGraphQLSSEHandler(schema, layer, options)\n\n  return async (request: Request): Promise<Response> => {\n    // Check Accept header for SSE support\n    const accept = request.headers.get(\"accept\") ?? \"\"\n    if (!accept.includes(\"text/event-stream\") && !accept.includes(\"*/*\")) {\n      return new Response(\n        JSON.stringify({\n          errors: [{ message: \"Client must accept text/event-stream\" }],\n        }),\n        { status: 406, headers: { \"Content-Type\": \"application/json\" } }\n      )\n    }\n\n    // Read and parse the request body\n    let subscriptionRequest: SSESubscriptionRequest\n    try {\n      const body = (await request.json()) as Record<string, unknown>\n      if (typeof body.query !== \"string\") {\n        throw new Error(\"Missing query\")\n      }\n      subscriptionRequest = {\n        query: body.query,\n        variables: body.variables as Record<string, unknown> | undefined,\n        operationName: body.operationName as string | undefined,\n        extensions: body.extensions as Record<string, unknown> | undefined,\n      }\n    } catch {\n      return new Response(\n        JSON.stringify({\n          errors: [{ message: \"Invalid GraphQL request body\" }],\n        }),\n        { status: 400, headers: { \"Content-Type\": \"application/json\" } }\n      )\n    }\n\n    // Get the event stream\n    const eventStream = sseHandler(subscriptionRequest, request.headers)\n\n    // Create a ReadableStream from the Effect Stream\n    const readableStream = new ReadableStream({\n      async start(controller) {\n        const encoder = new TextEncoder()\n\n        await Effect.runPromise(\n          Stream.runForEach(eventStream, (event) =>\n            Effect.sync(() => {\n              const message = formatSSEMessage(event)\n              controller.enqueue(encoder.encode(message))\n            })\n          ).pipe(\n            Effect.catchAll((error) => Effect.logWarning(\"SSE stream error\", error)),\n            Effect.ensuring(Effect.sync(() => controller.close()))\n          )\n        )\n      },\n    })\n\n    return new Response(readableStream, {\n      status: 200,\n      headers: SSE_HEADERS,\n    })\n  }\n}\n\n/**\n * Create SSE handlers with path matching for web standard environments.\n *\n * This returns an object with methods to check if a request should be\n * handled as SSE and to handle it.\n *\n * @param schema - The GraphQL schema with subscription definitions\n * @param layer - Effect layer providing services required by resolvers\n * @param options - Optional lifecycle hooks and configuration\n *\n * @example\n * ```typescript\n * const sse = createSSEHandlers(schema, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     if (sse.shouldHandle(request)) {\n *       return sse.handle(request)\n *     }\n *     // Handle other requests...\n *   }\n * }\n * ```\n */\nexport const createSSEHandlers = <R>(\n  schema: GraphQLSchema,\n  layer: Layer.Layer<R>,\n  options?: WebSSEOptions<R>\n): {\n  /** Path this SSE handler responds to */\n  readonly path: string\n  /** Check if a request should be handled as SSE */\n  shouldHandle: (request: Request) => boolean\n  /** Handle an SSE request */\n  handle: (request: Request) => Promise<Response>\n} => {\n  const path = options?.path ?? \"/graphql/stream\"\n  const handler = createSSEHandler(schema, layer, options)\n\n  return {\n    path,\n    shouldHandle: (request: Request) => {\n      if (request.method !== \"POST\") return false\n      const url = new URL(request.url)\n      return url.pathname === path\n    },\n    handle: handler,\n  }\n}\n"]}

package/{dist/sse.d.ts → index.d.cts}

@@ -1,10 +1,66 @@
-import { Layer } from "effect";
-import { GraphQLSchema } from "graphql";
-import { type GraphQLSSEOptions } from "@effect-gql/core";
+import { Layer, Context } from 'effect';
+import { HttpRouter } from '@effect/platform';
+import { GraphQLSchema } from 'graphql';
+import { GraphQLSSEOptions } from '@effect-gql/core';
+
+/**
+ * Result of creating a web handler
+ */
+interface WebHandler {
+    /**
+     * Handle a web standard Request and return a Response.
+     * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.
+     */
+    readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
+    /**
+     * Dispose of the handler and clean up resources.
+     * Call this when shutting down the worker.
+     */
+    readonly dispose: () => Promise<void>;
+}
+/**
+ * Create a web standard Request/Response handler from an HttpRouter.
+ *
+ * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes
+ * that use the Web standard fetch API.
+ *
+ * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)
+ * @param layer - Layer providing any services required by the router
+ * @returns A handler object with handler() and dispose() methods
+ *
+ * @example Cloudflare Workers
+ * ```typescript
+ * import { makeGraphQLRouter } from "@effect-gql/core"
+ * import { toHandler } from "@effect-gql/web"
+ * import { Layer } from "effect"
+ *
+ * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
+ * const { handler } = toHandler(router, Layer.empty)
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     return await handler(request)
+ *   }
+ * }
+ * ```
+ *
+ * @example Deno
+ * ```typescript
+ * import { makeGraphQLRouter } from "@effect-gql/core"
+ * import { toHandler } from "@effect-gql/web"
+ *
+ * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
+ * const { handler } = toHandler(router, Layer.empty)
+ *
+ * Deno.serve((request) => handler(request))
+ * ```
+ */
+declare const toHandler: <E, R, RE>(router: HttpRouter.HttpRouter<E, R>, layer: Layer.Layer<R, RE>) => WebHandler;
+
 /**
  * Options for Web SSE handler
  */
-export interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {
+interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {
     /**
      * Path for SSE connections.
      * @default "/graphql/stream"
@@ -64,7 +120,7 @@ export interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {
  * })
  * ```
  */
-export declare const createSSEHandler: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<R>) => ((request: Request) => Promise<Response>);
+declare const createSSEHandler: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<R>) => ((request: Request) => Promise<Response>);
 /**
  * Create SSE handlers with path matching for web standard environments.
  *
@@ -89,7 +145,7 @@ export declare const createSSEHandler: <R>(schema: GraphQLSchema, layer: Layer.L
  * }
  * ```
  */
-export declare const createSSEHandlers: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<R>) => {
+declare const createSSEHandlers: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<R>) => {
     /** Path this SSE handler responds to */
     readonly path: string;
     /** Check if a request should be handled as SSE */
@@ -97,4 +153,5 @@ export declare const createSSEHandlers: <R>(schema: GraphQLSchema, layer: Layer.
     /** Handle an SSE request */
     handle: (request: Request) => Promise<Response>;
 };
-//# sourceMappingURL=sse.d.ts.map
+
+export { type WebHandler, type WebSSEOptions, createSSEHandler, createSSEHandlers, toHandler };

package/index.d.ts

@@ -0,0 +1,157 @@
+import { Layer, Context } from 'effect';
+import { HttpRouter } from '@effect/platform';
+import { GraphQLSchema } from 'graphql';
+import { GraphQLSSEOptions } from '@effect-gql/core';
+
+/**
+ * Result of creating a web handler
+ */
+interface WebHandler {
+    /**
+     * Handle a web standard Request and return a Response.
+     * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.
+     */
+    readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
+    /**
+     * Dispose of the handler and clean up resources.
+     * Call this when shutting down the worker.
+     */
+    readonly dispose: () => Promise<void>;
+}
+/**
+ * Create a web standard Request/Response handler from an HttpRouter.
+ *
+ * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes
+ * that use the Web standard fetch API.
+ *
+ * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)
+ * @param layer - Layer providing any services required by the router
+ * @returns A handler object with handler() and dispose() methods
+ *
+ * @example Cloudflare Workers
+ * ```typescript
+ * import { makeGraphQLRouter } from "@effect-gql/core"
+ * import { toHandler } from "@effect-gql/web"
+ * import { Layer } from "effect"
+ *
+ * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
+ * const { handler } = toHandler(router, Layer.empty)
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     return await handler(request)
+ *   }
+ * }
+ * ```
+ *
+ * @example Deno
+ * ```typescript
+ * import { makeGraphQLRouter } from "@effect-gql/core"
+ * import { toHandler } from "@effect-gql/web"
+ *
+ * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
+ * const { handler } = toHandler(router, Layer.empty)
+ *
+ * Deno.serve((request) => handler(request))
+ * ```
+ */
+declare const toHandler: <E, R, RE>(router: HttpRouter.HttpRouter<E, R>, layer: Layer.Layer<R, RE>) => WebHandler;
+
+/**
+ * Options for Web SSE handler
+ */
+interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {
+    /**
+     * Path for SSE connections.
+     * @default "/graphql/stream"
+     */
+    readonly path?: string;
+}
+/**
+ * Create an SSE handler for web standard environments.
+ *
+ * This handler is designed for Cloudflare Workers, Deno, and other runtimes
+ * that use the Web standard fetch API. It returns a streaming Response for
+ * SSE subscription requests.
+ *
+ * @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 Cloudflare Workers
+ * ```typescript
+ * import { toHandler } from "@effect-gql/web"
+ * import { createSSEHandler } from "@effect-gql/web"
+ *
+ * const graphqlHandler = toHandler(router, Layer.empty)
+ * const sseHandler = createSSEHandler(schema, Layer.empty)
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     const url = new URL(request.url)
+ *
+ *     // Handle SSE subscriptions
+ *     if (url.pathname === "/graphql/stream" && request.method === "POST") {
+ *       return await sseHandler(request)
+ *     }
+ *
+ *     // Handle regular GraphQL requests
+ *     return await graphqlHandler.handler(request)
+ *   }
+ * }
+ * ```
+ *
+ * @example Deno
+ * ```typescript
+ * import { toHandler, createSSEHandler } from "@effect-gql/web"
+ *
+ * const graphqlHandler = toHandler(router, Layer.empty)
+ * const sseHandler = createSSEHandler(schema, Layer.empty)
+ *
+ * Deno.serve((request) => {
+ *   const url = new URL(request.url)
+ *
+ *   if (url.pathname === "/graphql/stream" && request.method === "POST") {
+ *     return sseHandler(request)
+ *   }
+ *
+ *   return graphqlHandler.handler(request)
+ * })
+ * ```
+ */
+declare const createSSEHandler: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<R>) => ((request: Request) => Promise<Response>);
+/**
+ * Create SSE handlers with path matching for web standard environments.
+ *
+ * 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 sse = createSSEHandlers(schema, Layer.empty)
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     if (sse.shouldHandle(request)) {
+ *       return sse.handle(request)
+ *     }
+ *     // Handle other requests...
+ *   }
+ * }
+ * ```
+ */
+declare const createSSEHandlers: <R>(schema: GraphQLSchema, layer: Layer.Layer<R>, options?: WebSSEOptions<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>;
+};
+
+export { type WebHandler, type WebSSEOptions, createSSEHandler, createSSEHandlers, toHandler };

package/index.js

@@ -0,0 +1,81 @@
+import { HttpApp } from '@effect/platform';
+import { Effect, Stream } from 'effect';
+import { makeGraphQLSSEHandler, formatSSEMessage, SSE_HEADERS } from '@effect-gql/core';
+
+// src/handler.ts
+var toHandler = (router, layer) => {
+  return HttpApp.toWebHandlerLayer(router, layer);
+};
+var createSSEHandler = (schema, layer, options) => {
+  const sseHandler = makeGraphQLSSEHandler(schema, layer, options);
+  return async (request) => {
+    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" } }
+      );
+    }
+    let subscriptionRequest;
+    try {
+      const body = await request.json();
+      if (typeof body.query !== "string") {
+        throw new Error("Missing query");
+      }
+      subscriptionRequest = {
+        query: body.query,
+        variables: body.variables,
+        operationName: body.operationName,
+        extensions: body.extensions
+      };
+    } catch {
+      return new Response(
+        JSON.stringify({
+          errors: [{ message: "Invalid GraphQL request body" }]
+        }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const eventStream = sseHandler(subscriptionRequest, request.headers);
+    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
+    });
+  };
+};
+var createSSEHandlers = (schema, layer, options) => {
+  const path = options?.path ?? "/graphql/stream";
+  const handler = createSSEHandler(schema, layer, options);
+  return {
+    path,
+    shouldHandle: (request) => {
+      if (request.method !== "POST") return false;
+      const url = new URL(request.url);
+      return url.pathname === path;
+    },
+    handle: handler
+  };
+};
+
+export { createSSEHandler, createSSEHandlers, toHandler };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/handler.ts","../src/sse.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import { Context, Layer } from \"effect\"\nimport { HttpApp, HttpRouter } from \"@effect/platform\"\n\n/**\n * Result of creating a web handler\n */\nexport interface WebHandler {\n  /**\n   * Handle a web standard Request and return a Response.\n   * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.\n   */\n  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>\n\n  /**\n   * Dispose of the handler and clean up resources.\n   * Call this when shutting down the worker.\n   */\n  readonly dispose: () => Promise<void>\n}\n\n/**\n * Create a web standard Request/Response handler from an HttpRouter.\n *\n * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes\n * that use the Web standard fetch API.\n *\n * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)\n * @param layer - Layer providing any services required by the router\n * @returns A handler object with handler() and dispose() methods\n *\n * @example Cloudflare Workers\n * ```typescript\n * import { makeGraphQLRouter } from \"@effect-gql/core\"\n * import { toHandler } from \"@effect-gql/web\"\n * import { Layer } from \"effect\"\n *\n * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })\n * const { handler } = toHandler(router, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     return await handler(request)\n *   }\n * }\n * ```\n *\n * @example Deno\n * ```typescript\n * import { makeGraphQLRouter } from \"@effect-gql/core\"\n * import { toHandler } from \"@effect-gql/web\"\n *\n * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })\n * const { handler } = toHandler(router, Layer.empty)\n *\n * Deno.serve((request) => handler(request))\n * ```\n */\nexport const toHandler = <E, R, RE>(\n  router: HttpRouter.HttpRouter<E, R>,\n  layer: Layer.Layer<R, RE>\n): WebHandler => {\n  return HttpApp.toWebHandlerLayer(router, layer)\n}\n","import { Effect, Layer, Stream } from \"effect\"\nimport { GraphQLSchema } from \"graphql\"\nimport {\n  makeGraphQLSSEHandler,\n  formatSSEMessage,\n  SSE_HEADERS,\n  type GraphQLSSEOptions,\n  type SSESubscriptionRequest,\n} from \"@effect-gql/core\"\n\n/**\n * Options for Web SSE handler\n */\nexport interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {\n  /**\n   * Path for SSE connections.\n   * @default \"/graphql/stream\"\n   */\n  readonly path?: string\n}\n\n/**\n * Create an SSE handler for web standard environments.\n *\n * This handler is designed for Cloudflare Workers, Deno, and other runtimes\n * that use the Web standard fetch API. It returns a streaming Response for\n * SSE subscription requests.\n *\n * @param schema - The GraphQL schema with subscription definitions\n * @param layer - Effect layer providing services required by resolvers\n * @param options - Optional lifecycle hooks and configuration\n * @returns A function that handles SSE requests and returns a Response\n *\n * @example Cloudflare Workers\n * ```typescript\n * import { toHandler } from \"@effect-gql/web\"\n * import { createSSEHandler } from \"@effect-gql/web\"\n *\n * const graphqlHandler = toHandler(router, Layer.empty)\n * const sseHandler = createSSEHandler(schema, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     const url = new URL(request.url)\n *\n *     // Handle SSE subscriptions\n *     if (url.pathname === \"/graphql/stream\" && request.method === \"POST\") {\n *       return await sseHandler(request)\n *     }\n *\n *     // Handle regular GraphQL requests\n *     return await graphqlHandler.handler(request)\n *   }\n * }\n * ```\n *\n * @example Deno\n * ```typescript\n * import { toHandler, createSSEHandler } from \"@effect-gql/web\"\n *\n * const graphqlHandler = toHandler(router, Layer.empty)\n * const sseHandler = createSSEHandler(schema, Layer.empty)\n *\n * Deno.serve((request) => {\n *   const url = new URL(request.url)\n *\n *   if (url.pathname === \"/graphql/stream\" && request.method === \"POST\") {\n *     return sseHandler(request)\n *   }\n *\n *   return graphqlHandler.handler(request)\n * })\n * ```\n */\nexport const createSSEHandler = <R>(\n  schema: GraphQLSchema,\n  layer: Layer.Layer<R>,\n  options?: WebSSEOptions<R>\n): ((request: Request) => Promise<Response>) => {\n  const sseHandler = makeGraphQLSSEHandler(schema, layer, options)\n\n  return async (request: Request): Promise<Response> => {\n    // Check Accept header for SSE support\n    const accept = request.headers.get(\"accept\") ?? \"\"\n    if (!accept.includes(\"text/event-stream\") && !accept.includes(\"*/*\")) {\n      return new Response(\n        JSON.stringify({\n          errors: [{ message: \"Client must accept text/event-stream\" }],\n        }),\n        { status: 406, headers: { \"Content-Type\": \"application/json\" } }\n      )\n    }\n\n    // Read and parse the request body\n    let subscriptionRequest: SSESubscriptionRequest\n    try {\n      const body = (await request.json()) as Record<string, unknown>\n      if (typeof body.query !== \"string\") {\n        throw new Error(\"Missing query\")\n      }\n      subscriptionRequest = {\n        query: body.query,\n        variables: body.variables as Record<string, unknown> | undefined,\n        operationName: body.operationName as string | undefined,\n        extensions: body.extensions as Record<string, unknown> | undefined,\n      }\n    } catch {\n      return new Response(\n        JSON.stringify({\n          errors: [{ message: \"Invalid GraphQL request body\" }],\n        }),\n        { status: 400, headers: { \"Content-Type\": \"application/json\" } }\n      )\n    }\n\n    // Get the event stream\n    const eventStream = sseHandler(subscriptionRequest, request.headers)\n\n    // Create a ReadableStream from the Effect Stream\n    const readableStream = new ReadableStream({\n      async start(controller) {\n        const encoder = new TextEncoder()\n\n        await Effect.runPromise(\n          Stream.runForEach(eventStream, (event) =>\n            Effect.sync(() => {\n              const message = formatSSEMessage(event)\n              controller.enqueue(encoder.encode(message))\n            })\n          ).pipe(\n            Effect.catchAll((error) => Effect.logWarning(\"SSE stream error\", error)),\n            Effect.ensuring(Effect.sync(() => controller.close()))\n          )\n        )\n      },\n    })\n\n    return new Response(readableStream, {\n      status: 200,\n      headers: SSE_HEADERS,\n    })\n  }\n}\n\n/**\n * Create SSE handlers with path matching for web standard environments.\n *\n * This returns an object with methods to check if a request should be\n * handled as SSE and to handle it.\n *\n * @param schema - The GraphQL schema with subscription definitions\n * @param layer - Effect layer providing services required by resolvers\n * @param options - Optional lifecycle hooks and configuration\n *\n * @example\n * ```typescript\n * const sse = createSSEHandlers(schema, Layer.empty)\n *\n * export default {\n *   async fetch(request: Request) {\n *     if (sse.shouldHandle(request)) {\n *       return sse.handle(request)\n *     }\n *     // Handle other requests...\n *   }\n * }\n * ```\n */\nexport const createSSEHandlers = <R>(\n  schema: GraphQLSchema,\n  layer: Layer.Layer<R>,\n  options?: WebSSEOptions<R>\n): {\n  /** Path this SSE handler responds to */\n  readonly path: string\n  /** Check if a request should be handled as SSE */\n  shouldHandle: (request: Request) => boolean\n  /** Handle an SSE request */\n  handle: (request: Request) => Promise<Response>\n} => {\n  const path = options?.path ?? \"/graphql/stream\"\n  const handler = createSSEHandler(schema, layer, options)\n\n  return {\n    path,\n    shouldHandle: (request: Request) => {\n      if (request.method !== \"POST\") return false\n      const url = new URL(request.url)\n      return url.pathname === path\n    },\n    handle: handler,\n  }\n}\n"]}

package/package.json

@@ -1,30 +1,26 @@
 {
   "name": "@effect-gql/web",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Web standard handler for @effect-gql/core - works with Cloudflare Workers, Deno, and other WASM runtimes",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "repository": {
+    "url": "https://github.com/nrf110/effect-gql"
+  },
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "dist/index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
     }
   },
-  "files": [
-    "dist",
-    "src"
-  ],
   "peerDependencies": {
-    "@effect-gql/core": "^0.1.0",
+    "@effect-gql/core": "^1.1.0",
     "@effect/platform": "^0.94.0",
     "effect": "^3.19.0"
   },
-  "devDependencies": {
-    "@effect-gql/core": "*",
-    "@effect/platform": "^0.94.0",
-    "effect": "^3.19.13",
-    "graphql": "^16.0.0"
-  },
   "keywords": [
     "effect",
     "graphql",
@@ -34,13 +30,5 @@
     "web",
     "deno"
   ],
-  "license": "MIT",
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:unit": "vitest run test/unit",
-    "test:watch": "vitest"
-  }
-}
+  "license": "MIT"
+}

package/dist/handler.d.ts

@@ -1,56 +0,0 @@
-import { Context, Layer } from "effect";
-import { HttpRouter } from "@effect/platform";
-/**
- * Result of creating a web handler
- */
-export interface WebHandler {
-    /**
-     * Handle a web standard Request and return a Response.
-     * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.
-     */
-    readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>;
-    /**
-     * Dispose of the handler and clean up resources.
-     * Call this when shutting down the worker.
-     */
-    readonly dispose: () => Promise<void>;
-}
-/**
- * Create a web standard Request/Response handler from an HttpRouter.
- *
- * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes
- * that use the Web standard fetch API.
- *
- * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)
- * @param layer - Layer providing any services required by the router
- * @returns A handler object with handler() and dispose() methods
- *
- * @example Cloudflare Workers
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- * import { Layer } from "effect"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     return await handler(request)
- *   }
- * }
- * ```
- *
- * @example Deno
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * Deno.serve((request) => handler(request))
- * ```
- */
-export declare const toHandler: <E, R, RE>(router: HttpRouter.HttpRouter<E, R>, layer: Layer.Layer<R, RE>) => WebHandler;
-//# sourceMappingURL=handler.d.ts.map

package/dist/handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAW,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEtD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAE3F;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,EAAE,EAChC,QAAQ,UAAU,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EACnC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KACxB,UAEF,CAAA"}

package/dist/handler.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toHandler = void 0;
-const platform_1 = require("@effect/platform");
-/**
- * Create a web standard Request/Response handler from an HttpRouter.
- *
- * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes
- * that use the Web standard fetch API.
- *
- * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)
- * @param layer - Layer providing any services required by the router
- * @returns A handler object with handler() and dispose() methods
- *
- * @example Cloudflare Workers
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- * import { Layer } from "effect"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     return await handler(request)
- *   }
- * }
- * ```
- *
- * @example Deno
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * Deno.serve((request) => handler(request))
- * ```
- */
-const toHandler = (router, layer) => {
-    return platform_1.HttpApp.toWebHandlerLayer(router, layer);
-};
-exports.toHandler = toHandler;
-//# sourceMappingURL=handler.js.map

package/dist/handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handler.js","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":";;;AACA,+CAAsD;AAmBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACI,MAAM,SAAS,GAAG,CACvB,MAAmC,EACnC,KAAyB,EACb,EAAE;IACd,OAAO,kBAAO,CAAC,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AACjD,CAAC,CAAA;AALY,QAAA,SAAS,aAKrB"}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { toHandler, type WebHandler } from "./handler";
-export { createSSEHandler, createSSEHandlers, type WebSSEOptions } from "./sse";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,WAAW,CAAA;AAGtD,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,OAAO,CAAA"}

package/dist/index.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSSEHandlers = exports.createSSEHandler = exports.toHandler = void 0;
-var handler_1 = require("./handler");
-Object.defineProperty(exports, "toHandler", { enumerable: true, get: function () { return handler_1.toHandler; } });
-// SSE (Server-Sent Events) subscription support
-var sse_1 = require("./sse");
-Object.defineProperty(exports, "createSSEHandler", { enumerable: true, get: function () { return sse_1.createSSEHandler; } });
-Object.defineProperty(exports, "createSSEHandlers", { enumerable: true, get: function () { return sse_1.createSSEHandlers; } });
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qCAAsD;AAA7C,oGAAA,SAAS,OAAA;AAElB,gDAAgD;AAChD,6BAA+E;AAAtE,uGAAA,gBAAgB,OAAA;AAAE,wGAAA,iBAAiB,OAAA"}

package/dist/sse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAU,MAAM,QAAQ,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAIL,KAAK,iBAAiB,EAEvB,MAAM,kBAAkB,CAAA;AAEzB;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC5D;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,QAAQ,aAAa,EACrB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACrB,UAAU,aAAa,CAAC,CAAC,CAAC,KACzB,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAgE1C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EACjC,QAAQ,aAAa,EACrB,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EACrB,UAAU,aAAa,CAAC,CAAC,CAAC,KACzB;IACD,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,kDAAkD;IAClD,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,4BAA4B;IAC5B,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;CAchD,CAAA"}

package/dist/sse.js

@@ -1,146 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSSEHandlers = exports.createSSEHandler = void 0;
-const effect_1 = require("effect");
-const core_1 = require("@effect-gql/core");
-/**
- * Create an SSE handler for web standard environments.
- *
- * This handler is designed for Cloudflare Workers, Deno, and other runtimes
- * that use the Web standard fetch API. It returns a streaming Response for
- * SSE subscription requests.
- *
- * @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 Cloudflare Workers
- * ```typescript
- * import { toHandler } from "@effect-gql/web"
- * import { createSSEHandler } from "@effect-gql/web"
- *
- * const graphqlHandler = toHandler(router, Layer.empty)
- * const sseHandler = createSSEHandler(schema, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     const url = new URL(request.url)
- *
- *     // Handle SSE subscriptions
- *     if (url.pathname === "/graphql/stream" && request.method === "POST") {
- *       return await sseHandler(request)
- *     }
- *
- *     // Handle regular GraphQL requests
- *     return await graphqlHandler.handler(request)
- *   }
- * }
- * ```
- *
- * @example Deno
- * ```typescript
- * import { toHandler, createSSEHandler } from "@effect-gql/web"
- *
- * const graphqlHandler = toHandler(router, Layer.empty)
- * const sseHandler = createSSEHandler(schema, Layer.empty)
- *
- * Deno.serve((request) => {
- *   const url = new URL(request.url)
- *
- *   if (url.pathname === "/graphql/stream" && request.method === "POST") {
- *     return sseHandler(request)
- *   }
- *
- *   return graphqlHandler.handler(request)
- * })
- * ```
- */
-const createSSEHandler = (schema, layer, options) => {
-    const sseHandler = (0, core_1.makeGraphQLSSEHandler)(schema, layer, options);
-    return async (request) => {
-        // 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;
-        try {
-            const body = (await request.json());
-            if (typeof body.query !== "string") {
-                throw new Error("Missing query");
-            }
-            subscriptionRequest = {
-                query: body.query,
-                variables: body.variables,
-                operationName: body.operationName,
-                extensions: body.extensions,
-            };
-        }
-        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_1.Effect.runPromise(effect_1.Stream.runForEach(eventStream, (event) => effect_1.Effect.sync(() => {
-                    const message = (0, core_1.formatSSEMessage)(event);
-                    controller.enqueue(encoder.encode(message));
-                })).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.logWarning("SSE stream error", error)), effect_1.Effect.ensuring(effect_1.Effect.sync(() => controller.close()))));
-            },
-        });
-        return new Response(readableStream, {
-            status: 200,
-            headers: core_1.SSE_HEADERS,
-        });
-    };
-};
-exports.createSSEHandler = createSSEHandler;
-/**
- * Create SSE handlers with path matching for web standard environments.
- *
- * 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 sse = createSSEHandlers(schema, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     if (sse.shouldHandle(request)) {
- *       return sse.handle(request)
- *     }
- *     // Handle other requests...
- *   }
- * }
- * ```
- */
-const createSSEHandlers = (schema, layer, options) => {
-    const path = options?.path ?? "/graphql/stream";
-    const handler = (0, exports.createSSEHandler)(schema, layer, options);
-    return {
-        path,
-        shouldHandle: (request) => {
-            if (request.method !== "POST")
-                return false;
-            const url = new URL(request.url);
-            return url.pathname === path;
-        },
-        handle: handler,
-    };
-};
-exports.createSSEHandlers = createSSEHandlers;
-//# sourceMappingURL=sse.js.map

package/dist/sse.js.map

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

package/src/handler.ts

@@ -1,63 +0,0 @@
-import { Context, Layer } from "effect"
-import { HttpApp, HttpRouter } from "@effect/platform"
-
-/**
- * Result of creating a web handler
- */
-export interface WebHandler {
-  /**
-   * Handle a web standard Request and return a Response.
-   * This is the main entry point for Cloudflare Workers, Deno, and other WASM runtimes.
-   */
-  readonly handler: (request: Request, context?: Context.Context<never>) => Promise<Response>
-
-  /**
-   * Dispose of the handler and clean up resources.
-   * Call this when shutting down the worker.
-   */
-  readonly dispose: () => Promise<void>
-}
-
-/**
- * Create a web standard Request/Response handler from an HttpRouter.
- *
- * This is designed for Cloudflare Workers, Deno, and other WASM-based runtimes
- * that use the Web standard fetch API.
- *
- * @param router - The HttpRouter to handle (typically from makeGraphQLRouter or toRouter)
- * @param layer - Layer providing any services required by the router
- * @returns A handler object with handler() and dispose() methods
- *
- * @example Cloudflare Workers
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- * import { Layer } from "effect"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     return await handler(request)
- *   }
- * }
- * ```
- *
- * @example Deno
- * ```typescript
- * import { makeGraphQLRouter } from "@effect-gql/core"
- * import { toHandler } from "@effect-gql/web"
- *
- * const router = makeGraphQLRouter(schema, Layer.empty, { graphiql: true })
- * const { handler } = toHandler(router, Layer.empty)
- *
- * Deno.serve((request) => handler(request))
- * ```
- */
-export const toHandler = <E, R, RE>(
-  router: HttpRouter.HttpRouter<E, R>,
-  layer: Layer.Layer<R, RE>
-): WebHandler => {
-  return HttpApp.toWebHandlerLayer(router, layer)
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export { toHandler, type WebHandler } from "./handler"
-
-// SSE (Server-Sent Events) subscription support
-export { createSSEHandler, createSSEHandlers, type WebSSEOptions } from "./sse"

package/src/sse.ts

@@ -1,193 +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 Web SSE handler
- */
-export interface WebSSEOptions<R> extends GraphQLSSEOptions<R> {
-  /**
-   * Path for SSE connections.
-   * @default "/graphql/stream"
-   */
-  readonly path?: string
-}
-
-/**
- * Create an SSE handler for web standard environments.
- *
- * This handler is designed for Cloudflare Workers, Deno, and other runtimes
- * that use the Web standard fetch API. It returns a streaming Response for
- * SSE subscription requests.
- *
- * @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 Cloudflare Workers
- * ```typescript
- * import { toHandler } from "@effect-gql/web"
- * import { createSSEHandler } from "@effect-gql/web"
- *
- * const graphqlHandler = toHandler(router, Layer.empty)
- * const sseHandler = createSSEHandler(schema, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     const url = new URL(request.url)
- *
- *     // Handle SSE subscriptions
- *     if (url.pathname === "/graphql/stream" && request.method === "POST") {
- *       return await sseHandler(request)
- *     }
- *
- *     // Handle regular GraphQL requests
- *     return await graphqlHandler.handler(request)
- *   }
- * }
- * ```
- *
- * @example Deno
- * ```typescript
- * import { toHandler, createSSEHandler } from "@effect-gql/web"
- *
- * const graphqlHandler = toHandler(router, Layer.empty)
- * const sseHandler = createSSEHandler(schema, Layer.empty)
- *
- * Deno.serve((request) => {
- *   const url = new URL(request.url)
- *
- *   if (url.pathname === "/graphql/stream" && request.method === "POST") {
- *     return sseHandler(request)
- *   }
- *
- *   return graphqlHandler.handler(request)
- * })
- * ```
- */
-export const createSSEHandler = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: WebSSEOptions<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 with path matching for web standard environments.
- *
- * 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 sse = createSSEHandlers(schema, Layer.empty)
- *
- * export default {
- *   async fetch(request: Request) {
- *     if (sse.shouldHandle(request)) {
- *       return sse.handle(request)
- *     }
- *     // Handle other requests...
- *   }
- * }
- * ```
- */
-export const createSSEHandlers = <R>(
-  schema: GraphQLSchema,
-  layer: Layer.Layer<R>,
-  options?: WebSSEOptions<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 = createSSEHandler(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,
-  }
-}