npm - @effect-gql/core - Versions diffs - 0.1.0 → 1.0.0 - Mend

@effect-gql/core 0.1.0 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (164) hide show

package/README.md +100 -0
package/builder/index.cjs +1431 -0
package/builder/index.cjs.map +1 -0
package/builder/index.d.cts +259 -0
package/{dist/builder/pipe-api.d.ts → builder/index.d.ts} +49 -21
package/builder/index.js +1390 -0
package/builder/index.js.map +1 -0
package/index.cjs +3419 -0
package/index.cjs.map +1 -0
package/index.d.cts +523 -0
package/index.d.ts +523 -0
package/index.js +3242 -0
package/index.js.map +1 -0
package/package.json +19 -28
package/schema-builder-Cvdq7Kz_.d.cts +963 -0
package/schema-builder-Cvdq7Kz_.d.ts +963 -0
package/server/index.cjs +1555 -0
package/server/index.cjs.map +1 -0
package/server/index.d.cts +680 -0
package/server/index.d.ts +680 -0
package/server/index.js +1524 -0
package/server/index.js.map +1 -0
package/dist/analyzer-extension.d.ts +0 -105
package/dist/analyzer-extension.d.ts.map +0 -1
package/dist/analyzer-extension.js +0 -137
package/dist/analyzer-extension.js.map +0 -1
package/dist/builder/execute.d.ts +0 -26
package/dist/builder/execute.d.ts.map +0 -1
package/dist/builder/execute.js +0 -104
package/dist/builder/execute.js.map +0 -1
package/dist/builder/field-builders.d.ts +0 -30
package/dist/builder/field-builders.d.ts.map +0 -1
package/dist/builder/field-builders.js +0 -200
package/dist/builder/field-builders.js.map +0 -1
package/dist/builder/index.d.ts +0 -7
package/dist/builder/index.d.ts.map +0 -1
package/dist/builder/index.js +0 -31
package/dist/builder/index.js.map +0 -1
package/dist/builder/pipe-api.d.ts.map +0 -1
package/dist/builder/pipe-api.js +0 -151
package/dist/builder/pipe-api.js.map +0 -1
package/dist/builder/schema-builder.d.ts +0 -301
package/dist/builder/schema-builder.d.ts.map +0 -1
package/dist/builder/schema-builder.js +0 -566
package/dist/builder/schema-builder.js.map +0 -1
package/dist/builder/type-registry.d.ts +0 -80
package/dist/builder/type-registry.d.ts.map +0 -1
package/dist/builder/type-registry.js +0 -505
package/dist/builder/type-registry.js.map +0 -1
package/dist/builder/types.d.ts +0 -283
package/dist/builder/types.d.ts.map +0 -1
package/dist/builder/types.js +0 -3
package/dist/builder/types.js.map +0 -1
package/dist/cli/generate-schema.d.ts +0 -29
package/dist/cli/generate-schema.d.ts.map +0 -1
package/dist/cli/generate-schema.js +0 -233
package/dist/cli/generate-schema.js.map +0 -1
package/dist/cli/index.d.ts +0 -19
package/dist/cli/index.d.ts.map +0 -1
package/dist/cli/index.js +0 -24
package/dist/cli/index.js.map +0 -1
package/dist/context.d.ts +0 -18
package/dist/context.d.ts.map +0 -1
package/dist/context.js +0 -11
package/dist/context.js.map +0 -1
package/dist/error.d.ts +0 -45
package/dist/error.d.ts.map +0 -1
package/dist/error.js +0 -29
package/dist/error.js.map +0 -1
package/dist/extensions.d.ts +0 -130
package/dist/extensions.d.ts.map +0 -1
package/dist/extensions.js +0 -78
package/dist/extensions.js.map +0 -1
package/dist/index.d.ts +0 -12
package/dist/index.d.ts.map +0 -1
package/dist/index.js +0 -47
package/dist/index.js.map +0 -1
package/dist/loader.d.ts +0 -169
package/dist/loader.d.ts.map +0 -1
package/dist/loader.js +0 -237
package/dist/loader.js.map +0 -1
package/dist/resolver-context.d.ts +0 -154
package/dist/resolver-context.d.ts.map +0 -1
package/dist/resolver-context.js +0 -184
package/dist/resolver-context.js.map +0 -1
package/dist/schema-mapping.d.ts +0 -30
package/dist/schema-mapping.d.ts.map +0 -1
package/dist/schema-mapping.js +0 -280
package/dist/schema-mapping.js.map +0 -1
package/dist/server/cache-control.d.ts +0 -96
package/dist/server/cache-control.d.ts.map +0 -1
package/dist/server/cache-control.js +0 -308
package/dist/server/cache-control.js.map +0 -1
package/dist/server/complexity.d.ts +0 -165
package/dist/server/complexity.d.ts.map +0 -1
package/dist/server/complexity.js +0 -433
package/dist/server/complexity.js.map +0 -1
package/dist/server/config.d.ts +0 -66
package/dist/server/config.d.ts.map +0 -1
package/dist/server/config.js +0 -104
package/dist/server/config.js.map +0 -1
package/dist/server/graphiql.d.ts +0 -5
package/dist/server/graphiql.d.ts.map +0 -1
package/dist/server/graphiql.js +0 -43
package/dist/server/graphiql.js.map +0 -1
package/dist/server/index.d.ts +0 -18
package/dist/server/index.d.ts.map +0 -1
package/dist/server/index.js +0 -48
package/dist/server/index.js.map +0 -1
package/dist/server/router.d.ts +0 -79
package/dist/server/router.d.ts.map +0 -1
package/dist/server/router.js +0 -232
package/dist/server/router.js.map +0 -1
package/dist/server/schema-builder-extensions.d.ts +0 -42
package/dist/server/schema-builder-extensions.d.ts.map +0 -1
package/dist/server/schema-builder-extensions.js +0 -48
package/dist/server/schema-builder-extensions.js.map +0 -1
package/dist/server/sse-adapter.d.ts +0 -64
package/dist/server/sse-adapter.d.ts.map +0 -1
package/dist/server/sse-adapter.js +0 -227
package/dist/server/sse-adapter.js.map +0 -1
package/dist/server/sse-types.d.ts +0 -192
package/dist/server/sse-types.d.ts.map +0 -1
package/dist/server/sse-types.js +0 -63
package/dist/server/sse-types.js.map +0 -1
package/dist/server/ws-adapter.d.ts +0 -39
package/dist/server/ws-adapter.d.ts.map +0 -1
package/dist/server/ws-adapter.js +0 -247
package/dist/server/ws-adapter.js.map +0 -1
package/dist/server/ws-types.d.ts +0 -169
package/dist/server/ws-types.d.ts.map +0 -1
package/dist/server/ws-types.js +0 -11
package/dist/server/ws-types.js.map +0 -1
package/dist/server/ws-utils.d.ts +0 -42
package/dist/server/ws-utils.d.ts.map +0 -1
package/dist/server/ws-utils.js +0 -99
package/dist/server/ws-utils.js.map +0 -1
package/src/analyzer-extension.ts +0 -254
package/src/builder/execute.ts +0 -153
package/src/builder/field-builders.ts +0 -322
package/src/builder/index.ts +0 -48
package/src/builder/pipe-api.ts +0 -312
package/src/builder/schema-builder.ts +0 -970
package/src/builder/type-registry.ts +0 -670
package/src/builder/types.ts +0 -305
package/src/context.ts +0 -23
package/src/error.ts +0 -32
package/src/extensions.ts +0 -240
package/src/index.ts +0 -32
package/src/loader.ts +0 -363
package/src/resolver-context.ts +0 -253
package/src/schema-mapping.ts +0 -307
package/src/server/cache-control.ts +0 -590
package/src/server/complexity.ts +0 -774
package/src/server/config.ts +0 -174
package/src/server/graphiql.ts +0 -38
package/src/server/index.ts +0 -96
package/src/server/router.ts +0 -432
package/src/server/schema-builder-extensions.ts +0 -51
package/src/server/sse-adapter.ts +0 -327
package/src/server/sse-types.ts +0 -234
package/src/server/ws-adapter.ts +0 -355
package/src/server/ws-types.ts +0 -192
package/src/server/ws-utils.ts +0 -136

