@effect-gql/core 0.1.0 → 1.0.0

package/builder/index.js

@@ -0,0 +1,1390 @@
+import { GraphQLDirective, GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType, GraphQLUnionType, GraphQLSchema, GraphQLNonNull, GraphQLString, GraphQLFloat, GraphQLBoolean, GraphQLInt, GraphQLList, parse, GraphQLError, validate, execute as execute$1 } from 'graphql';
+export { DirectiveLocation } from 'graphql';
+import { Pipeable, Context, Runtime, Queue, Option, Effect, Stream, Fiber, Ref } from 'effect';
+import * as S2 from 'effect/Schema';
+import * as AST from 'effect/SchemaAST';
+
+// src/builder/index.ts
+var isIntegerType = (ast) => {
+  if (ast._tag === "Refinement") {
+    const refinement = ast;
+    const annotations = refinement.annotations;
+    if (annotations) {
+      const identifier = AST.getIdentifierAnnotation(refinement);
+      if (identifier._tag === "Some" && identifier.value === "Int") {
+        return true;
+      }
+    }
+    return isIntegerType(refinement.from);
+  }
+  return false;
+};
+var toGraphQLType = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "StringKeyword") return GraphQLString;
+  if (ast._tag === "NumberKeyword") return GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return GraphQLInt;
+    }
+    return toGraphQLType(S2.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? GraphQLInt : GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2.make(elements[0].type);
+      return new GraphQLList(toGraphQLType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Object_${Math.random().toString(36).slice(2, 11)}`;
+    return new GraphQLObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLType(S2.make(ast.to));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLType(S2.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLType(S2.make(innerAst));
+  }
+  return GraphQLString;
+};
+var toGraphQLInputType = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "StringKeyword") return GraphQLString;
+  if (ast._tag === "NumberKeyword") return GraphQLFloat;
+  if (ast._tag === "BooleanKeyword") return GraphQLBoolean;
+  if (ast._tag === "Refinement") {
+    if (isIntegerType(ast)) {
+      return GraphQLInt;
+    }
+    return toGraphQLInputType(S2.make(ast.from));
+  }
+  if (ast._tag === "Literal") {
+    if (typeof ast.literal === "string") return GraphQLString;
+    if (typeof ast.literal === "number") {
+      return Number.isInteger(ast.literal) ? GraphQLInt : GraphQLFloat;
+    }
+    if (typeof ast.literal === "boolean") return GraphQLBoolean;
+  }
+  if (ast._tag === "TupleType") {
+    const elements = ast.elements;
+    if (elements.length > 0) {
+      const elementSchema = S2.make(elements[0].type);
+      return new GraphQLList(toGraphQLInputType(elementSchema));
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new GraphQLNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    const typeName = schema.annotations?.identifier || `Input_${Math.random().toString(36).slice(2, 11)}`;
+    return new GraphQLInputObjectType({
+      name: typeName,
+      fields
+    });
+  }
+  if (ast._tag === "Transformation") {
+    return toGraphQLInputType(S2.make(ast.from));
+  }
+  if (ast._tag === "Union") {
+    const types = ast.types;
+    if (types.length > 0) {
+      return toGraphQLInputType(S2.make(types[0]));
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLInputType(S2.make(innerAst));
+  }
+  return GraphQLString;
+};
+var toGraphQLArgs = (schema) => {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const args = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLInputType(fieldSchema);
+      if (!field2.isOptional) {
+        fieldType = new GraphQLNonNull(fieldType);
+      }
+      args[fieldName] = { type: fieldType };
+    }
+    return args;
+  }
+  throw new Error(`Schema must be an object type to convert to GraphQL arguments`);
+};
+
+// src/builder/type-registry.ts
+function getSchemaName(schema) {
+  const ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    const identifier = AST.getIdentifierAnnotation(ast.to);
+    if (identifier._tag === "Some") {
+      return identifier.value;
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const tagProp = ast.propertySignatures.find((p) => String(p.name) === "_tag");
+    if (tagProp && tagProp.type._tag === "Literal" && typeof tagProp.type.literal === "string") {
+      return tagProp.type.literal;
+    }
+  }
+  return void 0;
+}
+function buildReverseLookups(ctx) {
+  if (!ctx.schemaToTypeName) {
+    ctx.schemaToTypeName = /* @__PURE__ */ new Map();
+    ctx.astToTypeName = /* @__PURE__ */ new Map();
+    for (const [typeName, typeReg] of ctx.types) {
+      ctx.schemaToTypeName.set(typeReg.schema, typeName);
+      ctx.astToTypeName.set(typeReg.schema.ast, typeName);
+    }
+  }
+  if (!ctx.schemaToInterfaceName) {
+    ctx.schemaToInterfaceName = /* @__PURE__ */ new Map();
+    ctx.astToInterfaceName = /* @__PURE__ */ new Map();
+    for (const [interfaceName, interfaceReg] of ctx.interfaces) {
+      ctx.schemaToInterfaceName.set(interfaceReg.schema, interfaceName);
+      ctx.astToInterfaceName.set(interfaceReg.schema.ast, interfaceName);
+    }
+  }
+  if (!ctx.schemaToInputName) {
+    ctx.schemaToInputName = /* @__PURE__ */ new Map();
+    ctx.astToInputName = /* @__PURE__ */ new Map();
+    for (const [inputName, inputReg] of ctx.inputs) {
+      ctx.schemaToInputName.set(inputReg.schema, inputName);
+      ctx.astToInputName.set(inputReg.schema.ast, inputName);
+    }
+  }
+  if (!ctx.enumSortedValues) {
+    ctx.enumSortedValues = /* @__PURE__ */ new Map();
+    ctx.literalToEnumName = /* @__PURE__ */ new Map();
+    for (const [enumName, enumReg] of ctx.enums) {
+      ctx.enumSortedValues.set(enumName, [...enumReg.values].sort());
+      for (const value of enumReg.values) {
+        ctx.literalToEnumName.set(value, enumName);
+      }
+    }
+  }
+  if (!ctx.unionSortedTypes) {
+    ctx.unionSortedTypes = /* @__PURE__ */ new Map();
+    for (const [unionName, unionReg] of ctx.unions) {
+      ctx.unionSortedTypes.set(unionName, [...unionReg.types].sort());
+    }
+  }
+}
+var nonNullCache = /* @__PURE__ */ new WeakMap();
+function getNonNull(type) {
+  let cached = nonNullCache.get(type);
+  if (!cached) {
+    cached = new GraphQLNonNull(type);
+    nonNullCache.set(type, cached);
+  }
+  return cached;
+}
+function toGraphQLTypeWithRegistry(schema, ctx) {
+  buildReverseLookups(ctx);
+  const ast = schema.ast;
+  const registeredType = findRegisteredType(schema, ast, ctx);
+  if (registeredType) return registeredType;
+  const registeredInterface = findRegisteredInterface(schema, ast, ctx);
+  if (registeredInterface) return registeredInterface;
+  if (ast._tag === "Transformation") {
+    return handleTransformationAST(ast, ctx);
+  }
+  if (ast._tag === "Union") {
+    return handleUnionAST(ast, ctx);
+  }
+  if (ast._tag === "Literal") {
+    const enumType2 = findEnumForLiteral(ast, ctx);
+    if (enumType2) return enumType2;
+  }
+  if (ast._tag === "TupleType") {
+    return handleTupleTypeAST(ast, ctx);
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLTypeWithRegistry(S2.make(innerAst), ctx);
+  }
+  return toGraphQLType(schema);
+}
+function findRegisteredType(schema, ast, ctx) {
+  const typeName = ctx.schemaToTypeName?.get(schema) ?? ctx.astToTypeName?.get(ast);
+  if (typeName) {
+    return ctx.typeRegistry.get(typeName);
+  }
+  return void 0;
+}
+function findRegisteredInterface(schema, ast, ctx) {
+  const interfaceName = ctx.schemaToInterfaceName?.get(schema) ?? ctx.astToInterfaceName?.get(ast);
+  if (interfaceName) {
+    return ctx.interfaceRegistry.get(interfaceName);
+  }
+  return void 0;
+}
+function handleTransformationAST(ast, ctx) {
+  const toAst = ast.to;
+  if (toAst._tag === "TupleType") {
+    if (toAst.rest && toAst.rest.length > 0) {
+      const elementSchema = S2.make(toAst.rest[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new GraphQLList(elementType);
+    } else if (toAst.elements.length > 0) {
+      const elementSchema = S2.make(toAst.elements[0].type);
+      const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+      return new GraphQLList(elementType);
+    }
+  }
+  return toGraphQLTypeWithRegistry(S2.make(ast.to), ctx);
+}
+function handleUnionAST(ast, ctx) {
+  const allLiterals = ast.types.every((t) => t._tag === "Literal");
+  if (allLiterals) {
+    const enumType2 = findEnumForLiteralUnion(ast.types, ctx);
+    if (enumType2) return enumType2;
+  } else {
+    const unionType2 = findRegisteredUnion(ast.types, ctx);
+    if (unionType2) return unionType2;
+  }
+  if (ast.types.length > 0) {
+    return toGraphQLTypeWithRegistry(S2.make(ast.types[0]), ctx);
+  }
+  return toGraphQLType(S2.make(ast));
+}
+function findEnumForLiteralUnion(types, ctx) {
+  const literalValues = types.map((t) => String(t.literal)).sort();
+  for (const [enumName] of ctx.enums) {
+    const enumValues = ctx.enumSortedValues?.get(enumName);
+    if (enumValues && literalValues.length === enumValues.length && literalValues.every((v, i) => v === enumValues[i])) {
+      return ctx.enumRegistry.get(enumName);
+    }
+  }
+  return void 0;
+}
+function findRegisteredUnion(types, ctx) {
+  const memberTags = [];
+  for (const memberAst of types) {
+    if (memberAst._tag === "TypeLiteral") {
+      const tagProp = memberAst.propertySignatures.find((p) => String(p.name) === "_tag");
+      if (tagProp && tagProp.type._tag === "Literal") {
+        memberTags.push(String(tagProp.type.literal));
+      }
+    }
+  }
+  if (memberTags.length === types.length) {
+    const sortedTags = memberTags.sort();
+    for (const [unionName] of ctx.unions) {
+      const unionTypes = ctx.unionSortedTypes?.get(unionName);
+      if (unionTypes && sortedTags.length === unionTypes.length && sortedTags.every((tag, i) => tag === unionTypes[i])) {
+        return ctx.unionRegistry.get(unionName);
+      }
+    }
+  }
+  return void 0;
+}
+function findEnumForLiteral(ast, ctx) {
+  const literalValue = String(ast.literal);
+  const enumName = ctx.literalToEnumName?.get(literalValue);
+  if (enumName) {
+    return ctx.enumRegistry.get(enumName);
+  }
+  return void 0;
+}
+function handleTupleTypeAST(ast, ctx) {
+  if (ast.rest && ast.rest.length > 0) {
+    const elementSchema = S2.make(ast.rest[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new GraphQLList(elementType);
+  } else if (ast.elements && ast.elements.length > 0) {
+    const elementSchema = S2.make(ast.elements[0].type);
+    const elementType = toGraphQLTypeWithRegistry(elementSchema, ctx);
+    return new GraphQLList(elementType);
+  }
+  return toGraphQLType(S2.make(ast));
+}
+function schemaToFields(schema, ctx) {
+  let ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    ast = ast.to;
+  }
+  if (ast._tag === "Declaration") {
+    const typeParams = ast.typeParameters;
+    if (typeParams && typeParams.length > 0 && typeParams[0]._tag === "TypeLiteral") {
+      ast = typeParams[0];
+    }
+  }
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLTypeWithRegistry(fieldSchema, ctx);
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    return fields;
+  }
+  return {};
+}
+function schemaToInputFields(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const fields = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLInputTypeWithRegistry(
+        fieldSchema,
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      fields[fieldName] = { type: fieldType };
+    }
+    return fields;
+  }
+  return {};
+}
+function buildInputTypeLookupCache(inputs, enums) {
+  const cache = {
+    schemaToInputName: /* @__PURE__ */ new Map(),
+    astToInputName: /* @__PURE__ */ new Map(),
+    literalToEnumName: /* @__PURE__ */ new Map(),
+    enumSortedValues: /* @__PURE__ */ new Map()
+  };
+  for (const [inputName, inputReg] of inputs) {
+    cache.schemaToInputName.set(inputReg.schema, inputName);
+    cache.astToInputName.set(inputReg.schema.ast, inputName);
+  }
+  for (const [enumName, enumReg] of enums) {
+    cache.enumSortedValues.set(enumName, [...enumReg.values].sort());
+    for (const value of enumReg.values) {
+      cache.literalToEnumName.set(value, enumName);
+    }
+  }
+  return cache;
+}
+function toGraphQLInputTypeWithRegistry(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "Transformation") {
+    const toAst = ast.to;
+    return toGraphQLInputTypeWithRegistry(
+      S2.make(toAst),
+      enumRegistry,
+      inputRegistry,
+      inputs,
+      enums,
+      cache
+    );
+  }
+  if (cache?.schemaToInputName || cache?.astToInputName) {
+    const inputName = cache.schemaToInputName?.get(schema) ?? cache.astToInputName?.get(ast);
+    if (inputName) {
+      const result = inputRegistry.get(inputName);
+      if (result) return result;
+    }
+  } else {
+    for (const [inputName, inputReg] of inputs) {
+      if (inputReg.schema.ast === ast || inputReg.schema === schema) {
+        const result = inputRegistry.get(inputName);
+        if (result) return result;
+      }
+    }
+  }
+  if (ast._tag === "Union") {
+    const unionAst = ast;
+    const nonUndefinedTypes = unionAst.types.filter((t) => t._tag !== "UndefinedKeyword");
+    if (nonUndefinedTypes.length === 1 && nonUndefinedTypes[0]._tag === "Union") {
+      return toGraphQLInputTypeWithRegistry(
+        S2.make(nonUndefinedTypes[0]),
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+    }
+    if (nonUndefinedTypes.length === 1 && nonUndefinedTypes[0]._tag === "TypeLiteral") {
+      return toGraphQLInputTypeWithRegistry(
+        S2.make(nonUndefinedTypes[0]),
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+    }
+    const allLiterals = unionAst.types.every((t) => t._tag === "Literal");
+    if (allLiterals) {
+      const literalValues = unionAst.types.map((t) => String(t.literal)).sort();
+      for (const [enumName] of enums) {
+        const enumValues = cache?.enumSortedValues?.get(enumName) ?? [...enums.get(enumName).values].sort();
+        if (literalValues.length === enumValues.length && literalValues.every((v, i) => v === enumValues[i])) {
+          const result = enumRegistry.get(enumName);
+          if (result) return result;
+        }
+      }
+    }
+  }
+  if (ast._tag === "Literal") {
+    const literalValue = String(ast.literal);
+    if (cache?.literalToEnumName) {
+      const enumName = cache.literalToEnumName.get(literalValue);
+      if (enumName) {
+        const result = enumRegistry.get(enumName);
+        if (result) return result;
+      }
+    } else {
+      for (const [enumName, enumReg] of enums) {
+        if (enumReg.values.includes(literalValue)) {
+          const result = enumRegistry.get(enumName);
+          if (result) return result;
+        }
+      }
+    }
+  }
+  if (ast._tag === "Suspend") {
+    const innerAst = ast.f();
+    return toGraphQLInputTypeWithRegistry(
+      S2.make(innerAst),
+      enumRegistry,
+      inputRegistry,
+      inputs,
+      enums,
+      cache
+    );
+  }
+  return toGraphQLInputType(schema);
+}
+function toGraphQLArgsWithRegistry(schema, enumRegistry, inputRegistry, inputs, enums, cache) {
+  const ast = schema.ast;
+  if (ast._tag === "TypeLiteral") {
+    const args = {};
+    for (const field2 of ast.propertySignatures) {
+      const fieldName = String(field2.name);
+      const fieldSchema = S2.make(field2.type);
+      let fieldType = toGraphQLInputTypeWithRegistry(
+        fieldSchema,
+        enumRegistry,
+        inputRegistry,
+        inputs,
+        enums,
+        cache
+      );
+      if (!field2.isOptional) {
+        fieldType = getNonNull(fieldType);
+      }
+      args[fieldName] = { type: fieldType };
+    }
+    return args;
+  }
+  return toGraphQLArgs(schema);
+}
+function applyDirectives(effect, directives, directiveRegistrations) {
+  if (!directives) return effect;
+  let wrapped = effect;
+  for (const directiveApp of directives) {
+    const directiveReg = directiveRegistrations.get(directiveApp.name);
+    if (directiveReg?.apply) {
+      wrapped = directiveReg.apply(directiveApp.args ?? {})(wrapped);
+    }
+  }
+  return wrapped;
+}
+function applyMiddleware(effect, context, middlewares) {
+  if (middlewares.length === 0) return effect;
+  let wrapped = effect;
+  for (let i = middlewares.length - 1; i >= 0; i--) {
+    const middleware2 = middlewares[i];
+    if (middleware2.match && !middleware2.match(context.info)) {
+      continue;
+    }
+    wrapped = middleware2.apply(wrapped, context);
+  }
+  return wrapped;
+}
+function buildField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    resolve: async (_parent, args, context, info) => {
+      let effect = applyDirectives(
+        config.resolve(args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent: _parent, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    }
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function buildObjectField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    resolve: async (parent, args, context, info) => {
+      let effect = applyDirectives(
+        config.resolve(parent, args),
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    }
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function buildSubscriptionField(config, ctx) {
+  const fieldConfig = {
+    type: toGraphQLTypeWithRegistry(config.type, ctx),
+    // The subscribe function returns an AsyncIterator
+    subscribe: async (_parent, args, context, info) => {
+      let subscribeEffect = config.subscribe(args);
+      subscribeEffect = applyDirectives(
+        subscribeEffect,
+        config.directives,
+        ctx.directiveRegistrations
+      );
+      const middlewareContext = { parent: _parent, args, info };
+      subscribeEffect = applyMiddleware(subscribeEffect, middlewareContext, ctx.middlewares);
+      const stream = await Runtime.runPromise(context.runtime)(subscribeEffect);
+      return streamToAsyncIterator(stream, context.runtime);
+    },
+    // The resolve function transforms each yielded value
+    // If no custom resolve is provided, return the payload directly
+    resolve: config.resolve ? async (value, args, context, info) => {
+      let effect = config.resolve(value, args);
+      const middlewareContext = { parent: value, args, info };
+      effect = applyMiddleware(effect, middlewareContext, ctx.middlewares);
+      return await Runtime.runPromise(context.runtime)(effect);
+    } : (value) => value
+  };
+  if (config.args) {
+    fieldConfig.args = toGraphQLArgsWithRegistry(
+      config.args,
+      ctx.enumRegistry,
+      ctx.inputRegistry,
+      ctx.inputs,
+      ctx.enums,
+      ctx.inputTypeLookupCache
+    );
+  }
+  if (config.description) {
+    fieldConfig.description = config.description;
+  }
+  return fieldConfig;
+}
+function streamToAsyncIterator(stream, runtime) {
+  let queue;
+  let fiber;
+  let initialized = false;
+  let done = false;
+  const initialize = async () => {
+    if (initialized) return;
+    initialized = true;
+    queue = await Runtime.runPromise(runtime)(Queue.unbounded());
+    fiber = Runtime.runFork(runtime)(
+      Effect.ensuring(
+        Stream.runForEach(stream, (value) => Queue.offer(queue, Option.some(value))),
+        // Signal completion by pushing None
+        Queue.offer(queue, Option.none())
+      )
+    );
+  };
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async next() {
+      await initialize();
+      if (done) {
+        return { done: true, value: void 0 };
+      }
+      try {
+        const optionValue = await Runtime.runPromise(runtime)(Queue.take(queue));
+        if (Option.isNone(optionValue)) {
+          done = true;
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: optionValue.value };
+      } catch (error) {
+        done = true;
+        throw error;
+      }
+    },
+    async return() {
+      done = true;
+      if (initialized) {
+        try {
+          await Runtime.runPromise(runtime)(
+            Fiber.interrupt(fiber)
+          );
+          await Runtime.runPromise(runtime)(Queue.shutdown(queue));
+        } catch {
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+}
+
+// src/builder/schema-builder.ts
+function updateState(state, key, value) {
+  return { ...state, [key]: value };
+}
+var GraphQLSchemaBuilder = class _GraphQLSchemaBuilder {
+  constructor(state) {
+    this.state = state;
+  }
+  pipe() {
+    return Pipeable.pipeArguments(this, arguments);
+  }
+  /**
+   * Create an empty schema builder
+   */
+  static empty = new _GraphQLSchemaBuilder({
+    types: /* @__PURE__ */ new Map(),
+    interfaces: /* @__PURE__ */ new Map(),
+    enums: /* @__PURE__ */ new Map(),
+    unions: /* @__PURE__ */ new Map(),
+    inputs: /* @__PURE__ */ new Map(),
+    directives: /* @__PURE__ */ new Map(),
+    middlewares: [],
+    extensions: [],
+    queries: /* @__PURE__ */ new Map(),
+    mutations: /* @__PURE__ */ new Map(),
+    subscriptions: /* @__PURE__ */ new Map(),
+    objectFields: /* @__PURE__ */ new Map()
+  });
+  /**
+   * Create a new builder with updated state
+   */
+  with(newState) {
+    return new _GraphQLSchemaBuilder(newState);
+  }
+  // ============================================================================
+  // Registration Methods
+  // ============================================================================
+  /**
+   * Add a query field
+   */
+  query(name, config) {
+    const newQueries = new Map(this.state.queries);
+    newQueries.set(name, config);
+    return this.with(updateState(this.state, "queries", newQueries));
+  }
+  /**
+   * Add a mutation field
+   */
+  mutation(name, config) {
+    const newMutations = new Map(this.state.mutations);
+    newMutations.set(name, config);
+    return this.with(updateState(this.state, "mutations", newMutations));
+  }
+  /**
+   * Add a subscription field
+   *
+   * Subscriptions return a Stream that yields values over time.
+   * The subscribe function returns an Effect that produces a Stream.
+   *
+   * @example
+   * ```typescript
+   * builder.subscription("userCreated", {
+   *   type: User,
+   *   subscribe: Effect.gen(function*() {
+   *     const pubsub = yield* PubSubService
+   *     return pubsub.subscribe("USER_CREATED")
+   *   }),
+   * })
+   * ```
+   */
+  subscription(name, config) {
+    const newSubscriptions = new Map(this.state.subscriptions);
+    newSubscriptions.set(name, config);
+    return this.with(updateState(this.state, "subscriptions", newSubscriptions));
+  }
+  /**
+   * Register an object type from a schema
+   */
+  objectType(config) {
+    const { schema, implements: implementsInterfaces, directives, cacheControl, fields } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "objectType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newTypes = new Map(this.state.types);
+    newTypes.set(name, { name, schema, implements: implementsInterfaces, directives, cacheControl });
+    let newObjectFields = this.state.objectFields;
+    if (fields) {
+      newObjectFields = new Map(this.state.objectFields);
+      const typeFields = /* @__PURE__ */ new Map();
+      for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+        typeFields.set(fieldName, fieldConfig);
+      }
+      newObjectFields.set(name, typeFields);
+    }
+    return this.with({
+      ...this.state,
+      types: newTypes,
+      objectFields: newObjectFields
+    });
+  }
+  /**
+   * Register an interface type from a schema
+   */
+  interfaceType(config) {
+    const { schema, resolveType, directives } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "interfaceType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newInterfaces = new Map(this.state.interfaces);
+    newInterfaces.set(name, {
+      name,
+      schema,
+      resolveType: resolveType ?? ((value) => value._tag),
+      directives
+    });
+    return this.with(updateState(this.state, "interfaces", newInterfaces));
+  }
+  /**
+   * Register an enum type
+   */
+  enumType(config) {
+    const { name, values, description, directives } = config;
+    const newEnums = new Map(this.state.enums);
+    newEnums.set(name, { name, values, description, directives });
+    return this.with(updateState(this.state, "enums", newEnums));
+  }
+  /**
+   * Register a union type
+   */
+  unionType(config) {
+    const { name, types, resolveType, directives } = config;
+    const newUnions = new Map(this.state.unions);
+    newUnions.set(name, {
+      name,
+      types,
+      resolveType: resolveType ?? ((value) => value._tag),
+      directives
+    });
+    return this.with(updateState(this.state, "unions", newUnions));
+  }
+  /**
+   * Register an input type
+   */
+  inputType(config) {
+    const { schema, description, directives } = config;
+    const name = config.name ?? getSchemaName(schema);
+    if (!name) {
+      throw new Error(
+        "inputType requires a name. Either provide one explicitly or use a TaggedStruct/TaggedClass/Schema.Class"
+      );
+    }
+    const newInputs = new Map(this.state.inputs);
+    newInputs.set(name, { name, schema, description, directives });
+    return this.with(updateState(this.state, "inputs", newInputs));
+  }
+  /**
+   * Register a directive
+   */
+  directive(config) {
+    const newDirectives = new Map(this.state.directives);
+    newDirectives.set(config.name, config);
+    return this.with(updateState(this.state, "directives", newDirectives));
+  }
+  /**
+   * Register a middleware
+   *
+   * Middleware wraps all resolvers (or those matching a pattern) and executes
+   * in an "onion" model - first registered middleware is the outermost layer.
+   *
+   * @param config.name - Middleware name (for debugging/logging)
+   * @param config.description - Optional description
+   * @param config.match - Optional predicate to filter which fields this applies to
+   * @param config.apply - Function that transforms the resolver Effect
+   *
+   * @example
+   * ```typescript
+   * builder.middleware({
+   *   name: "logging",
+   *   apply: (effect, ctx) => Effect.gen(function*() {
+   *     yield* Effect.logInfo(`Resolving ${ctx.info.fieldName}`)
+   *     const start = Date.now()
+   *     const result = yield* effect
+   *     yield* Effect.logInfo(`Resolved in ${Date.now() - start}ms`)
+   *     return result
+   *   })
+   * })
+   * ```
+   */
+  middleware(config) {
+    const newMiddlewares = [...this.state.middlewares, config];
+    return this.with({ ...this.state, middlewares: newMiddlewares });
+  }
+  /**
+   * Register an extension
+   *
+   * Extensions provide lifecycle hooks that run at each phase of request processing
+   * (parse, validate, execute) and can contribute data to the response's extensions field.
+   *
+   * @param config.name - Extension name (for debugging/logging)
+   * @param config.description - Optional description
+   * @param config.onParse - Called after query parsing
+   * @param config.onValidate - Called after validation
+   * @param config.onExecuteStart - Called before execution begins
+   * @param config.onExecuteEnd - Called after execution completes
+   *
+   * @example
+   * ```typescript
+   * builder.extension({
+   *   name: "tracing",
+   *   onExecuteStart: () => Effect.gen(function*() {
+   *     const ext = yield* ExtensionsService
+   *     yield* ext.set("tracing", { startTime: Date.now() })
+   *   }),
+   *   onExecuteEnd: () => Effect.gen(function*() {
+   *     const ext = yield* ExtensionsService
+   *     yield* ext.merge("tracing", { endTime: Date.now() })
+   *   }),
+   * })
+   * ```
+   */
+  extension(config) {
+    const newExtensions = [...this.state.extensions, config];
+    return this.with({ ...this.state, extensions: newExtensions });
+  }
+  /**
+   * Get the registered extensions for use by the execution layer
+   */
+  getExtensions() {
+    return this.state.extensions;
+  }
+  /**
+   * Add a computed/relational field to an object type
+   */
+  field(typeName, fieldName, config) {
+    const newObjectFields = new Map(this.state.objectFields);
+    const typeFields = newObjectFields.get(typeName) || /* @__PURE__ */ new Map();
+    typeFields.set(fieldName, config);
+    newObjectFields.set(typeName, typeFields);
+    return this.with(updateState(this.state, "objectFields", newObjectFields));
+  }
+  // ============================================================================
+  // Schema Building
+  // ============================================================================
+  /**
+   * Get the field complexity map for use in complexity validation.
+   * Maps "TypeName.fieldName" to the complexity value or function.
+   */
+  getFieldComplexities() {
+    const complexities = /* @__PURE__ */ new Map();
+    for (const [name, config] of this.state.queries) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Query.${name}`, config.complexity);
+      }
+    }
+    for (const [name, config] of this.state.mutations) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Mutation.${name}`, config.complexity);
+      }
+    }
+    for (const [name, config] of this.state.subscriptions) {
+      if (config.complexity !== void 0) {
+        complexities.set(`Subscription.${name}`, config.complexity);
+      }
+    }
+    for (const [typeName, fields] of this.state.objectFields) {
+      for (const [fieldName, config] of fields) {
+        if (config.complexity !== void 0) {
+          complexities.set(`${typeName}.${fieldName}`, config.complexity);
+        }
+      }
+    }
+    return complexities;
+  }
+  /**
+   * Get the cache hint map for use in cache control calculation.
+   * Maps "TypeName.fieldName" to the cache hint for field-level hints,
+   * or "TypeName" to the cache hint for type-level hints.
+   */
+  getCacheHints() {
+    const hints = /* @__PURE__ */ new Map();
+    for (const [typeName, typeReg] of this.state.types) {
+      if (typeReg.cacheControl !== void 0) {
+        hints.set(typeName, typeReg.cacheControl);
+      }
+    }
+    for (const [name, config] of this.state.queries) {
+      if (config.cacheControl !== void 0) {
+        hints.set(`Query.${name}`, config.cacheControl);
+      }
+    }
+    for (const [name, config] of this.state.subscriptions) {
+      if (config.cacheControl !== void 0) {
+        hints.set(`Subscription.${name}`, config.cacheControl);
+      }
+    }
+    for (const [typeName, fields] of this.state.objectFields) {
+      for (const [fieldName, config] of fields) {
+        if (config.cacheControl !== void 0) {
+          hints.set(`${typeName}.${fieldName}`, config.cacheControl);
+        }
+      }
+    }
+    return hints;
+  }
+  /**
+   * Build the GraphQL schema (no services required)
+   */
+  buildSchema() {
+    const directiveRegistry = this.buildDirectiveRegistry();
+    const enumRegistry = this.buildEnumRegistry();
+    const inputRegistry = this.buildInputRegistry(enumRegistry);
+    const interfaceRegistry = this.buildInterfaceRegistry(enumRegistry);
+    const { typeRegistry, unionRegistry } = this.buildTypeAndUnionRegistries(
+      enumRegistry,
+      interfaceRegistry
+    );
+    const fieldCtx = this.createFieldBuilderContext(
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      inputRegistry
+    );
+    const queryFields = this.buildQueryFields(fieldCtx);
+    const mutationFields = this.buildMutationFields(fieldCtx);
+    const subscriptionFields = this.buildSubscriptionFields(fieldCtx);
+    return this.assembleSchema({
+      directiveRegistry,
+      enumRegistry,
+      inputRegistry,
+      interfaceRegistry,
+      typeRegistry,
+      unionRegistry,
+      queryFields,
+      mutationFields,
+      subscriptionFields
+    });
+  }
+  buildDirectiveRegistry() {
+    const registry = /* @__PURE__ */ new Map();
+    const cache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    for (const [name, reg] of this.state.directives) {
+      const graphqlDirective = new GraphQLDirective({
+        name,
+        description: reg.description,
+        locations: [...reg.locations],
+        args: reg.args ? toGraphQLArgsWithRegistry(
+          reg.args,
+          /* @__PURE__ */ new Map(),
+          /* @__PURE__ */ new Map(),
+          this.state.inputs,
+          this.state.enums,
+          cache
+        ) : void 0
+      });
+      registry.set(name, graphqlDirective);
+    }
+    return registry;
+  }
+  buildEnumRegistry() {
+    const registry = /* @__PURE__ */ new Map();
+    for (const [name, reg] of this.state.enums) {
+      const enumValues = {};
+      for (const value of reg.values) {
+        enumValues[value] = { value };
+      }
+      registry.set(
+        name,
+        new GraphQLEnumType({
+          name,
+          values: enumValues,
+          description: reg.description,
+          extensions: reg.directives ? { directives: reg.directives } : void 0
+        })
+      );
+    }
+    return registry;
+  }
+  buildInputRegistry(enumRegistry) {
+    const registry = /* @__PURE__ */ new Map();
+    const cache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    for (const [name, reg] of this.state.inputs) {
+      const inputType2 = new GraphQLInputObjectType({
+        name,
+        description: reg.description,
+        fields: () => schemaToInputFields(
+          reg.schema,
+          enumRegistry,
+          registry,
+          this.state.inputs,
+          this.state.enums,
+          cache
+        ),
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      registry.set(name, inputType2);
+    }
+    return registry;
+  }
+  buildInterfaceRegistry(enumRegistry) {
+    const registry = /* @__PURE__ */ new Map();
+    const typeRegistry = /* @__PURE__ */ new Map();
+    const unionRegistry = /* @__PURE__ */ new Map();
+    const sharedCtx = {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry: registry,
+      enumRegistry,
+      unionRegistry};
+    buildReverseLookups(sharedCtx);
+    for (const [name, reg] of this.state.interfaces) {
+      const interfaceType2 = new GraphQLInterfaceType({
+        name,
+        fields: () => schemaToFields(reg.schema, sharedCtx),
+        resolveType: reg.resolveType,
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      registry.set(name, interfaceType2);
+    }
+    return registry;
+  }
+  buildTypeAndUnionRegistries(enumRegistry, interfaceRegistry) {
+    const typeRegistry = /* @__PURE__ */ new Map();
+    const unionRegistry = /* @__PURE__ */ new Map();
+    const sharedCtx = {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry};
+    buildReverseLookups(sharedCtx);
+    const sharedFieldCtx = this.createFieldBuilderContext(
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      /* @__PURE__ */ new Map()
+    );
+    for (const [typeName, typeReg] of this.state.types) {
+      const implementedInterfaces = typeReg.implements?.map((name) => interfaceRegistry.get(name)).filter(Boolean) ?? [];
+      const graphqlType = new GraphQLObjectType({
+        name: typeName,
+        fields: () => {
+          const baseFields = schemaToFields(typeReg.schema, sharedCtx);
+          const additionalFields = this.state.objectFields.get(typeName);
+          if (additionalFields) {
+            for (const [fieldName, fieldConfig] of additionalFields) {
+              baseFields[fieldName] = buildObjectField(fieldConfig, sharedFieldCtx);
+            }
+          }
+          return baseFields;
+        },
+        interfaces: implementedInterfaces.length > 0 ? implementedInterfaces : void 0,
+        extensions: typeReg.directives ? { directives: typeReg.directives } : void 0
+      });
+      typeRegistry.set(typeName, graphqlType);
+    }
+    for (const [name, reg] of this.state.unions) {
+      const unionType2 = new GraphQLUnionType({
+        name,
+        types: () => reg.types.map((typeName) => typeRegistry.get(typeName)).filter(Boolean),
+        resolveType: reg.resolveType,
+        extensions: reg.directives ? { directives: reg.directives } : void 0
+      });
+      unionRegistry.set(name, unionType2);
+    }
+    return { typeRegistry, unionRegistry };
+  }
+  createFieldBuilderContext(typeRegistry, interfaceRegistry, enumRegistry, unionRegistry, inputRegistry) {
+    const inputTypeLookupCache = buildInputTypeLookupCache(this.state.inputs, this.state.enums);
+    return {
+      types: this.state.types,
+      interfaces: this.state.interfaces,
+      enums: this.state.enums,
+      unions: this.state.unions,
+      inputs: this.state.inputs,
+      typeRegistry,
+      interfaceRegistry,
+      enumRegistry,
+      unionRegistry,
+      inputRegistry,
+      directiveRegistrations: this.state.directives,
+      middlewares: this.state.middlewares,
+      inputTypeLookupCache
+    };
+  }
+  buildQueryFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.queries) {
+      fields[name] = buildField(config, ctx);
+    }
+    return fields;
+  }
+  buildMutationFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.mutations) {
+      fields[name] = buildField(config, ctx);
+    }
+    return fields;
+  }
+  buildSubscriptionFields(ctx) {
+    const fields = {};
+    for (const [name, config] of this.state.subscriptions) {
+      fields[name] = buildSubscriptionField(config, ctx);
+    }
+    return fields;
+  }
+  assembleSchema(registries) {
+    const schemaConfig = {
+      types: [
+        ...Array.from(registries.enumRegistry.values()),
+        ...Array.from(registries.inputRegistry.values()),
+        ...Array.from(registries.interfaceRegistry.values()),
+        ...Array.from(registries.typeRegistry.values()),
+        ...Array.from(registries.unionRegistry.values())
+      ],
+      directives: registries.directiveRegistry.size > 0 ? [...Array.from(registries.directiveRegistry.values())] : void 0
+    };
+    if (Object.keys(registries.queryFields).length > 0) {
+      schemaConfig.query = new GraphQLObjectType({
+        name: "Query",
+        fields: registries.queryFields
+      });
+    }
+    if (Object.keys(registries.mutationFields).length > 0) {
+      schemaConfig.mutation = new GraphQLObjectType({
+        name: "Mutation",
+        fields: registries.mutationFields
+      });
+    }
+    if (Object.keys(registries.subscriptionFields).length > 0) {
+      schemaConfig.subscription = new GraphQLObjectType({
+        name: "Subscription",
+        fields: registries.subscriptionFields
+      });
+    }
+    return new GraphQLSchema(schemaConfig);
+  }
+};
+
+// src/builder/pipe-api.ts
+var objectType = (config) => (builder) => builder.objectType(config);
+var interfaceType = (config) => (builder) => builder.interfaceType(config);
+var enumType = (config) => (builder) => builder.enumType(config);
+var unionType = (config) => (builder) => builder.unionType(config);
+var inputType = (config) => (builder) => builder.inputType(config);
+var directive = (config) => (builder) => builder.directive(config);
+var middleware = (config) => (builder) => builder.middleware(config);
+var extension = (config) => (builder) => builder.extension(config);
+var query = (name, config) => (builder) => builder.query(name, config);
+var mutation = (name, config) => (builder) => builder.mutation(name, config);
+var subscription = (name, config) => (builder) => builder.subscription(name, config);
+var field = (typeName, fieldName, config) => (builder) => builder.field(typeName, fieldName, config);
+var compose = (...operations) => (builder) => operations.reduce((b, op) => op(b), builder);
+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/builder/execute.ts
+var execute = (schema, layer, extensions = [], fieldComplexities = /* @__PURE__ */ new Map()) => (source, variableValues, operationName) => Effect.gen(function* () {
+  const extensionsService = yield* makeExtensionsService();
+  const runtime = yield* Effect.runtime();
+  let document;
+  try {
+    document = parse(source);
+  } catch (parseError) {
+    const extensionData2 = yield* extensionsService.get();
+    return {
+      errors: [
+        parseError instanceof GraphQLError ? parseError : new GraphQLError(String(parseError))
+      ],
+      extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+    };
+  }
+  yield* runParseHooks(extensions, source, document).pipe(
+    Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const validationErrors = validate(schema, document);
+  yield* runValidateHooks(extensions, document, validationErrors).pipe(
+    Effect.provideService(ExtensionsService, extensionsService)
+  );
+  if (validationErrors.length > 0) {
+    const extensionData2 = yield* extensionsService.get();
+    return {
+      errors: validationErrors,
+      extensions: Object.keys(extensionData2).length > 0 ? extensionData2 : void 0
+    };
+  }
+  const executionArgs = {
+    source,
+    document,
+    variableValues,
+    operationName,
+    schema,
+    fieldComplexities
+  };
+  yield* runExecuteStartHooks(extensions, executionArgs).pipe(
+    Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const executeResult = yield* Effect.try({
+    try: () => execute$1({
+      schema,
+      document,
+      variableValues,
+      operationName,
+      contextValue: { runtime }
+    }),
+    catch: (error) => new Error(String(error))
+  });
+  const resolvedResult = executeResult && typeof executeResult === "object" && "then" in executeResult ? yield* Effect.promise(() => executeResult) : executeResult;
+  yield* runExecuteEndHooks(extensions, resolvedResult).pipe(
+    Effect.provideService(ExtensionsService, extensionsService)
+  );
+  const extensionData = yield* extensionsService.get();
+  if (Object.keys(extensionData).length > 0) {
+    return {
+      ...resolvedResult,
+      extensions: {
+        ...resolvedResult.extensions,
+        ...extensionData
+      }
+    };
+  }
+  return resolvedResult;
+}).pipe(Effect.provide(layer));
+
+export { GraphQLSchemaBuilder, compose, directive, enumType, execute, extension, field, getSchemaName, inputType, interfaceType, middleware, mutation, objectType, query, subscription, unionType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map