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

@effect-gql/core 0.1.0 → 1.1.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 +1446 -0
package/builder/index.cjs.map +1 -0
package/builder/index.d.cts +260 -0
package/{dist/builder/pipe-api.d.ts → builder/index.d.ts} +50 -21
package/builder/index.js +1405 -0
package/builder/index.js.map +1 -0
package/index.cjs +3469 -0
package/index.cjs.map +1 -0
package/index.d.cts +529 -0
package/index.d.ts +529 -0
package/index.js +3292 -0
package/index.js.map +1 -0
package/package.json +19 -28
package/schema-builder-DKvkzU_M.d.cts +965 -0
package/schema-builder-DKvkzU_M.d.ts +965 -0
package/server/index.cjs +1579 -0
package/server/index.cjs.map +1 -0
package/server/index.d.cts +682 -0
package/server/index.d.ts +682 -0
package/server/index.js +1548 -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.cjs ADDED Viewed

@@ -0,0 +1,1579 @@
+'use strict';
+var effect = require('effect');
+var platform = require('@effect/platform');
+var graphql = require('graphql');
+var graphqlWs = require('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 = effect.Config.all({
+  path: effect.Config.string("GRAPHQL_PATH").pipe(effect.Config.withDefault("/graphql")),
+  introspection: effect.Config.boolean("GRAPHQL_INTROSPECTION").pipe(effect.Config.withDefault(true)),
+  graphiqlEnabled: effect.Config.boolean("GRAPHIQL_ENABLED").pipe(effect.Config.withDefault(false)),
+  graphiqlPath: effect.Config.string("GRAPHIQL_PATH").pipe(effect.Config.withDefault("/graphiql")),
+  graphiqlEndpoint: effect.Config.string("GRAPHIQL_ENDPOINT").pipe(effect.Config.option),
+  maxDepth: effect.Config.number("GRAPHQL_MAX_DEPTH").pipe(effect.Config.option),
+  maxComplexity: effect.Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(effect.Config.option),
+  maxAliases: effect.Config.number("GRAPHQL_MAX_ALIASES").pipe(effect.Config.option),
+  maxFields: effect.Config.number("GRAPHQL_MAX_FIELDS").pipe(effect.Config.option),
+  defaultFieldComplexity: effect.Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    effect.Config.withDefault(1)
+  ),
+  cacheControlEnabled: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(
+    effect.Config.withDefault(false)
+  ),
+  cacheControlDefaultMaxAge: effect.Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(
+    effect.Config.withDefault(0)
+  ),
+  cacheControlDefaultScope: effect.Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    effect.Config.withDefault("PUBLIC")
+  )
+}).pipe(
+  effect.Config.map(
+    ({
+      path,
+      introspection,
+      graphiqlEnabled,
+      graphiqlPath,
+      graphiqlEndpoint,
+      maxDepth,
+      maxComplexity,
+      maxAliases,
+      maxFields,
+      defaultFieldComplexity,
+      cacheControlEnabled,
+      cacheControlDefaultMaxAge,
+      cacheControlDefaultScope
+    }) => {
+      const hasComplexity = effect.Option.isSome(maxDepth) || effect.Option.isSome(maxComplexity) || effect.Option.isSome(maxAliases) || effect.Option.isSome(maxFields);
+      return {
+        path,
+        introspection,
+        graphiql: graphiqlEnabled ? {
+          path: graphiqlPath,
+          endpoint: effect.Option.isSome(graphiqlEndpoint) ? graphiqlEndpoint.value : path
+        } : false,
+        complexity: hasComplexity ? {
+          maxDepth: effect.Option.getOrUndefined(maxDepth),
+          maxComplexity: effect.Option.getOrUndefined(maxComplexity),
+          maxAliases: effect.Option.getOrUndefined(maxAliases),
+          maxFields: effect.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, subscriptionEndpoint) => `<!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)},
+        subscriptionUrl: ${JSON.stringify(subscriptionEndpoint ?? endpoint)},
+      });
+      ReactDOM.createRoot(document.getElementById('graphiql')).render(
+        React.createElement(GraphiQL, { fetcher })
+      );
+    </script>
+  </body>
+</html>`;
+var ComplexityLimitExceededError = class extends effect.Data.TaggedError("ComplexityLimitExceededError") {
+};
+var ComplexityAnalysisError = class extends effect.Data.TaggedError("ComplexityAnalysisError") {
+};
+var defaultComplexityCalculator = (defaultCost = 1) => {
+  return (info) => effect.Effect.try({
+    try: () => {
+      const fragments = /* @__PURE__ */ new Map();
+      for (const definition of info.document.definitions) {
+        if (definition.kind === graphql.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 graphql.GraphQLNonNull || type instanceof graphql.GraphQLList) {
+    return getNamedType(type.ofType);
+  }
+  if (type instanceof graphql.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 graphql.Kind.FIELD:
+      return analyzeField(selection, parentType, ctx, currentDepth, visitedFragments);
+    case graphql.Kind.FRAGMENT_SPREAD:
+      return analyzeFragmentSpread(selection, ctx, currentDepth, visitedFragments);
+    case graphql.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 graphql.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 graphql.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 graphql.Kind.VARIABLE:
+        args[arg.name.value] = variables[value.name.value];
+        break;
+      case graphql.Kind.INT:
+        args[arg.name.value] = parseInt(value.value, 10);
+        break;
+      case graphql.Kind.FLOAT:
+        args[arg.name.value] = parseFloat(value.value);
+        break;
+      case graphql.Kind.STRING:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.BOOLEAN:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.NULL:
+        args[arg.name.value] = null;
+        break;
+      case graphql.Kind.ENUM:
+        args[arg.name.value] = value.value;
+        break;
+      case graphql.Kind.LIST:
+        args[arg.name.value] = [];
+        break;
+      case graphql.Kind.OBJECT:
+        args[arg.name.value] = {};
+        break;
+    }
+  }
+  return args;
+}
+var validateComplexity = (query, operationName, variables, schema, fieldComplexities, config) => effect.Effect.gen(function* () {
+  const document = yield* effect.Effect.try({
+    try: () => graphql.parse(query),
+    catch: (error) => new ComplexityAnalysisError({
+      message: `Failed to parse query: ${error}`,
+      cause: error
+    })
+  });
+  const operation = yield* effect.Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.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.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.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 = effect.Config.all({
+  maxDepth: effect.Config.number("GRAPHQL_MAX_DEPTH").pipe(effect.Config.option),
+  maxComplexity: effect.Config.number("GRAPHQL_MAX_COMPLEXITY").pipe(effect.Config.option),
+  maxAliases: effect.Config.number("GRAPHQL_MAX_ALIASES").pipe(effect.Config.option),
+  maxFields: effect.Config.number("GRAPHQL_MAX_FIELDS").pipe(effect.Config.option),
+  defaultFieldComplexity: effect.Config.number("GRAPHQL_DEFAULT_FIELD_COMPLEXITY").pipe(
+    effect.Config.withDefault(1)
+  )
+}).pipe(
+  effect.Config.map(({ maxDepth, maxComplexity, maxAliases, maxFields, defaultFieldComplexity }) => ({
+    maxDepth: effect.Option.getOrUndefined(maxDepth),
+    maxComplexity: effect.Option.getOrUndefined(maxComplexity),
+    maxAliases: effect.Option.getOrUndefined(maxAliases),
+    maxFields: effect.Option.getOrUndefined(maxFields),
+    defaultFieldComplexity
+  }))
+);
+var depthOnlyCalculator = (info) => effect.Effect.try({
+  try: () => {
+    const fragments = /* @__PURE__ */ new Map();
+    for (const definition of info.document.definitions) {
+      if (definition.kind === graphql.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 graphql.Kind.FIELD:
+        if (selection.selectionSet) {
+          const nestedDepth = calculateMaxDepth(
+            selection.selectionSet,
+            fragments,
+            currentDepth + 1,
+            visitedFragments
+          );
+          maxDepth = Math.max(maxDepth, nestedDepth);
+        }
+        break;
+      case graphql.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 graphql.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.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.Effect.sync(() => {
+  const fragments = /* @__PURE__ */ new Map();
+  for (const definition of info.document.definitions) {
+    if (definition.kind === graphql.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.Effect.gen(function* () {
+  const document = yield* effect.Effect.try({
+    try: () => graphql.parse(query),
+    catch: (error) => new Error(`Failed to parse query: ${error}`)
+  });
+  const operation = yield* effect.Effect.try({
+    try: () => {
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.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 graphql.GraphQLNonNull || type instanceof graphql.GraphQLList) {
+    return getNamedType2(type.ofType);
+  }
+  if (type instanceof graphql.GraphQLObjectType || type instanceof graphql.GraphQLScalarType || type instanceof graphql.GraphQLEnumType) {
+    return type;
+  }
+  return null;
+}
+function isLeafType(type) {
+  const namedType = getNamedType2(type);
+  return namedType instanceof graphql.GraphQLScalarType || namedType instanceof graphql.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 graphql.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 graphql.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 graphql.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 graphql.Kind.FIELD:
+        fieldPolicy = analyzeField2(
+          selection,
+          parentType,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case graphql.Kind.FRAGMENT_SPREAD:
+        fieldPolicy = analyzeFragmentSpread2(
+          selection.name.value,
+          ctx,
+          actualParentMaxAge,
+          actualVisitedFragments
+        );
+        break;
+      case graphql.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 graphql.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 = effect.Config.all({
+  enabled: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_ENABLED").pipe(effect.Config.withDefault(true)),
+  defaultMaxAge: effect.Config.number("GRAPHQL_CACHE_CONTROL_DEFAULT_MAX_AGE").pipe(effect.Config.withDefault(0)),
+  defaultScope: effect.Config.string("GRAPHQL_CACHE_CONTROL_DEFAULT_SCOPE").pipe(
+    effect.Config.withDefault("PUBLIC"),
+    effect.Config.map((s) => s === "PRIVATE" ? "PRIVATE" : "PUBLIC")
+  ),
+  calculateHttpHeaders: effect.Config.boolean("GRAPHQL_CACHE_CONTROL_HTTP_HEADERS").pipe(
+    effect.Config.withDefault(true)
+  )
+});
+var ExtensionsService = effect.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.Effect.gen(function* () {
+  const ref = yield* effect.Ref.make({});
+  return ExtensionsService.of({
+    set: (key, value) => effect.Ref.update(ref, (current) => ({ ...current, [key]: value })),
+    merge: (key, value) => effect.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: () => effect.Ref.get(ref)
+  });
+});
+var runExtensionHooks = (extensions, hookName, getHookEffect) => effect.Effect.forEach(
+  extensions.filter((ext) => ext[hookName] !== void 0),
+  (ext) => getHookEffect(ext).pipe(
+    effect.Effect.catchAllCause(
+      (cause) => effect.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.Effect.logError("GraphQL error", cause) : effect.Effect.void).pipe(
+  effect.Effect.andThen(
+    platform.HttpServerResponse.json(
+      {
+        errors: [
+          {
+            message: "An error occurred processing your request"
+          }
+        ]
+      },
+      { status: 500 }
+    ).pipe(effect.Effect.orDie)
+  )
+);
+var GraphQLRequestBodySchema = effect.Schema.Struct({
+  query: effect.Schema.String,
+  variables: effect.Schema.optionalWith(effect.Schema.Record({ key: effect.Schema.String, value: effect.Schema.Unknown }), {
+    as: "Option"
+  }),
+  operationName: effect.Schema.optionalWith(effect.Schema.String, { as: "Option" })
+});
+var decodeRequestBody = platform.HttpIncomingMessage.schemaBodyJson(GraphQLRequestBodySchema);
+var parseGraphQLQuery = (query, extensionsService) => {
+  try {
+    const document = graphql.parse(query);
+    return effect.Effect.succeed({ ok: true, document });
+  } catch (parseError) {
+    return extensionsService.get().pipe(
+      effect.Effect.flatMap(
+        (extensionData) => platform.HttpServerResponse.json({
+          errors: [{ message: String(parseError) }],
+          extensions: Object.keys(extensionData).length > 0 ? extensionData : void 0
+        }).pipe(
+          effect.Effect.orDie,
+          effect.Effect.map((response) => ({ ok: false, response }))
+        )
+      )
+    );
+  }
+};
+var runComplexityValidation = (body, schema, fieldComplexities, complexityConfig) => {
+  if (!complexityConfig) {
+    return effect.Effect.void;
+  }
+  return validateComplexity(
+    body.query,
+    body.operationName,
+    body.variables,
+    schema,
+    fieldComplexities,
+    complexityConfig
+  ).pipe(
+    effect.Effect.catchTag("ComplexityLimitExceededError", (error) => effect.Effect.fail(error)),
+    effect.Effect.catchTag(
+      "ComplexityAnalysisError",
+      (error) => effect.Effect.logWarning("Complexity analysis failed", error)
+    )
+  );
+};
+var isPromiseLike = (value) => value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+var executeGraphQLQuery = (schema, document, variables, operationName, runtime) => {
+  const tryExecute = effect.Effect.try({
+    try: () => graphql.execute({
+      schema,
+      document,
+      variableValues: variables,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  return tryExecute.pipe(
+    effect.Effect.flatMap((executeResult) => {
+      if (isPromiseLike(executeResult)) {
+        return effect.Effect.promise(() => executeResult);
+      }
+      return effect.Effect.succeed(executeResult);
+    })
+  );
+};
+var computeCacheControlHeader = (document, operationName, schema, cacheHints, cacheControlConfig) => {
+  if (cacheControlConfig?.enabled === false || cacheControlConfig?.calculateHttpHeaders === false) {
+    return effect.Effect.succeed(void 0);
+  }
+  const operations = document.definitions.filter(
+    (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+  );
+  const operation = operationName ? operations.find((o) => o.name?.value === operationName) : operations[0];
+  if (!operation || operation.operation === "mutation") {
+    return effect.Effect.succeed(void 0);
+  }
+  return computeCachePolicy({
+    document,
+    operation,
+    schema,
+    cacheHints,
+    config: cacheControlConfig ?? {}
+  }).pipe(effect.Effect.map(toCacheControlHeader));
+};
+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 platform.HttpServerResponse.json(finalResult, { headers: responseHeaders }).pipe(effect.Effect.orDie);
+};
+var handleComplexityError = (error) => platform.HttpServerResponse.json(
+  {
+    errors: [
+      {
+        message: error.message,
+        extensions: {
+          code: "COMPLEXITY_LIMIT_EXCEEDED",
+          limitType: error.limitType,
+          limit: error.limit,
+          actual: error.actual
+        }
+      }
+    ]
+  },
+  { status: 400 }
+).pipe(effect.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.Effect.gen(function* () {
+    const extensionsService = yield* makeExtensionsService();
+    const runtime = yield* effect.Effect.runtime();
+    const request = yield* platform.HttpServerRequest.HttpServerRequest;
+    const parsedBody = yield* decodeRequestBody(request);
+    const body = {
+      query: parsedBody.query,
+      variables: parsedBody.variables._tag === "Some" ? parsedBody.variables.value : void 0,
+      operationName: parsedBody.operationName._tag === "Some" ? parsedBody.operationName.value : void 0
+    };
+    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.Effect.provideService(ExtensionsService, extensionsService)
+    );
+    const validationRules = resolvedConfig.introspection ? void 0 : graphql.specifiedRules.concat(graphql.NoSchemaIntrospectionCustomRule);
+    const validationErrors = graphql.validate(schema, document, validationRules);
+    yield* runValidateHooks(extensions, document, validationErrors).pipe(
+      effect.Effect.provideService(ExtensionsService, extensionsService)
+    );
+    if (validationErrors.length > 0) {
+      const extensionData2 = yield* extensionsService.get();
+      return yield* platform.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.Effect.provideService(ExtensionsService, extensionsService));
+    const result = yield* executeGraphQLQuery(
+      schema,
+      document,
+      body.variables,
+      body.operationName,
+      runtime
+    );
+    yield* runExecuteEndHooks(extensions, result).pipe(
+      effect.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.Effect.provide(layer),
+    effect.Effect.catchAll((error) => {
+      if (error instanceof ComplexityLimitExceededError) {
+        return handleComplexityError(error);
+      }
+      return effect.Effect.fail(error);
+    }),
+    effect.Effect.catchAllCause(errorHandler)
+  );
+  let router = platform.HttpRouter.empty.pipe(
+    platform.HttpRouter.post(resolvedConfig.path, graphqlHandler)
+  );
+  if (resolvedConfig.graphiql) {
+    const { path, endpoint, subscriptionEndpoint } = resolvedConfig.graphiql;
+    router = router.pipe(
+      platform.HttpRouter.get(
+        path,
+        platform.HttpServerResponse.html(graphiqlHtml(endpoint, subscriptionEndpoint))
+      )
+    );
+  }
+  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 effect.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 effect.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 effect.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.Effect.catchAll((error) => {
+          if (error._tag === "ComplexityLimitExceededError") {
+            throw new graphql.GraphQLError(error.message, {
+              extensions: {
+                code: "COMPLEXITY_LIMIT_EXCEEDED",
+                limitType: error.limitType,
+                limit: error.limit,
+                actual: error.actual
+              }
+            });
+          }
+          return effect.Effect.logWarning("Complexity analysis failed for subscription", error);
+        })
+      );
+      await effect.Effect.runPromise(validationEffect);
+    }
+    if (options?.onSubscribe) {
+      await effect.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 effect.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 effect.Runtime.runPromise(extra.runtime)(
+      options.onError(createConnectionContext(extra), errors)
+    ).catch(() => {
+    });
+  };
+};
+var createGraphqlWsSocketAdapter = (socket, runtime) => {
+  let messageCallback = null;
+  return {
+    adapter: {
+      protocol: socket.protocol,
+      send: (data) => effect.Runtime.runPromise(runtime)(
+        socket.send(data).pipe(effect.Effect.catchAll((error) => effect.Effect.logError("WebSocket send error", error)))
+      ),
+      close: (code, reason) => {
+        effect.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.Effect.gen(function* () {
+  const messageQueue = yield* effect.Queue.unbounded();
+  const closedDeferred = yield* effect.Deferred.make();
+  const messageFiber = yield* effect.Effect.fork(
+    effect.Stream.runForEach(socket.messages, (msg) => effect.Queue.offer(messageQueue, msg)).pipe(
+      effect.Effect.catchAll((error) => effect.Deferred.fail(closedDeferred, error))
+    )
+  );
+  const closeFiber = yield* effect.Effect.fork(
+    socket.closed.pipe(
+      effect.Effect.tap((event) => effect.Deferred.succeed(closedDeferred, event)),
+      effect.Effect.catchAll((error) => effect.Deferred.fail(closedDeferred, error))
+    )
+  );
+  const { adapter, dispatchMessage } = createGraphqlWsSocketAdapter(socket, extra.runtime);
+  const closedHandler = wsServer.opened(adapter, extra);
+  const processMessagesFiber = yield* effect.Effect.fork(
+    effect.Effect.gen(function* () {
+      while (true) {
+        const message = yield* effect.Queue.take(messageQueue);
+        yield* effect.Effect.tryPromise({
+          try: () => dispatchMessage(message),
+          catch: (error) => error
+        }).pipe(effect.Effect.catchAll(() => effect.Effect.void));
+      }
+    })
+  );
+  yield* effect.Deferred.await(closedDeferred).pipe(
+    effect.Effect.catchAll(() => effect.Effect.succeed({ code: 1e3, reason: "Error" }))
+  );
+  closedHandler(1e3, "Connection closed");
+  yield* effect.Fiber.interrupt(messageFiber);
+  yield* effect.Fiber.interrupt(closeFiber);
+  yield* effect.Fiber.interrupt(processMessagesFiber);
+  yield* effect.Queue.shutdown(messageQueue);
+}).pipe(
+  effect.Effect.catchAllCause(() => effect.Effect.void),
+  effect.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) => graphql.subscribe(args),
+    onConnect: makeOnConnectHandler(options),
+    onDisconnect: makeOnDisconnectHandler(options),
+    onSubscribe: makeOnSubscribeHandler(options, schema, complexityConfig, fieldComplexities),
+    onComplete: makeOnCompleteHandler(options),
+    onError: makeOnErrorHandler(options)
+  };
+  const wsServer = graphqlWs.makeServer(serverOptions);
+  return (socket) => effect.Effect.gen(function* () {
+    const runtime = yield* effect.Effect.provide(effect.Effect.runtime(), layer);
+    const extra = {
+      socket,
+      runtime,
+      connectionParams: {}
+    };
+    yield* runConnectionLifecycle(socket, wsServer, extra);
+  }).pipe(
+    effect.Effect.catchAllCause(() => effect.Effect.void),
+    effect.Effect.scoped
+  );
+};
+var WS_CLOSED = 3;
+var toEffectWebSocketFromWs = (ws) => {
+  const messagesEffect = effect.Effect.gen(function* () {
+    const queue = yield* effect.Queue.unbounded();
+    const closed = yield* effect.Deferred.make();
+    ws.on("message", (data) => {
+      const message = data.toString();
+      effect.Effect.runPromise(effect.Queue.offer(queue, message)).catch(() => {
+      });
+    });
+    ws.on("error", (error) => {
+      effect.Effect.runPromise(effect.Deferred.fail(closed, new WebSocketError({ cause: error }))).catch(() => {
+      });
+    });
+    ws.on("close", (code, reason) => {
+      effect.Effect.runPromise(
+        effect.Queue.shutdown(queue).pipe(
+          effect.Effect.andThen(effect.Deferred.succeed(closed, { code, reason: reason.toString() }))
+        )
+      ).catch(() => {
+      });
+    });
+    return { queue, closed };
+  });
+  const messages = effect.Stream.unwrap(
+    messagesEffect.pipe(
+      effect.Effect.map(({ queue }) => effect.Stream.fromQueue(queue).pipe(effect.Stream.catchAll(() => effect.Stream.empty)))
+    )
+  );
+  return {
+    protocol: ws.protocol || "graphql-transport-ws",
+    send: (data) => effect.Effect.async((resume) => {
+      ws.send(data, (error) => {
+        if (error) {
+          resume(effect.Effect.fail(new WebSocketError({ cause: error })));
+        } else {
+          resume(effect.Effect.succeed(void 0));
+        }
+      });
+    }),
+    close: (code, reason) => effect.Effect.sync(() => {
+      ws.close(code ?? 1e3, reason ?? "");
+    }),
+    messages,
+    closed: effect.Effect.async((resume) => {
+      if (ws.readyState === WS_CLOSED) {
+        resume(effect.Effect.succeed({ code: 1e3, reason: "" }));
+        return;
+      }
+      const onClose = (code, reason) => {
+        cleanup();
+        resume(effect.Effect.succeed({ code, reason: reason.toString() }));
+      };
+      const onError = (error) => {
+        cleanup();
+        resume(effect.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.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 effect.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 effect.Stream.unwrap(
+    effect.Effect.gen(function* () {
+      const runtime = yield* effect.Effect.provide(effect.Effect.runtime(), layer);
+      let connectionContext = {};
+      if (options?.onConnect) {
+        try {
+          connectionContext = yield* effect.Effect.provide(options.onConnect(request, headers), layer);
+        } catch {
+          return effect.Stream.make(
+            formatErrorEvent([
+              new graphql.GraphQLError("Subscription connection rejected", {
+                extensions: { code: "CONNECTION_REJECTED" }
+              })
+            ]),
+            formatCompleteEvent()
+          );
+        }
+      }
+      let document;
+      try {
+        document = graphql.parse(request.query);
+      } catch (syntaxError) {
+        return effect.Stream.make(formatErrorEvent([syntaxError]), formatCompleteEvent());
+      }
+      const validationErrors = graphql.validate(schema, document);
+      if (validationErrors.length > 0) {
+        return effect.Stream.make(formatErrorEvent(validationErrors), formatCompleteEvent());
+      }
+      const operations = document.definitions.filter(
+        (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+      );
+      const operation = request.operationName ? operations.find((o) => o.name?.value === request.operationName) : operations[0];
+      if (!operation) {
+        return effect.Stream.make(
+          formatErrorEvent([new graphql.GraphQLError("No operation found in query")]),
+          formatCompleteEvent()
+        );
+      }
+      if (operation.operation !== "subscription") {
+        return effect.Stream.make(
+          formatErrorEvent([
+            new graphql.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.Effect.map(() => null),
+          effect.Effect.catchAll((error) => {
+            if (error._tag === "ComplexityLimitExceededError") {
+              return effect.Effect.succeed(
+                new graphql.GraphQLError(error.message, {
+                  extensions: {
+                    code: "COMPLEXITY_LIMIT_EXCEEDED",
+                    limitType: error.limitType,
+                    limit: error.limit,
+                    actual: error.actual
+                  }
+                })
+              );
+            }
+            return effect.Effect.logWarning("Complexity analysis failed for SSE subscription", error).pipe(
+              effect.Effect.map(() => null)
+            );
+          })
+        );
+        if (complexityResult) {
+          return effect.Stream.make(formatErrorEvent([complexityResult]), formatCompleteEvent());
+        }
+      }
+      const ctx = {
+        runtime,
+        request,
+        connectionContext
+      };
+      if (options?.onSubscribe) {
+        yield* effect.Effect.provide(options.onSubscribe(ctx), layer).pipe(
+          effect.Effect.catchAll(() => effect.Effect.void)
+        );
+      }
+      const graphqlContext = {
+        runtime,
+        ...connectionContext
+      };
+      const subscriptionResult = yield* effect.Effect.tryPromise({
+        try: () => graphql.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 effect.Stream.make(formatErrorEvent(result.errors), formatCompleteEvent());
+        }
+        return effect.Stream.make(formatNextEvent(result), formatCompleteEvent());
+      }
+      const asyncIterator = subscriptionResult[Symbol.asyncIterator]();
+      const eventStream = effect.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 graphql.GraphQLError ? error : new graphql.GraphQLError(
+                    error instanceof Error ? error.message : "Subscription error",
+                    { extensions: { code: "SUBSCRIPTION_ERROR" } }
+                  )
+                ])
+              );
+              emit.end();
+            }
+          }
+        };
+        iterate();
+        return effect.Effect.sync(() => {
+          done = true;
+          asyncIterator.return?.();
+        });
+      });
+      return eventStream.pipe(
+        effect.Stream.onDone(
+          () => effect.Effect.gen(function* () {
+            yield* effect.Effect.sync(() => {
+            });
+          }).pipe(effect.Effect.asVoid)
+        ),
+        effect.Stream.concat(effect.Stream.make(formatCompleteEvent())),
+        effect.Stream.onDone(() => {
+          if (options?.onComplete) {
+            return effect.Effect.provide(options.onComplete(ctx), layer).pipe(
+              effect.Effect.catchAll(() => effect.Effect.void)
+            );
+          }
+          return effect.Effect.void;
+        })
+      );
+    }).pipe(
+      effect.Effect.catchAll(
+        (error) => effect.Effect.succeed(
+          effect.Stream.make(
+            formatErrorEvent([
+              new graphql.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;
+}
+exports.CacheControlConfigFromEnv = CacheControlConfigFromEnv;
+exports.ComplexityAnalysisError = ComplexityAnalysisError;
+exports.ComplexityConfigFromEnv = ComplexityConfigFromEnv;
+exports.ComplexityLimitExceededError = ComplexityLimitExceededError;
+exports.GraphQLRouterConfigFromEnv = GraphQLRouterConfigFromEnv;
+exports.SSEError = SSEError;
+exports.SSE_HEADERS = SSE_HEADERS;
+exports.WS_CLOSED = WS_CLOSED;
+exports.WebSocketError = WebSocketError;
+exports.combineCalculators = combineCalculators;
+exports.computeCachePolicy = computeCachePolicy;
+exports.computeCachePolicyFromQuery = computeCachePolicyFromQuery;
+exports.defaultComplexityCalculator = defaultComplexityCalculator;
+exports.defaultConfig = defaultConfig;
+exports.defaultErrorHandler = defaultErrorHandler;
+exports.depthOnlyCalculator = depthOnlyCalculator;
+exports.formatCompleteEvent = formatCompleteEvent;
+exports.formatErrorEvent = formatErrorEvent;
+exports.formatNextEvent = formatNextEvent;
+exports.formatSSEMessage = formatSSEMessage;
+exports.graphiqlHtml = graphiqlHtml;
+exports.makeGraphQLRouter = makeGraphQLRouter;
+exports.makeGraphQLSSEHandler = makeGraphQLSSEHandler;
+exports.makeGraphQLWSHandler = makeGraphQLWSHandler;
+exports.makeSSESubscriptionStream = makeSSESubscriptionStream;
+exports.normalizeConfig = normalizeConfig;
+exports.toCacheControlHeader = toCacheControlHeader;
+exports.toEffectWebSocketFromWs = toEffectWebSocketFromWs;
+exports.toRouter = toRouter;
+exports.validateComplexity = validateComplexity;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map