package/server/index.js ADDED Viewed

@@ -0,0 +1,1524 @@
+import { Config, Option, Data, Context, Effect, Queue, Deferred, Stream, Ref, Runtime, Fiber } from 'effect';
+import { HttpServerResponse, HttpServerRequest, HttpRouter } from '@effect/platform';
+import { Kind, GraphQLObjectType, parse, specifiedRules, NoSchemaIntrospectionCustomRule, validate, subscribe, GraphQLError, GraphQLNonNull, GraphQLList, GraphQLSchema, GraphQLScalarType, GraphQLEnumType, execute } from 'graphql';
+import { makeServer } from 'graphql-ws';
+// src/server/config.ts
+var defaultConfig = {
+  path: "/graphql",
+  graphiql: false,
+  complexity: void 0,
+  introspection: true,
+  cacheControl: void 0
+};
+var normalizeConfig = (input = {}) => {
+  const path = input.path ?? defaultConfig.path;
+  let graphiql = false;
+  if (input.graphiql === true) {
+    graphiql = { path: "/graphiql", endpoint: path };
+  } else if (input.graphiql && typeof input.graphiql === "object") {
+    graphiql = {
+      path: input.graphiql.path ?? "/graphiql",
+      endpoint: input.graphiql.endpoint ?? path
+    };
+  }
+  return {
+    path,
+    graphiql,
+    complexity: input.complexity,
+    introspection: input.introspection ?? true,
+    cacheControl: input.cacheControl
+  };
+};
+var GraphQLRouterConfigFromEnv = Config.all({
+  path: Config.string("GRAPHQL_PATH").pipe(Config.withDefault("/graphql")),
+  introspection: Config.boolean("GRAPHQL_INTROSPECTION").pipe(Config.withDefault(true)),
+  graphiqlEnabled: Config.boolean("GRAPHIQL_ENABLED").pipe(Config.withDefault(false)),
+  graphiqlPath: Config.string("GRAPHIQL_PATH").pipe(Config.withDefault("/graphiql")),
+  graphiqlEndpoint: Config.string("GRAPHIQL_ENDPOINT").pipe(Config.option),
+  maxDepth: Config.number("GRAPHQL_MAX_DEPTH").pipe(Config.option),
+  maxComplexity: Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(Config.option),
+  maxAliases: Config.number("GRAPHQL_MAX_ALIASES").pipe(Config.option),
+  maxFields: Config.number("GRAPHQL_MAX_FIELDS").pipe(Config.option),
+  defaultFieldComplexity: Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    Config.withDefault(1)
+  ),
+  cacheControlEnabled: Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(
+    Config.withDefault(false)
+  ),
+  cacheControlDefaultMaxAge: Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(
+    Config.withDefault(0)
+  ),
+  cacheControlDefaultScope: Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    Config.withDefault("PUBLIC")
+  )
+}).pipe(
+  Config.map(
+    ({
+      path,
+      introspection,
+      graphiqlEnabled,
+      graphiqlPath,
+      graphiqlEndpoint,
+      maxDepth,
+      maxComplexity,
+      maxAliases,
+      maxFields,
+      defaultFieldComplexity,
+      cacheControlEnabled,
+      cacheControlDefaultMaxAge,
+      cacheControlDefaultScope
+    }) => {
+      const hasComplexity = Option.isSome(maxDepth) || Option.isSome(maxComplexity) || Option.isSome(maxAliases) || Option.isSome(maxFields);
+      return {
+        path,
+        introspection,
+        graphiql: graphiqlEnabled ? {
+          path: graphiqlPath,
+          endpoint: Option.isSome(graphiqlEndpoint) ? graphiqlEndpoint.value : path
+        } : false,
+        complexity: hasComplexity ? {
+          maxDepth: Option.getOrUndefined(maxDepth),
+          maxComplexity: Option.getOrUndefined(maxComplexity),
+          maxAliases: Option.getOrUndefined(maxAliases),
+          maxFields: Option.getOrUndefined(maxFields),
+          defaultFieldComplexity
+        } : void 0,
+        cacheControl: cacheControlEnabled ? {
+          enabled: true,
+          defaultMaxAge: cacheControlDefaultMaxAge,
+          defaultScope: cacheControlDefaultScope === "PRIVATE" ? "PRIVATE" : "PUBLIC",
+          calculateHttpHeaders: true
+        } : void 0
+      };
+    }
+  )
+);
+// src/server/graphiql.ts
+var graphiqlHtml = (endpoint) => `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>GraphiQL</title>
+    <link
+      rel="stylesheet"
+      href="https://unpkg.com/graphiql@3/graphiql.min.css"
+    />
+  </head>
+  <body style="margin: 0; overflow: hidden;">
+    <div id="graphiql" style="height: 100vh;"></div>
+    <script
+      crossorigin
+      src="https://unpkg.com/react@18/umd/react.production.min.js"
+    ></script>
+    <script
+      crossorigin
+      src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"
+    ></script>
+    <script
+      crossorigin
+      src="https://unpkg.com/graphiql@3/graphiql.min.js"
+    ></script>
+    <script>
+      const fetcher = GraphiQL.createFetcher({
+        url: ${JSON.stringify(endpoint)},
+      });
+      ReactDOM.createRoot(document.getElementById('graphiql')).render(
+        React.createElement(GraphiQL, { fetcher })
+      );
+    </script>
+  </body>
+</html>`;
+var ComplexityLimitExceededError = class extends Data.TaggedError("ComplexityLimitExceededError") {
+};
+var ComplexityAnalysisError = class extends Data.TaggedError("ComplexityAnalysisError") {
+};
+var defaultComplexityCalculator = (defaultCost = 1) => {
+  return (info) => Effect.try({
+    try: () => {
+      const fragments = /* @__PURE__ */ new Map();
+      for (const definition of info.document.definitions) {
+        if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+          fragments.set(definition.name.value, definition);
+        }
+      }
+      const rootType = getRootType(info.schema, info.operation.operation);
+      if (!rootType) {
+        throw new Error(`No root type found for operation: ${info.operation.operation}`);
+      }
+      const result = analyzeSelectionSet(
+        info.operation.selectionSet,
+        rootType,
+        info.schema,
+        fragments,
+        info.fieldComplexities,
+        info.variables ?? {},
+        defaultCost,
+        1,
+        // Starting depth
+        /* @__PURE__ */ new Set()
+        // Visited fragments to prevent infinite loops
+      );
+      return result;
+    },
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to analyze query complexity: ${error}`,
+      cause: error
+    })
+  });
+};
+function getRootType(schema, operation) {
+  switch (operation) {
+    case "query":
+      return schema.getQueryType() ?? null;
+    case "mutation":
+      return schema.getMutationType() ?? null;
+    case "subscription":
+      return schema.getSubscriptionType() ?? null;
+  }
+}
+function getNamedType(type) {
+  if (type instanceof GraphQLNonNull || type instanceof GraphQLList) {
+    return getNamedType(type.ofType);
+  }
+  if (type instanceof GraphQLObjectType) {
+    return type;
+  }
+  return null;
+}
+function accumulateResult(acc, result) {
+  acc.maxDepth = Math.max(acc.maxDepth, result.depth);
+  acc.complexity += result.complexity;
+  acc.fieldCount += result.fieldCount;
+  acc.aliasCount += result.aliasCount;
+}
+function analyzeSelectionSet(selectionSet, parentType, schema, fragments, fieldComplexities, variables, defaultCost, currentDepth, visitedFragments) {
+  const ctx = { schema, fragments, fieldComplexities, variables, defaultCost };
+  const acc = { maxDepth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  for (const selection of selectionSet.selections) {
+    const result = analyzeSelection(selection, parentType, ctx, currentDepth, visitedFragments);
+    accumulateResult(acc, result);
+  }
+  return {
+    depth: acc.maxDepth,
+    complexity: acc.complexity,
+    fieldCount: acc.fieldCount,
+    aliasCount: acc.aliasCount
+  };
+}
+function analyzeSelection(selection, parentType, ctx, currentDepth, visitedFragments) {
+  switch (selection.kind) {
+    case Kind.FIELD:
+      return analyzeField(selection, parentType, ctx, currentDepth, visitedFragments);
+    case Kind.FRAGMENT_SPREAD:
+      return analyzeFragmentSpread(selection, ctx, currentDepth, visitedFragments);
+    case Kind.INLINE_FRAGMENT:
+      return analyzeInlineFragment(selection, parentType, ctx, currentDepth, visitedFragments);
+  }
+}
+function analyzeField(field, parentType, ctx, currentDepth, visitedFragments) {
+  const fieldName = field.name.value;
+  const aliasCount = field.alias ? 1 : 0;
+  if (fieldName.startsWith("__")) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 1, aliasCount };
+  }
+  const schemaField = parentType.getFields()[fieldName];
+  if (!schemaField) {
+    return { depth: currentDepth, complexity: ctx.defaultCost, fieldCount: 1, aliasCount };
+  }
+  const args = resolveFieldArguments(field, ctx.variables);
+  const complexityKey = `${parentType.name}.${fieldName}`;
+  const fieldComplexity = ctx.fieldComplexities.get(complexityKey);
+  const cost = fieldComplexity !== void 0 ? typeof fieldComplexity === "function" ? fieldComplexity(args) : fieldComplexity : ctx.defaultCost;
+  if (field.selectionSet) {
+    const fieldType = getNamedType(schemaField.type);
+    if (fieldType) {
+      const nestedResult = analyzeSelectionSet(
+        field.selectionSet,
+        fieldType,
+        ctx.schema,
+        ctx.fragments,
+        ctx.fieldComplexities,
+        ctx.variables,
+        ctx.defaultCost,
+        currentDepth + 1,
+        visitedFragments
+      );
+      return {
+        depth: nestedResult.depth,
+        complexity: cost + nestedResult.complexity,
+        fieldCount: 1 + nestedResult.fieldCount,
+        aliasCount: aliasCount + nestedResult.aliasCount
+      };
+    }
+  }
+  return { depth: currentDepth, complexity: cost, fieldCount: 1, aliasCount };
+}
+function analyzeFragmentSpread(spread, ctx, currentDepth, visitedFragments) {
+  const fragmentName = spread.name.value;
+  if (visitedFragments.has(fragmentName)) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const fragment = ctx.fragments.get(fragmentName);
+  if (!fragment) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const fragmentType = ctx.schema.getType(fragment.typeCondition.name.value);
+  if (!(fragmentType instanceof GraphQLObjectType)) {
+    return { depth: currentDepth, complexity: 0, fieldCount: 0, aliasCount: 0 };
+  }
+  const newVisited = new Set(visitedFragments);
+  newVisited.add(fragmentName);
+  return analyzeSelectionSet(
+    fragment.selectionSet,
+    fragmentType,
+    ctx.schema,
+    ctx.fragments,
+    ctx.fieldComplexities,
+    ctx.variables,
+    ctx.defaultCost,
+    currentDepth,
+    newVisited
+  );
+}
+function analyzeInlineFragment(fragment, parentType, ctx, currentDepth, visitedFragments) {
+  let targetType = parentType;
+  if (fragment.typeCondition) {
+    const conditionType = ctx.schema.getType(fragment.typeCondition.name.value);
+    if (conditionType instanceof GraphQLObjectType) {
+      targetType = conditionType;
+    }
+  }
+  return analyzeSelectionSet(
+    fragment.selectionSet,
+    targetType,
+    ctx.schema,
+    ctx.fragments,
+    ctx.fieldComplexities,
+    ctx.variables,
+    ctx.defaultCost,
+    currentDepth,
+    visitedFragments
+  );
+}
+function resolveFieldArguments(field, variables) {
+  const args = {};
+  if (!field.arguments) {
+    return args;
+  }
+  for (const arg of field.arguments) {
+    const value = arg.value;
+    switch (value.kind) {
+      case Kind.VARIABLE:
+        args[arg.name.value] = variables[value.name.value];
+        break;
+      case Kind.INT:
+        args[arg.name.value] = parseInt(value.value, 10);
+        break;
+      case Kind.FLOAT:
+        args[arg.name.value] = parseFloat(value.value);
+        break;
+      case Kind.STRING:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.BOOLEAN:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.NULL:
+        args[arg.name.value] = null;
+        break;
+      case Kind.ENUM:
+        args[arg.name.value] = value.value;
+        break;
+      case Kind.LIST:
+        args[arg.name.value] = [];
+        break;
+      case Kind.OBJECT:
+        args[arg.name.value] = {};
+        break;
+    }
+  }
+  return args;
+}
+var validateComplexity = (query, operationName, variables, schema, fieldComplexities, config) => Effect.gen(function* () {
+  const document = yield* Effect.try({
+    try: () => parse(query),
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to parse query: ${error}`,
+      cause: error
+    })
+  });
+  const operation = yield* Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === Kind.OPERATION_DEFINITION
+      );
+      if (operations.length === 0) {
+        throw new Error("No operation found in query");
+      }
+      if (operationName) {
+        const op = operations.find((o) => o.name?.value === operationName);
+        if (!op) {
+          throw new Error(`Operation "${operationName}" not found`);
+        }
+        return op;
+      }
+      if (operations.length > 1) {
+        throw new Error("Multiple operations found - operationName required");
+      }
+      return operations[0];
+    },
+    catch: (error) => new ComplexityAnalysisError({
+      message: String(error),
+      cause: error
+    })
+  });
+  const calculator = config.calculator ?? defaultComplexityCalculator(config.defaultFieldComplexity ?? 1);
+  const result = yield* calculator({
+    document,
+    operation,
+    variables,
+    schema,
+    fieldComplexities
+  });
+  const checkLimit = (limitType, limit, actual) => Effect.gen(function* () {
+    if (limit !== void 0 && actual > limit) {
+      const exceededInfo = {
+        result,
+        exceededLimit: limitType,
+        limit,
+        actual,
+        query,
+        operationName
+      };
+      if (config.onExceeded) {
+        yield* config.onExceeded(exceededInfo);
+      }
+      yield* Effect.fail(
+        new ComplexityLimitExceededError({
+          message: `Query ${limitType} of ${actual} exceeds maximum allowed ${limitType} of ${limit}`,
+          limit,
+          actual,
+          limitType
+        })
+      );
+    }
+  });
+  yield* checkLimit("depth", config.maxDepth, result.depth);
+  yield* checkLimit("complexity", config.maxComplexity, result.complexity);
+  yield* checkLimit("aliases", config.maxAliases, result.aliasCount);
+  yield* checkLimit("fields", config.maxFields, result.fieldCount);
+  return result;
+});
+var ComplexityConfigFromEnv = Config.all({
+  maxDepth: Config.number("GRAPHQL_MAX_DEPTH").pipe(Config.option),
+  maxComplexity: Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(Config.option),
+  maxAliases: Config.number("GRAPHQL_MAX_ALIASES").pipe(Config.option),
+  maxFields: Config.number("GRAPHQL_MAX_FIELDS").pipe(Config.option),
+  defaultFieldComplexity: Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    Config.withDefault(1)
+  )
+}).pipe(
+  Config.map(({ maxDepth, maxComplexity, maxAliases, maxFields, defaultFieldComplexity }) => ({
+    maxDepth: Option.getOrUndefined(maxDepth),
+    maxComplexity: Option.getOrUndefined(maxComplexity),
+    maxAliases: Option.getOrUndefined(maxAliases),
+    maxFields: Option.getOrUndefined(maxFields),
+    defaultFieldComplexity
+  }))
+);
+var depthOnlyCalculator = (info) => Effect.try({
+  try: () => {
+    const fragments = /* @__PURE__ */ new Map();
+    for (const definition of info.document.definitions) {
+      if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+        fragments.set(definition.name.value, definition);
+      }
+    }
+    const depth = calculateMaxDepth(info.operation.selectionSet, fragments, 1, /* @__PURE__ */ new Set());
+    return {
+      depth,
+      complexity: 0,
+      fieldCount: 0,
+      aliasCount: 0
+    };
+  },
+  catch: (error) => new ComplexityAnalysisError({
+    message: `Failed to analyze query depth: ${error}`,
+    cause: error
+  })
+});
+function calculateMaxDepth(selectionSet, fragments, currentDepth, visitedFragments) {
+  let maxDepth = currentDepth;
+  for (const selection of selectionSet.selections) {
+    switch (selection.kind) {
+      case Kind.FIELD:
+        if (selection.selectionSet) {
+          const nestedDepth = calculateMaxDepth(
+            selection.selectionSet,
+            fragments,
+            currentDepth + 1,
+            visitedFragments
+          );
+          maxDepth = Math.max(maxDepth, nestedDepth);
+        }
+        break;
+      case Kind.FRAGMENT_SPREAD: {
+        const fragmentName = selection.name.value;
+        if (!visitedFragments.has(fragmentName)) {
+          const fragment = fragments.get(fragmentName);
+          if (fragment) {
+            const newVisited = new Set(visitedFragments);
+            newVisited.add(fragmentName);
+            const fragmentDepth = calculateMaxDepth(
+              fragment.selectionSet,
+              fragments,
+              currentDepth,
+              newVisited
+            );
+            maxDepth = Math.max(maxDepth, fragmentDepth);
+          }
+        }
+        break;
+      }
+      case Kind.INLINE_FRAGMENT: {
+        const inlineDepth = calculateMaxDepth(
+          selection.selectionSet,
+          fragments,
+          currentDepth,
+          visitedFragments
+        );
+        maxDepth = Math.max(maxDepth, inlineDepth);
+        break;
+      }
+    }
+  }
+  return maxDepth;
+}
+var combineCalculators = (...calculators) => {
+  return (info) => Effect.gen(function* () {
+    let maxDepth = 0;
+    let maxComplexity = 0;
+    let maxFieldCount = 0;
+    let maxAliasCount = 0;
+    for (const calculator of calculators) {
+      const result = yield* calculator(info);
+      maxDepth = Math.max(maxDepth, result.depth);
+      maxComplexity = Math.max(maxComplexity, result.complexity);
+      maxFieldCount = Math.max(maxFieldCount, result.fieldCount);
+      maxAliasCount = Math.max(maxAliasCount, result.aliasCount);
+    }
+    return {
+      depth: maxDepth,
+      complexity: maxComplexity,
+      fieldCount: maxFieldCount,
+      aliasCount: maxAliasCount
+    };
+  });
+};
+var computeCachePolicy = (info) => Effect.sync(() => {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of info.document.definitions) {
+    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+      fragments.set(definition.name.value, definition);
+    }
+  }
+  const rootType = getRootType2(info.schema, info.operation.operation);
+  if (!rootType) {
+    return { maxAge: 0, scope: "PUBLIC" };
+  }
+  const defaultMaxAge = info.config.defaultMaxAge ?? 0;
+  const defaultScope = info.config.defaultScope ?? "PUBLIC";
+  const result = analyzeSelectionSet2(
+    info.operation.selectionSet,
+    rootType,
+    info.schema,
+    fragments,
+    info.cacheHints,
+    defaultMaxAge,
+    defaultScope,
+    void 0,
+    // No parent maxAge for root
+    /* @__PURE__ */ new Set()
+  );
+  return result;
+});
+var computeCachePolicyFromQuery = (query, operationName, schema, cacheHints, config = {}) => Effect.gen(function* () {
+  const document = yield* Effect.try({
+    try: () => parse(query),
+    catch: (error) => new Error(`Failed to parse query: ${error}`)
+  });
+  const operation = yield* Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === Kind.OPERATION_DEFINITION
+      );
+      if (operations.length === 0) {
+        throw new Error("No operation found in query");
+      }
+      if (operationName) {
+        const op = operations.find((o) => o.name?.value === operationName);
+        if (!op) {
+          throw new Error(`Operation "${operationName}" not found`);
+        }
+        return op;
+      }
+      if (operations.length > 1) {
+        throw new Error("Multiple operations found - operationName required");
+      }
+      return operations[0];
+    },
+    catch: (error) => error
+  });
+  return yield* computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config
+  });
+});
+var toCacheControlHeader = (policy) => {
+  if (policy.maxAge === 0) {
+    return "no-store";
+  }
+  const directives = [];
+  directives.push(policy.scope === "PRIVATE" ? "private" : "public");
+  directives.push(`max-age=${policy.maxAge}`);
+  return directives.join(", ");
+};
+function getRootType2(schema, operation) {
+  switch (operation) {
+    case "query":
+      return schema.getQueryType() ?? null;
+    case "mutation":
+      return schema.getMutationType() ?? null;
+    case "subscription":
+      return schema.getSubscriptionType() ?? null;
+  }
+}
+function getNamedType2(type) {
+  if (type instanceof GraphQLNonNull || type instanceof GraphQLList) {
+    return getNamedType2(type.ofType);
+  }
+  if (type instanceof GraphQLObjectType || type instanceof GraphQLScalarType || type instanceof GraphQLEnumType) {
+    return type;
+  }
+  return null;
+}
+function isLeafType(type) {
+  const namedType = getNamedType2(type);
+  return namedType instanceof GraphQLScalarType || namedType instanceof GraphQLEnumType;
+}
+function aggregatePolicy(acc, policy) {
+  if (acc.minMaxAge === void 0) {
+    acc.minMaxAge = policy.maxAge;
+  } else {
+    acc.minMaxAge = Math.min(acc.minMaxAge, policy.maxAge);
+  }
+  if (policy.scope === "PRIVATE") {
+    acc.hasPrivate = true;
+  }
+}
+function analyzeFragmentSpread2(fragmentName, ctx, parentMaxAge, visitedFragments) {
+  if (visitedFragments.has(fragmentName)) {
+    return void 0;
+  }
+  const fragment = ctx.fragments.get(fragmentName);
+  if (!fragment) {
+    return void 0;
+  }
+  const fragmentType = ctx.schema.getType(fragment.typeCondition.name.value);
+  if (!(fragmentType instanceof GraphQLObjectType)) {
+    return void 0;
+  }
+  const newVisited = new Set(visitedFragments);
+  newVisited.add(fragmentName);
+  return analyzeSelectionSet2(fragment.selectionSet, fragmentType, ctx, parentMaxAge, newVisited);
+}
+function analyzeInlineFragment2(selection, parentType, ctx, parentMaxAge, visitedFragments) {
+  let targetType = parentType;
+  if (selection.typeCondition) {
+    const conditionType = ctx.schema.getType(selection.typeCondition.name.value);
+    if (conditionType instanceof GraphQLObjectType) {
+      targetType = conditionType;
+    }
+  }
+  return analyzeSelectionSet2(
+    selection.selectionSet,
+    targetType,
+    ctx,
+    parentMaxAge,
+    visitedFragments
+  );
+}
+function lookupEffectiveCacheHint(parentTypeName, fieldName, returnType, cacheHints) {
+  const fieldKey = `${parentTypeName}.${fieldName}`;
+  const fieldHint = cacheHints.get(fieldKey);
+  if (fieldHint) return fieldHint;
+  const namedType = getNamedType2(returnType);
+  return namedType ? cacheHints.get(namedType.name) : void 0;
+}
+function computeFieldMaxAge(hint, fieldType, parentMaxAge, defaultMaxAge) {
+  if (hint) {
+    if (hint.inheritMaxAge && parentMaxAge !== void 0) {
+      return parentMaxAge;
+    }
+    if (hint.maxAge !== void 0) {
+      return hint.maxAge;
+    }
+  }
+  if (isLeafType(fieldType) && parentMaxAge !== void 0) {
+    return parentMaxAge;
+  }
+  return defaultMaxAge;
+}
+function analyzeSelectionSet2(selectionSet, parentType, schemaOrCtx, fragmentsOrParentMaxAge, cacheHintsOrVisited, defaultMaxAge, defaultScope, parentMaxAge, visitedFragments) {
+  let ctx;
+  let actualParentMaxAge;
+  let actualVisitedFragments;
+  if (schemaOrCtx instanceof GraphQLSchema) {
+    ctx = {
+      schema: schemaOrCtx,
+      fragments: fragmentsOrParentMaxAge,
+      cacheHints: cacheHintsOrVisited,
+      defaultMaxAge,
+      defaultScope
+    };
+    actualParentMaxAge = parentMaxAge;
+    actualVisitedFragments = visitedFragments;
+  } else {
+    ctx = schemaOrCtx;
+    actualParentMaxAge = fragmentsOrParentMaxAge;
+    actualVisitedFragments = cacheHintsOrVisited;
+  }
+  const acc = { minMaxAge: void 0, hasPrivate: false };
+  for (const selection of selectionSet.selections) {
+    let fieldPolicy;
+    switch (selection.kind) {
+      case Kind.FIELD:
+        fieldPolicy = analyzeField2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case Kind.FRAGMENT_SPREAD:
+        fieldPolicy = analyzeFragmentSpread2(
+          selection.name.value,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case Kind.INLINE_FRAGMENT:
+        fieldPolicy = analyzeInlineFragment2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+    }
+    if (fieldPolicy) {
+      aggregatePolicy(acc, fieldPolicy);
+    }
+  }
+  return {
+    maxAge: acc.minMaxAge ?? ctx.defaultMaxAge,
+    scope: acc.hasPrivate ? "PRIVATE" : ctx.defaultScope
+  };
+}
+function analyzeField2(field, parentType, ctx, parentMaxAge, visitedFragments) {
+  const fieldName = field.name.value;
+  if (fieldName.startsWith("__")) {
+    return { maxAge: Infinity, scope: "PUBLIC" };
+  }
+  const schemaField = parentType.getFields()[fieldName];
+  if (!schemaField) {
+    return { maxAge: ctx.defaultMaxAge, scope: ctx.defaultScope };
+  }
+  const effectiveHint = lookupEffectiveCacheHint(
+    parentType.name,
+    fieldName,
+    schemaField.type,
+    ctx.cacheHints
+  );
+  const fieldMaxAge = computeFieldMaxAge(
+    effectiveHint,
+    schemaField.type,
+    parentMaxAge,
+    ctx.defaultMaxAge
+  );
+  const fieldScope = effectiveHint?.scope ?? ctx.defaultScope;
+  const namedType = getNamedType2(schemaField.type);
+  if (field.selectionSet && namedType instanceof GraphQLObjectType) {
+    const nestedPolicy = analyzeSelectionSet2(
+      field.selectionSet,
+      namedType,
+      ctx,
+      fieldMaxAge,
+      visitedFragments
+    );
+    return {
+      maxAge: Math.min(fieldMaxAge, nestedPolicy.maxAge),
+      scope: fieldScope === "PRIVATE" || nestedPolicy.scope === "PRIVATE" ? "PRIVATE" : "PUBLIC"
+    };
+  }
+  return { maxAge: fieldMaxAge, scope: fieldScope };
+}
+var CacheControlConfigFromEnv = Config.all({
+  enabled: Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(Config.withDefault(true)),
+  defaultMaxAge: Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(Config.withDefault(0)),
+  defaultScope: Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    Config.withDefault("PUBLIC"),
+    Config.map((s) => s === "PRIVATE" ? "PRIVATE" : "PUBLIC")
+  ),
+  calculateHttpHeaders: Config.boolean("GRAPHQL_CACHE_CONTROL_HTTP_HEADERS").pipe(
+    Config.withDefault(true)
+  )
+});
+var ExtensionsService = Context.GenericTag(
+  "@effect-gql/ExtensionsService"
+);
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+var makeExtensionsService = () => Effect.gen(function* () {
+  const ref = yield* Ref.make({});
+  return ExtensionsService.of({
+    set: (key, value) => Ref.update(ref, (current) => ({ ...current, [key]: value })),
+    merge: (key, value) => Ref.update(ref, (current) => {
+      const existing = current[key];
+      if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
+        return {
+          ...current,
+          [key]: deepMerge(existing, value)
+        };
+      }
+      return { ...current, [key]: value };
+    }),
+    get: () => Ref.get(ref)
+  });
+});
+var runExtensionHooks = (extensions, hookName, getHookEffect) => Effect.forEach(
+  extensions.filter((ext) => ext[hookName] !== void 0),
+  (ext) => getHookEffect(ext).pipe(
+    Effect.catchAllCause(
+      (cause) => Effect.logWarning(`Extension "${ext.name}" ${String(hookName)} hook failed`, cause)
+    )
+  ),
+  { discard: true }
+);
+var runParseHooks = (extensions, source, document) => runExtensionHooks(extensions, "onParse", (ext) => ext.onParse(source, document));
+var runValidateHooks = (extensions, document, errors) => runExtensionHooks(extensions, "onValidate", (ext) => ext.onValidate(document, errors));
+var runExecuteStartHooks = (extensions, args) => runExtensionHooks(extensions, "onExecuteStart", (ext) => ext.onExecuteStart(args));
+var runExecuteEndHooks = (extensions, result) => runExtensionHooks(extensions, "onExecuteEnd", (ext) => ext.onExecuteEnd(result));
+// src/server/router.ts
+var defaultErrorHandler = (cause) => (process.env.NODE_ENV !== "production" ? Effect.logError("GraphQL error", cause) : Effect.void).pipe(
+  Effect.andThen(
+    HttpServerResponse.json(
+      {
+        errors: [
+          {
+            message: "An error occurred processing your request"
+          }
+        ]
+      },
+      { status: 500 }
+    ).pipe(Effect.orDie)
+  )
+);
+var parseGraphQLQuery = (query, extensionsService) => Effect.gen(function* () {
+  try {
+    const document = parse(query);
+    return { ok: true, document };
+  } catch (parseError) {
+    const extensionData = yield* extensionsService.get();
+    const response = yield* HttpServerResponse.json({
+      errors: [{ message: String(parseError) }],
+      extensions: Object.keys(extensionData).length > 0 ? extensionData : void 0
+    }).pipe(Effect.orDie);
+    return { ok: false, response };
+  }
+});
+var runComplexityValidation = (body, schema, fieldComplexities, complexityConfig) => {
+  if (!complexityConfig) {
+    return Effect.void;
+  }
+  return validateComplexity(
+    body.query,
+    body.operationName,
+    body.variables,
+    schema,
+    fieldComplexities,
+    complexityConfig
+  ).pipe(
+    Effect.catchTag("ComplexityLimitExceededError", (error) => Effect.fail(error)),
+    Effect.catchTag(
+      "ComplexityAnalysisError",
+      (error) => Effect.logWarning("Complexity analysis failed", error)
+    )
+  );
+};
+var executeGraphQLQuery = (schema, document, variables, operationName, runtime) => Effect.gen(function* () {
+  const executeResult = yield* Effect.try({
+    try: () => execute({
+      schema,
+      document,
+      variableValues: variables,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  if (executeResult && typeof executeResult === "object" && "then" in executeResult) {
+    return yield* Effect.promise(
+      () => executeResult
+    );
+  }
+  return executeResult;
+});
+var computeCacheControlHeader = (document, operationName, schema, cacheHints, cacheControlConfig) => Effect.gen(function* () {
+  if (cacheControlConfig?.enabled === false || cacheControlConfig?.calculateHttpHeaders === false) {
+    return void 0;
+  }
+  const operations = document.definitions.filter(
+    (d) => d.kind === Kind.OPERATION_DEFINITION
+  );
+  const operation = operationName ? operations.find((o) => o.name?.value === operationName) : operations[0];
+  if (!operation || operation.operation === "mutation") {
+    return void 0;
+  }
+  const cachePolicy = yield* computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config: cacheControlConfig ?? {}
+  });
+  return toCacheControlHeader(cachePolicy);
+});
+var buildGraphQLResponse = (result, extensionData, cacheControlHeader) => {
+  const finalResult = Object.keys(extensionData).length > 0 ? {
+    ...result,
+    extensions: {
+      ...result.extensions,
+      ...extensionData
+    }
+  } : result;
+  const responseHeaders = cacheControlHeader ? { "cache-control": cacheControlHeader } : void 0;
+  return HttpServerResponse.json(finalResult, { headers: responseHeaders }).pipe(Effect.orDie);
+};
+var handleComplexityError = (error) => HttpServerResponse.json(
+  {
+    errors: [
+      {
+        message: error.message,
+        extensions: {
+          code: "COMPLEXITY_LIMIT_EXCEEDED",
+          limitType: error.limitType,
+          limit: error.limit,
+          actual: error.actual
+        }
+      }
+    ]
+  },
+  { status: 400 }
+).pipe(Effect.orDie);
+var makeGraphQLRouter = (schema, layer, options = {}) => {
+  const resolvedConfig = normalizeConfig(options);
+  const fieldComplexities = options.fieldComplexities ?? /* @__PURE__ */ new Map();
+  const cacheHints = options.cacheHints ?? /* @__PURE__ */ new Map();
+  const extensions = options.extensions ?? [];
+  const errorHandler = options.errorHandler ?? defaultErrorHandler;
+  const graphqlHandler = Effect.gen(function* () {
+    const extensionsService = yield* makeExtensionsService();
+    const runtime = yield* Effect.runtime();
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const body = yield* request.json;
+    const parseResult = yield* parseGraphQLQuery(body.query, extensionsService);
+    if (!parseResult.ok) {
+      return parseResult.response;
+    }
+    const document = parseResult.document;
+    yield* runParseHooks(extensions, body.query, document).pipe(
+      Effect.provideService(ExtensionsService, extensionsService)
+    );
+    const validationRules = resolvedConfig.introspection ? void 0 : [...specifiedRules, NoSchemaIntrospectionCustomRule];
+    const validationErrors = validate(schema, document, validationRules);
+    yield* runValidateHooks(extensions, document, validationErrors).pipe(
+      Effect.provideService(ExtensionsService, extensionsService)
+    );
+    if (validationErrors.length > 0) {
+      const extensionData2 = yield* extensionsService.get();
+      return yield* HttpServerResponse.json(
+        {
+          errors: validationErrors.map((e) => ({
+            message: e.message,
+            locations: e.locations,
+            path: e.path
+          })),
+          extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+        },
+        { status: 400 }
+      );
+    }
+    yield* runComplexityValidation(body, schema, fieldComplexities, resolvedConfig.complexity);
+    yield* runExecuteStartHooks(extensions, {
+      source: body.query,
+      document,
+      variableValues: body.variables,
+      operationName: body.operationName,
+      schema,
+      fieldComplexities
+    }).pipe(Effect.provideService(ExtensionsService, extensionsService));
+    const result = yield* executeGraphQLQuery(
+      schema,
+      document,
+      body.variables,
+      body.operationName,
+      runtime
+    );
+    yield* runExecuteEndHooks(extensions, result).pipe(
+      Effect.provideService(ExtensionsService, extensionsService)
+    );
+    const extensionData = yield* extensionsService.get();
+    const cacheControlHeader = yield* computeCacheControlHeader(
+      document,
+      body.operationName,
+      schema,
+      cacheHints,
+      resolvedConfig.cacheControl
+    );
+    return yield* buildGraphQLResponse(result, extensionData, cacheControlHeader);
+  }).pipe(
+    Effect.provide(layer),
+    Effect.catchAll((error) => {
+      if (error instanceof ComplexityLimitExceededError) {
+        return handleComplexityError(error);
+      }
+      return Effect.fail(error);
+    }),
+    Effect.catchAllCause(errorHandler)
+  );
+  let router = HttpRouter.empty.pipe(
+    HttpRouter.post(resolvedConfig.path, graphqlHandler)
+  );
+  if (resolvedConfig.graphiql) {
+    const { path, endpoint } = resolvedConfig.graphiql;
+    router = router.pipe(
+      HttpRouter.get(path, HttpServerResponse.html(graphiqlHtml(endpoint)))
+    );
+  }
+  return router;
+};
+// src/server/schema-builder-extensions.ts
+var toRouter = (builder, layer, options) => {
+  const schema = builder.buildSchema();
+  const fieldComplexities = builder.getFieldComplexities();
+  const cacheHints = builder.getCacheHints();
+  return makeGraphQLRouter(schema, layer, { ...options, fieldComplexities, cacheHints });
+};
+var WebSocketError = class extends Data.TaggedError("WebSocketError") {
+};
+var createConnectionContext = (extra) => ({
+  runtime: extra.runtime,
+  connectionParams: extra.connectionParams,
+  socket: extra.socket
+});
+var makeOnConnectHandler = (options) => {
+  if (!options?.onConnect) return void 0;
+  return async (ctx) => {
+    const extra = ctx.extra;
+    try {
+      const result = await Runtime.runPromise(extra.runtime)(
+        options.onConnect(ctx.connectionParams ?? {})
+      );
+      if (typeof result === "object" && result !== null) {
+        Object.assign(extra.connectionParams, result);
+      }
+      return result !== false;
+    } catch {
+      return false;
+    }
+  };
+};
+var makeOnDisconnectHandler = (options) => {
+  if (!options?.onDisconnect) return void 0;
+  return async (ctx) => {
+    const extra = ctx.extra;
+    await Runtime.runPromise(extra.runtime)(
+      options.onDisconnect(createConnectionContext(extra))
+    ).catch(() => {
+    });
+  };
+};
+var makeOnSubscribeHandler = (options, schema, complexityConfig, fieldComplexities) => {
+  return async (ctx, id, payload) => {
+    const extra = ctx.extra;
+    const connectionCtx = createConnectionContext(extra);
+    if (complexityConfig) {
+      const validationEffect = validateComplexity(
+        payload.query,
+        payload.operationName ?? void 0,
+        payload.variables ?? void 0,
+        schema,
+        fieldComplexities,
+        complexityConfig
+      ).pipe(
+        Effect.catchAll((error) => {
+          if (error._tag === "ComplexityLimitExceededError") {
+            throw new GraphQLError(error.message, {
+              extensions: {
+                code: "COMPLEXITY_LIMIT_EXCEEDED",
+                limitType: error.limitType,
+                limit: error.limit,
+                actual: error.actual
+              }
+            });
+          }
+          return Effect.logWarning("Complexity analysis failed for subscription", error);
+        })
+      );
+      await Effect.runPromise(validationEffect);
+    }
+    if (options?.onSubscribe) {
+      await Runtime.runPromise(extra.runtime)(
+        options.onSubscribe(connectionCtx, {
+          id,
+          payload: {
+            query: payload.query,
+            variables: payload.variables ?? void 0,
+            operationName: payload.operationName ?? void 0,
+            extensions: payload.extensions ?? void 0
+          }
+        })
+      );
+    }
+  };
+};
+var makeOnCompleteHandler = (options) => {
+  if (!options?.onComplete) return void 0;
+  return async (ctx, id, _payload) => {
+    const extra = ctx.extra;
+    await Runtime.runPromise(extra.runtime)(
+      options.onComplete(createConnectionContext(extra), { id })
+    ).catch(() => {
+    });
+  };
+};
+var makeOnErrorHandler = (options) => {
+  if (!options?.onError) return void 0;
+  return async (ctx, _id, _payload, errors) => {
+    const extra = ctx.extra;
+    await Runtime.runPromise(extra.runtime)(
+      options.onError(createConnectionContext(extra), errors)
+    ).catch(() => {
+    });
+  };
+};
+var createGraphqlWsSocketAdapter = (socket, runtime) => {
+  let messageCallback = null;
+  return {
+    adapter: {
+      protocol: socket.protocol,
+      send: (data) => Runtime.runPromise(runtime)(
+        socket.send(data).pipe(Effect.catchAll((error) => Effect.logError("WebSocket send error", error)))
+      ),
+      close: (code, reason) => {
+        Runtime.runPromise(runtime)(socket.close(code, reason)).catch(() => {
+        });
+      },
+      onMessage: (cb) => {
+        messageCallback = cb;
+      },
+      onPong: (_payload) => {
+      }
+    },
+    dispatchMessage: async (message) => {
+      if (messageCallback) {
+        await messageCallback(message);
+      }
+    }
+  };
+};
+var runConnectionLifecycle = (socket, wsServer, extra) => Effect.gen(function* () {
+  const messageQueue = yield* Queue.unbounded();
+  const closedDeferred = yield* Deferred.make();
+  const messageFiber = yield* Effect.fork(
+    Stream.runForEach(socket.messages, (msg) => Queue.offer(messageQueue, msg)).pipe(
+      Effect.catchAll((error) => Deferred.fail(closedDeferred, error))
+    )
+  );
+  const closeFiber = yield* Effect.fork(
+    socket.closed.pipe(
+      Effect.tap((event) => Deferred.succeed(closedDeferred, event)),
+      Effect.catchAll((error) => Deferred.fail(closedDeferred, error))
+    )
+  );
+  const { adapter, dispatchMessage } = createGraphqlWsSocketAdapter(socket, extra.runtime);
+  const closedHandler = wsServer.opened(adapter, extra);
+  const processMessagesFiber = yield* Effect.fork(
+    Effect.gen(function* () {
+      while (true) {
+        const message = yield* Queue.take(messageQueue);
+        yield* Effect.tryPromise({
+          try: () => dispatchMessage(message),
+          catch: (error) => error
+        }).pipe(Effect.catchAll(() => Effect.void));
+      }
+    })
+  );
+  yield* Deferred.await(closedDeferred).pipe(
+    Effect.catchAll(() => Effect.succeed({ code: 1e3, reason: "Error" }))
+  );
+  closedHandler(1e3, "Connection closed");
+  yield* Fiber.interrupt(messageFiber);
+  yield* Fiber.interrupt(closeFiber);
+  yield* Fiber.interrupt(processMessagesFiber);
+  yield* Queue.shutdown(messageQueue);
+}).pipe(
+  Effect.catchAllCause(() => Effect.void),
+  Effect.scoped
+);
+var makeGraphQLWSHandler = (schema, layer, options) => {
+  const complexityConfig = options?.complexity;
+  const fieldComplexities = options?.fieldComplexities ?? /* @__PURE__ */ new Map();
+  const serverOptions = {
+    schema,
+    context: async (ctx) => {
+      const extra = ctx.extra;
+      return {
+        runtime: extra.runtime,
+        ...extra.connectionParams
+      };
+    },
+    subscribe: async (args) => subscribe(args),
+    onConnect: makeOnConnectHandler(options),
+    onDisconnect: makeOnDisconnectHandler(options),
+    onSubscribe: makeOnSubscribeHandler(options, schema, complexityConfig, fieldComplexities),
+    onComplete: makeOnCompleteHandler(options),
+    onError: makeOnErrorHandler(options)
+  };
+  const wsServer = makeServer(serverOptions);
+  return (socket) => Effect.gen(function* () {
+    const runtime = yield* Effect.provide(Effect.runtime(), layer);
+    const extra = {
+      socket,
+      runtime,
+      connectionParams: {}
+    };
+    yield* runConnectionLifecycle(socket, wsServer, extra);
+  }).pipe(
+    Effect.catchAllCause(() => Effect.void),
+    Effect.scoped
+  );
+};
+var WS_CLOSED = 3;
+var toEffectWebSocketFromWs = (ws) => {
+  const messagesEffect = Effect.gen(function* () {
+    const queue = yield* Queue.unbounded();
+    const closed = yield* Deferred.make();
+    ws.on("message", (data) => {
+      const message = data.toString();
+      Effect.runPromise(Queue.offer(queue, message)).catch(() => {
+      });
+    });
+    ws.on("error", (error) => {
+      Effect.runPromise(Deferred.fail(closed, new WebSocketError({ cause: error }))).catch(() => {
+      });
+    });
+    ws.on("close", (code, reason) => {
+      Effect.runPromise(
+        Queue.shutdown(queue).pipe(
+          Effect.andThen(Deferred.succeed(closed, { code, reason: reason.toString() }))
+        )
+      ).catch(() => {
+      });
+    });
+    return { queue, closed };
+  });
+  const messages = Stream.unwrap(
+    messagesEffect.pipe(
+      Effect.map(({ queue }) => Stream.fromQueue(queue).pipe(Stream.catchAll(() => Stream.empty)))
+    )
+  );
+  return {
+    protocol: ws.protocol || "graphql-transport-ws",
+    send: (data) => Effect.async((resume) => {
+      ws.send(data, (error) => {
+        if (error) {
+          resume(Effect.fail(new WebSocketError({ cause: error })));
+        } else {
+          resume(Effect.succeed(void 0));
+        }
+      });
+    }),
+    close: (code, reason) => Effect.sync(() => {
+      ws.close(code ?? 1e3, reason ?? "");
+    }),
+    messages,
+    closed: Effect.async((resume) => {
+      if (ws.readyState === WS_CLOSED) {
+        resume(Effect.succeed({ code: 1e3, reason: "" }));
+        return;
+      }
+      const onClose = (code, reason) => {
+        cleanup();
+        resume(Effect.succeed({ code, reason: reason.toString() }));
+      };
+      const onError = (error) => {
+        cleanup();
+        resume(Effect.fail(new WebSocketError({ cause: error })));
+      };
+      const cleanup = () => {
+        ws.removeListener("close", onClose);
+        ws.removeListener("error", onError);
+      };
+      ws.on("close", onClose);
+      ws.on("error", onError);
+      return Effect.sync(cleanup);
+    })
+  };
+};
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable nginx buffering
+};
+var SSEError = class extends Data.TaggedError("SSEError") {
+};
+var formatNextEvent = (result) => ({
+  event: "next",
+  data: JSON.stringify(result)
+});
+var formatErrorEvent = (errors) => ({
+  event: "error",
+  data: JSON.stringify({ errors })
+});
+var formatCompleteEvent = () => ({
+  event: "complete",
+  data: ""
+});
+var formatSSEMessage = (event) => {
+  const lines = [`event: ${event.event}`];
+  if (event.data) {
+    lines.push(`data: ${event.data}`);
+  }
+  lines.push("", "");
+  return lines.join("\n");
+};
+var makeSSESubscriptionStream = (schema, layer, request, headers, options) => {
+  const complexityConfig = options?.complexity;
+  const fieldComplexities = options?.fieldComplexities ?? /* @__PURE__ */ new Map();
+  return Stream.unwrap(
+    Effect.gen(function* () {
+      const runtime = yield* Effect.provide(Effect.runtime(), layer);
+      let connectionContext = {};
+      if (options?.onConnect) {
+        try {
+          connectionContext = yield* Effect.provide(options.onConnect(request, headers), layer);
+        } catch {
+          return Stream.make(
+            formatErrorEvent([
+              new GraphQLError("Subscription connection rejected", {
+                extensions: { code: "CONNECTION_REJECTED" }
+              })
+            ]),
+            formatCompleteEvent()
+          );
+        }
+      }
+      let document;
+      try {
+        document = parse(request.query);
+      } catch (syntaxError) {
+        return Stream.make(formatErrorEvent([syntaxError]), formatCompleteEvent());
+      }
+      const validationErrors = validate(schema, document);
+      if (validationErrors.length > 0) {
+        return Stream.make(formatErrorEvent(validationErrors), formatCompleteEvent());
+      }
+      const operations = document.definitions.filter(
+        (d) => d.kind === Kind.OPERATION_DEFINITION
+      );
+      const operation = request.operationName ? operations.find((o) => o.name?.value === request.operationName) : operations[0];
+      if (!operation) {
+        return Stream.make(
+          formatErrorEvent([new GraphQLError("No operation found in query")]),
+          formatCompleteEvent()
+        );
+      }
+      if (operation.operation !== "subscription") {
+        return Stream.make(
+          formatErrorEvent([
+            new GraphQLError(
+              `SSE endpoint only supports subscriptions, received: ${operation.operation}`,
+              { extensions: { code: "OPERATION_NOT_SUPPORTED" } }
+            )
+          ]),
+          formatCompleteEvent()
+        );
+      }
+      if (complexityConfig) {
+        const complexityResult = yield* validateComplexity(
+          request.query,
+          request.operationName,
+          request.variables,
+          schema,
+          fieldComplexities,
+          complexityConfig
+        ).pipe(
+          Effect.map(() => null),
+          Effect.catchAll((error) => {
+            if (error._tag === "ComplexityLimitExceededError") {
+              return Effect.succeed(
+                new GraphQLError(error.message, {
+                  extensions: {
+                    code: "COMPLEXITY_LIMIT_EXCEEDED",
+                    limitType: error.limitType,
+                    limit: error.limit,
+                    actual: error.actual
+                  }
+                })
+              );
+            }
+            return Effect.logWarning("Complexity analysis failed for SSE subscription", error).pipe(
+              Effect.map(() => null)
+            );
+          })
+        );
+        if (complexityResult) {
+          return Stream.make(formatErrorEvent([complexityResult]), formatCompleteEvent());
+        }
+      }
+      const ctx = {
+        runtime,
+        request,
+        connectionContext
+      };
+      if (options?.onSubscribe) {
+        yield* Effect.provide(options.onSubscribe(ctx), layer).pipe(
+          Effect.catchAll(() => Effect.void)
+        );
+      }
+      const graphqlContext = {
+        runtime,
+        ...connectionContext
+      };
+      const subscriptionResult = yield* Effect.tryPromise({
+        try: () => subscribe({
+          schema,
+          document,
+          variableValues: request.variables,
+          operationName: request.operationName ?? void 0,
+          contextValue: graphqlContext
+        }),
+        catch: (error) => new SSEError({ cause: error })
+      });
+      if (!isAsyncIterable(subscriptionResult)) {
+        const result = subscriptionResult;
+        if (result.errors) {
+          return Stream.make(formatErrorEvent(result.errors), formatCompleteEvent());
+        }
+        return Stream.make(formatNextEvent(result), formatCompleteEvent());
+      }
+      const asyncIterator = subscriptionResult[Symbol.asyncIterator]();
+      const eventStream = Stream.async((emit) => {
+        let done = false;
+        const iterate = async () => {
+          try {
+            while (!done) {
+              const result = await asyncIterator.next();
+              if (result.done) {
+                emit.end();
+                break;
+              }
+              emit.single(formatNextEvent(result.value));
+            }
+          } catch (error) {
+            if (!done) {
+              emit.single(
+                formatErrorEvent([
+                  error instanceof GraphQLError ? error : new GraphQLError(
+                    error instanceof Error ? error.message : "Subscription error",
+                    { extensions: { code: "SUBSCRIPTION_ERROR" } }
+                  )
+                ])
+              );
+              emit.end();
+            }
+          }
+        };
+        iterate();
+        return Effect.sync(() => {
+          done = true;
+          asyncIterator.return?.();
+        });
+      });
+      return eventStream.pipe(
+        Stream.onDone(
+          () => Effect.gen(function* () {
+            yield* Effect.sync(() => {
+            });
+          }).pipe(Effect.asVoid)
+        ),
+        Stream.concat(Stream.make(formatCompleteEvent())),
+        Stream.onDone(() => {
+          if (options?.onComplete) {
+            return Effect.provide(options.onComplete(ctx), layer).pipe(
+              Effect.catchAll(() => Effect.void)
+            );
+          }
+          return Effect.void;
+        })
+      );
+    }).pipe(
+      Effect.catchAll(
+        (error) => Effect.succeed(
+          Stream.make(
+            formatErrorEvent([
+              new GraphQLError(error instanceof Error ? error.message : "Internal error", {
+                extensions: { code: "INTERNAL_ERROR" }
+              })
+            ]),
+            formatCompleteEvent()
+          )
+        )
+      )
+    )
+  );
+};
+var makeGraphQLSSEHandler = (schema, layer, options) => {
+  return (request, headers) => makeSSESubscriptionStream(schema, layer, request, headers, options);
+};
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+export { CacheControlConfigFromEnv, ComplexityAnalysisError, ComplexityConfigFromEnv, ComplexityLimitExceededError, GraphQLRouterConfigFromEnv, SSEError, SSE_HEADERS, WS_CLOSED, WebSocketError, combineCalculators, computeCachePolicy, computeCachePolicyFromQuery, defaultComplexityCalculator, defaultConfig, defaultErrorHandler, depthOnlyCalculator, formatCompleteEvent, formatErrorEvent, formatNextEvent, formatSSEMessage, graphiqlHtml, makeGraphQLRouter, makeGraphQLSSEHandler, makeGraphQLWSHandler, makeSSESubscriptionStream, normalizeConfig, toCacheControlHeader, toEffectWebSocketFromWs, toRouter, validateComplexity };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map