@effect-gql/web 0.1.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Nick Fisher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/handler.d.ts

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

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

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

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

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

package/dist/index.d.ts.map

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

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

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

@@ -0,0 +1,100 @@
+import { Layer } from "effect";
+import { GraphQLSchema } from "graphql";
+import { type GraphQLSSEOptions } 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 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...
+ *   }
+ * }
+ * ```
+ */
+export 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>;
+};
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

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

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

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

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@effect-gql/web",
+  "version": "0.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",
+  "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": "^3.19.0"
+  },
+  "devDependencies": {
+    "@effect-gql/core": "*",
+    "@effect/platform": "^0.94.0",
+    "effect": "^3.19.13",
+    "graphql": "^16.0.0"
+  },
+  "keywords": [
+    "effect",
+    "graphql",
+    "cloudflare",
+    "workers",
+    "wasm",
+    "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"
+  }
+}

package/src/handler.ts

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

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

package/src/sse.ts

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