@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@graphql-tools/executor/esm/execution/execute.js

@@ -0,0 +1,1101 @@
+import { isPromise, fakePromise, createDeferredPromise, mapAsyncIterator, handleMaybePromise } from "../../../../@whatwg-node/promise-helpers/esm/index.js";
+import { coerceError } from "./coerceError.js";
+import { flattenAsyncIterable } from "./flattenAsyncIterable.js";
+import { invariant } from "./invariant.js";
+import { promiseForObject } from "./promiseForObject.js";
+import { getVariableValues } from "./values.js";
+import { isObjectLike, promiseReduce, isIterableObject } from "../../../utils/esm/jsutils.js";
+import { assertValidSchema } from "../../../../graphql/type/validate.js";
+import { memoize1, memoize3 } from "../../../utils/esm/memoize.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+import { isAsyncIterable } from "../../../utils/esm/isAsyncIterable.js";
+import { collectFields, collectSubFields } from "../../../utils/esm/collectFields.js";
+import { addPath, pathToArray } from "../../../utils/esm/Path.js";
+import { getArgumentValues } from "../../../utils/esm/getArgumentValues.js";
+import { createGraphQLError, locatedError } from "../../../utils/esm/errors.js";
+import { getDefinedRootType } from "../../../utils/esm/rootTypes.js";
+import { SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef } from "../../../../graphql/type/introspection.js";
+import { inspect } from "../../../../cross-inspect/esm/index.js";
+import { isNonNullType, isListType, isLeafType, isAbstractType, isObjectType } from "../../../../graphql/type/definition.js";
+import { GraphQLError } from "../../../../graphql/error/GraphQLError.js";
+import { getDirectiveValues } from "../../../../graphql/execution/values.js";
+import { GraphQLStreamDirective } from "../../../utils/esm/directives.js";
+import { versionInfo } from "../../../../graphql/version.js";
+import { DisposableSymbols } from "../../../../@whatwg-node/disposablestack/esm/symbols.js";
+const collectSubfields = memoize3((exeContext, returnType, fieldNodes) => collectSubFields(exeContext.schema, exeContext.fragments, exeContext.variableValues, returnType, fieldNodes));
+function execute(args) {
+  const exeContext = buildExecutionContext(args);
+  if (!("schema" in exeContext)) {
+    return {
+      errors: exeContext.map((e) => {
+        Object.defineProperty(e, "extensions", {
+          value: {
+            ...e.extensions,
+            http: {
+              ...e.extensions?.["http"] || {},
+              status: 400
+            }
+          }
+        });
+        return e;
+      })
+    };
+  }
+  return executeImpl(exeContext);
+}
+function executeImpl(exeContext) {
+  exeContext.signal?.throwIfAborted();
+  return handleMaybePromise(() => executeOperation(exeContext), (data) => {
+    const initialResult = buildResponse(data, exeContext.errors);
+    if (exeContext.subsequentPayloads.size > 0) {
+      return {
+        initialResult: {
+          ...initialResult,
+          hasNext: true
+        },
+        subsequentResults: yieldSubsequentPayloads(exeContext)
+      };
+    }
+    return initialResult;
+  }, (error) => {
+    exeContext.signal?.throwIfAborted();
+    if (error.errors) {
+      exeContext.errors.push(...error.errors);
+    } else {
+      exeContext.errors.push(error);
+    }
+    return buildResponse(null, exeContext.errors);
+  });
+}
+function buildResponse(data, errors) {
+  return errors.length === 0 ? { data } : { errors, data };
+}
+const getFragmentsFromDocument = memoize1(function getFragmentsFromDocument2(document) {
+  const fragments = /* @__PURE__ */ Object.create(null);
+  for (const definition of document.definitions) {
+    if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+      fragments[definition.name.value] = definition;
+    }
+  }
+  return fragments;
+});
+function buildExecutionContext(args) {
+  const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, signal, schemaCoordinateInErrors } = args;
+  signal?.throwIfAborted();
+  assertValidSchema(schema);
+  const fragments = getFragmentsFromDocument(document);
+  let operation;
+  for (const definition of document.definitions) {
+    switch (definition.kind) {
+      case Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== void 0) {
+            return [
+              createGraphQLError("Must provide operation name if query contains multiple operations.", {
+                extensions: {
+                  code: "OPERATION_RESOLUTION_FAILURE"
+                }
+              })
+            ];
+          }
+          operation = definition;
+        } else if (definition.name?.value === operationName) {
+          operation = definition;
+        }
+        break;
+    }
+  }
+  if (operation == null) {
+    if (operationName != null) {
+      return [
+        createGraphQLError(`Unknown operation named "${operationName}".`, {
+          extensions: {
+            code: "OPERATION_RESOLUTION_FAILURE"
+          }
+        })
+      ];
+    }
+    return [
+      createGraphQLError("Must provide an operation.", {
+        extensions: {
+          code: "OPERATION_RESOLUTION_FAILURE"
+        }
+      })
+    ];
+  }
+  const variableDefinitions = operation.variableDefinitions ?? [];
+  const coercedVariableValues = getVariableValues(schema, variableDefinitions, rawVariableValues ?? {}, {
+    maxErrors: 50
+  });
+  if (coercedVariableValues.errors) {
+    return coercedVariableValues.errors;
+  }
+  signal?.throwIfAborted();
+  let onSignalAbort;
+  let signalPromise;
+  if (signal) {
+    const listeners = /* @__PURE__ */ new Set();
+    const signalDeferred = createDeferredPromise();
+    signalPromise = signalDeferred.promise;
+    const sharedListener = () => {
+      signalDeferred.reject(signal.reason);
+      signal.removeEventListener("abort", sharedListener);
+    };
+    signal.addEventListener("abort", sharedListener, { once: true });
+    signalPromise.catch(() => {
+      for (const listener of listeners) {
+        listener();
+      }
+      listeners.clear();
+    });
+    onSignalAbort = (handler) => {
+      listeners.add(handler);
+    };
+  }
+  return {
+    schema,
+    fragments,
+    rootValue,
+    contextValue,
+    operation,
+    variableValues: coercedVariableValues.coerced,
+    fieldResolver: fieldResolver ?? defaultFieldResolver,
+    typeResolver: typeResolver ?? defaultTypeResolver,
+    subscribeFieldResolver: subscribeFieldResolver ?? defaultFieldResolver,
+    subsequentPayloads: /* @__PURE__ */ new Set(),
+    errors: [],
+    signal,
+    onSignalAbort,
+    signalPromise,
+    schemaCoordinateInErrors
+  };
+}
+function buildPerEventExecutionContext(exeContext, payload) {
+  return {
+    ...exeContext,
+    rootValue: payload,
+    subsequentPayloads: /* @__PURE__ */ new Set(),
+    errors: []
+  };
+}
+function executeOperation(exeContext) {
+  const { operation, schema, fragments, variableValues, rootValue } = exeContext;
+  const rootType = getDefinedRootType(schema, operation.operation, [operation]);
+  if (rootType == null) {
+    createGraphQLError(`Schema is not configured to execute ${operation.operation} operation.`, {
+      nodes: operation
+    });
+  }
+  const { fields: rootFields, patches } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
+  const path = void 0;
+  let result;
+  if (operation.operation === "mutation") {
+    result = executeFieldsSerially(exeContext, rootType, rootValue, path, rootFields);
+  } else {
+    result = executeFields(exeContext, rootType, rootValue, path, rootFields);
+  }
+  for (const patch of patches) {
+    const { label, fields: patchFields } = patch;
+    executeDeferredFragment(exeContext, rootType, rootValue, patchFields, label, path);
+  }
+  return result;
+}
+function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+  return promiseReduce(fields, (results, [responseName, fieldNodes]) => {
+    const fieldPath = addPath(path, responseName, parentType.name);
+    exeContext.signal?.throwIfAborted();
+    return handleMaybePromise(() => executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath), (result) => {
+      if (result === void 0) {
+        return results;
+      }
+      results[responseName] = result;
+      return results;
+    });
+  }, /* @__PURE__ */ Object.create(null));
+}
+function executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord) {
+  const results = /* @__PURE__ */ Object.create(null);
+  let containsPromise = false;
+  try {
+    for (const [responseName, fieldNodes] of fields) {
+      exeContext.signal?.throwIfAborted();
+      const fieldPath = addPath(path, responseName, parentType.name);
+      const result = executeField(exeContext, parentType, sourceValue, fieldNodes, fieldPath, asyncPayloadRecord);
+      if (result !== void 0) {
+        results[responseName] = result;
+        if (isPromise(result)) {
+          containsPromise = true;
+        }
+      }
+    }
+  } catch (error) {
+    if (error !== exeContext.signal?.reason && containsPromise) {
+      return handleMaybePromise(() => promiseForObject(results, exeContext.signal), () => {
+        throw error;
+      }, () => {
+        throw error;
+      });
+    }
+    throw error;
+  }
+  if (!containsPromise) {
+    return results;
+  }
+  return promiseForObject(results, exeContext.signal, exeContext.signalPromise);
+}
+function executeField(exeContext, parentType, source, fieldNodes, path, asyncPayloadRecord) {
+  const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
+  const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
+  if (!fieldDef) {
+    return;
+  }
+  const returnType = fieldDef.type;
+  const resolveFn = fieldDef.resolve ?? exeContext.fieldResolver;
+  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path);
+  try {
+    exeContext.signal?.throwIfAborted();
+    const args = getArgumentValues(fieldDef, fieldNodes[0], exeContext.variableValues);
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(source, args, contextValue, info);
+    let completed;
+    if (isPromise(result)) {
+      completed = result.then((resolved) => completeValue(exeContext, returnType, fieldNodes, info, path, resolved, asyncPayloadRecord));
+    } else {
+      completed = completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+    }
+    if (isPromise(completed)) {
+      return completed.then(void 0, (rawError) => {
+        if (rawError instanceof AggregateError) {
+          let result2;
+          for (let rawErrorItem of rawError.errors) {
+            rawErrorItem = coerceError(rawErrorItem);
+            const error2 = locatedError(rawErrorItem, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+            result2 = handleFieldError(error2, returnType, errors);
+            filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+          }
+          return result2;
+        }
+        rawError = coerceError(rawError);
+        const error = locatedError(rawError, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+        const handledError = handleFieldError(error, returnType, errors);
+        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+        return handledError;
+      });
+    }
+    return completed;
+  } catch (rawError) {
+    if (rawError instanceof AggregateError) {
+      let result;
+      for (let rawErrorItem of rawError.errors) {
+        rawErrorItem = coerceError(rawErrorItem);
+        const error2 = locatedError(rawErrorItem, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+        result = handleFieldError(error2, returnType, errors);
+        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+      }
+      return result;
+    }
+    const coercedError = coerceError(rawError);
+    const error = locatedError(coercedError, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+    const handledError = handleFieldError(error, returnType, errors);
+    filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+    return handledError;
+  }
+}
+function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
+  return {
+    fieldName: fieldDef.name,
+    fieldNodes,
+    returnType: fieldDef.type,
+    parentType,
+    path,
+    schema: exeContext.schema,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues,
+    signal: exeContext.signal
+  };
+}
+const CRITICAL_ERROR = "CRITICAL_ERROR";
+function handleFieldError(error, returnType, errors) {
+  if (isNonNullType(returnType)) {
+    throw error;
+  }
+  if (error.extensions?.[CRITICAL_ERROR]) {
+    throw error;
+  }
+  errors.push(error);
+  return null;
+}
+function completeValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (isNonNullType(returnType)) {
+    const completed = completeValue(exeContext, returnType.ofType, fieldNodes, info, path, result, asyncPayloadRecord);
+    if (completed === null) {
+      throw new Error(`Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`);
+    }
+    return completed;
+  }
+  if (result == null) {
+    return null;
+  }
+  if (isListType(returnType)) {
+    return completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+  }
+  if (isLeafType(returnType)) {
+    return completeLeafValue(returnType, result);
+  }
+  if (isAbstractType(returnType)) {
+    return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+  }
+  if (isObjectType(returnType)) {
+    return completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord);
+  }
+  console.assert(false, "Cannot complete value of unexpected output type: " + inspect(returnType));
+}
+function getStreamValues(exeContext, fieldNodes, path) {
+  if (typeof path.key === "number") {
+    return;
+  }
+  const stream = getDirectiveValues(GraphQLStreamDirective, fieldNodes[0], exeContext.variableValues);
+  if (!stream) {
+    return;
+  }
+  if (stream.if === false) {
+    return;
+  }
+  invariant(typeof stream["initialCount"] === "number", "initialCount must be a number");
+  invariant(stream["initialCount"] >= 0, "initialCount must be a positive integer");
+  return {
+    initialCount: stream["initialCount"],
+    label: typeof stream["label"] === "string" ? stream["label"] : void 0
+  };
+}
+async function completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord) {
+  exeContext.signal?.throwIfAborted();
+  if (iterator.return) {
+    exeContext.onSignalAbort?.(() => {
+      iterator.return?.();
+    });
+  }
+  const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
+  const stream = getStreamValues(exeContext, fieldNodes, path);
+  let containsPromise = false;
+  const completedResults = [];
+  let index = 0;
+  while (true) {
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      executeStreamIterator(index, iterator, exeContext, fieldNodes, info, itemType, path, stream.label, asyncPayloadRecord);
+      break;
+    }
+    const itemPath = addPath(path, index, void 0);
+    let iteration;
+    try {
+      iteration = await iterator.next();
+      if (iteration.done) {
+        break;
+      }
+    } catch (rawError) {
+      const coercedError = coerceError(rawError);
+      const error = locatedError(coercedError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+      completedResults.push(handleFieldError(error, itemType, errors));
+      break;
+    }
+    if (completeListItemValue(iteration.value, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
+      containsPromise = true;
+    }
+    index += 1;
+  }
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeListValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+  const itemType = returnType.ofType;
+  const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
+  if (isAsyncIterable(result)) {
+    const iterator = result[Symbol.asyncIterator]();
+    return completeAsyncIteratorValue(exeContext, itemType, fieldNodes, info, path, iterator, asyncPayloadRecord);
+  }
+  if (!isIterableObject(result)) {
+    throw createGraphQLError(`Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`);
+  }
+  const stream = getStreamValues(exeContext, fieldNodes, path);
+  let containsPromise = false;
+  let previousAsyncPayloadRecord = asyncPayloadRecord;
+  const completedResults = [];
+  let index = 0;
+  for (const item of result) {
+    const itemPath = addPath(path, index, void 0);
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      previousAsyncPayloadRecord = executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, stream.label, previousAsyncPayloadRecord);
+      index++;
+      continue;
+    }
+    if (completeListItemValue(item, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord)) {
+      containsPromise = true;
+    }
+    index++;
+  }
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeListItemValue(item, completedResults, errors, exeContext, itemType, fieldNodes, info, itemPath, asyncPayloadRecord) {
+  try {
+    let completedItem;
+    if (isPromise(item)) {
+      completedItem = item.then((resolved) => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved, asyncPayloadRecord));
+    } else {
+      completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
+    }
+    if (isPromise(completedItem)) {
+      completedResults.push(completedItem.then(void 0, (rawError) => {
+        rawError = coerceError(rawError);
+        const error = locatedError(rawError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+        const handledError = handleFieldError(error, itemType, errors);
+        filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+        return handledError;
+      }));
+      return true;
+    }
+    completedResults.push(completedItem);
+  } catch (rawError) {
+    const coercedError = coerceError(rawError);
+    const error = locatedError(coercedError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+    const handledError = handleFieldError(error, itemType, errors);
+    filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+    completedResults.push(handledError);
+  }
+  return false;
+}
+function completeLeafValue(returnType, result) {
+  let serializedResult;
+  try {
+    serializedResult = returnType.serialize(result);
+  } catch (err) {
+    if (err instanceof GraphQLError) {
+      throw new Error(err.message);
+    }
+    throw err;
+  }
+  if (serializedResult == null) {
+    throw new Error(`Expected \`${inspect(returnType)}.serialize(${inspect(result)})\` to return non-nullable value, returned: ${inspect(serializedResult)}`);
+  }
+  return serializedResult;
+}
+function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+  const resolveTypeFn = returnType.resolveType ?? exeContext.typeResolver;
+  const contextValue = exeContext.contextValue;
+  const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
+  if (isPromise(runtimeType)) {
+    return runtimeType.then((resolvedRuntimeType) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord));
+  }
+  return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeType, exeContext, returnType, fieldNodes, info, result), fieldNodes, info, path, result, asyncPayloadRecord);
+}
+function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNodes, info, result) {
+  if (runtimeTypeName == null) {
+    throw createGraphQLError(`Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`, { nodes: fieldNodes });
+  }
+  if (isObjectType(runtimeTypeName)) {
+    if (versionInfo.major >= 16) {
+      throw createGraphQLError("Support for returning GraphQLObjectType from resolveType was removed in graphql-js@16.0.0 please return type name instead.");
+    }
+    runtimeTypeName = runtimeTypeName.name;
+  }
+  if (typeof runtimeTypeName !== "string") {
+    throw createGraphQLError(`Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}" with value ${inspect(result)}, received "${inspect(runtimeTypeName)}".`);
+  }
+  const runtimeType = exeContext.schema.getType(runtimeTypeName);
+  if (runtimeType == null) {
+    throw createGraphQLError(`Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`, { nodes: fieldNodes });
+  }
+  if (!isObjectType(runtimeType)) {
+    throw createGraphQLError(`Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`, { nodes: fieldNodes });
+  }
+  if (!exeContext.schema.isSubType(returnType, runtimeType)) {
+    throw createGraphQLError(`Runtime Object type "${runtimeType.name}" is not a possible type for "${returnType.name}".`, { nodes: fieldNodes });
+  }
+  return runtimeType;
+}
+function completeObjectValue(exeContext, returnType, fieldNodes, info, path, result, asyncPayloadRecord) {
+  if (returnType.isTypeOf) {
+    const isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info);
+    if (isPromise(isTypeOf)) {
+      return isTypeOf.then((resolvedIsTypeOf) => {
+        if (!resolvedIsTypeOf) {
+          throw invalidReturnTypeError(returnType, result, fieldNodes);
+        }
+        return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
+      });
+    }
+    if (!isTypeOf) {
+      throw invalidReturnTypeError(returnType, result, fieldNodes);
+    }
+  }
+  return collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord);
+}
+function invalidReturnTypeError(returnType, result, fieldNodes) {
+  return createGraphQLError(`Expected value of type "${returnType.name}" but got: ${inspect(result)}.`, {
+    nodes: fieldNodes
+  });
+}
+function collectAndExecuteSubfields(exeContext, returnType, fieldNodes, path, result, asyncPayloadRecord) {
+  const { fields: subFieldNodes, patches: subPatches } = collectSubfields(exeContext, returnType, fieldNodes);
+  const subFields = executeFields(exeContext, returnType, result, path, subFieldNodes, asyncPayloadRecord);
+  for (const subPatch of subPatches) {
+    const { label, fields: subPatchFieldNodes } = subPatch;
+    executeDeferredFragment(exeContext, returnType, result, subPatchFieldNodes, label, path, asyncPayloadRecord);
+  }
+  return subFields;
+}
+const defaultTypeResolver = function(value, contextValue, info, abstractType) {
+  if (isObjectLike(value) && typeof value["__typename"] === "string") {
+    return value["__typename"];
+  }
+  const possibleTypes = info.schema.getPossibleTypes(abstractType);
+  const promisedIsTypeOfResults = [];
+  for (let i = 0; i < possibleTypes.length; i++) {
+    const type = possibleTypes[i];
+    if (type.isTypeOf) {
+      const isTypeOfResult = type.isTypeOf(value, contextValue, info);
+      if (isPromise(isTypeOfResult)) {
+        promisedIsTypeOfResults[i] = isTypeOfResult;
+      } else if (isTypeOfResult) {
+        return type.name;
+      }
+    }
+  }
+  if (promisedIsTypeOfResults.length) {
+    return Promise.all(promisedIsTypeOfResults).then((isTypeOfResults) => {
+      for (let i = 0; i < isTypeOfResults.length; i++) {
+        if (isTypeOfResults[i]) {
+          return possibleTypes[i].name;
+        }
+      }
+    });
+  }
+};
+const defaultFieldResolver = function(source, args, contextValue, info) {
+  if (isObjectLike(source) || typeof source === "function") {
+    const property = source[info.fieldName];
+    if (typeof property === "function") {
+      return source[info.fieldName](args, contextValue, info);
+    }
+    return property;
+  }
+};
+function subscribe(args) {
+  const exeContext = buildExecutionContext(args);
+  if (!("schema" in exeContext)) {
+    for (const error of exeContext) {
+      const extensions = error.extensions ||= {};
+      const httpExtensions = extensions["http"] ||= {};
+      httpExtensions.status = 400;
+      error.extensions["code"] = "BAD_USER_INPUT";
+    }
+    return {
+      errors: exeContext
+    };
+  }
+  const resultOrStream = createSourceEventStreamImpl(exeContext);
+  if (isPromise(resultOrStream)) {
+    return resultOrStream.then((resolvedResultOrStream) => mapSourceToResponse(exeContext, resolvedResultOrStream));
+  }
+  return mapSourceToResponse(exeContext, resultOrStream);
+}
+function isIncrementalResults(results) {
+  return results?.initialResult;
+}
+function flattenIncrementalResults(incrementalResults) {
+  const subsequentIterator = incrementalResults.subsequentResults;
+  let initialResultSent = false;
+  let done = false;
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      if (done) {
+        return fakePromise({ value: void 0, done });
+      }
+      if (initialResultSent) {
+        return subsequentIterator.next();
+      }
+      initialResultSent = true;
+      return fakePromise({
+        value: incrementalResults.initialResult,
+        done
+      });
+    },
+    return() {
+      done = true;
+      return subsequentIterator.return();
+    },
+    throw(error) {
+      done = true;
+      return subsequentIterator.throw(error);
+    },
+    [DisposableSymbols.asyncDispose]() {
+      done = true;
+      return subsequentIterator?.[DisposableSymbols.asyncDispose]?.();
+    }
+  };
+}
+async function* ensureAsyncIterable(someExecutionResult) {
+  if ("initialResult" in someExecutionResult) {
+    yield* flattenIncrementalResults(someExecutionResult);
+  } else {
+    yield someExecutionResult;
+  }
+}
+function mapSourceToResponse(exeContext, resultOrStream) {
+  if (!isAsyncIterable(resultOrStream)) {
+    return resultOrStream;
+  }
+  return flattenAsyncIterable(mapAsyncIterator(resultOrStream, (payload) => handleMaybePromise(() => executeImpl(buildPerEventExecutionContext(exeContext, payload)), ensureAsyncIterable), (error) => {
+    if (error instanceof AggregateError) {
+      throw new AggregateError(error.errors.map((e) => wrapError(e, exeContext.operation)), error.message);
+    }
+    throw wrapError(error, exeContext.operation);
+  }));
+}
+function wrapError(error, operation) {
+  return createGraphQLError(error.message, {
+    originalError: error,
+    nodes: [operation]
+  });
+}
+function createSourceEventStreamImpl(exeContext) {
+  try {
+    const eventStream = executeSubscription(exeContext);
+    if (isPromise(eventStream)) {
+      return eventStream.then(void 0, (error) => ({ errors: [error] }));
+    }
+    return eventStream;
+  } catch (error) {
+    return { errors: [error] };
+  }
+}
+function executeSubscription(exeContext) {
+  const { schema, fragments, operation, variableValues, rootValue } = exeContext;
+  const rootType = schema.getSubscriptionType();
+  if (rootType == null) {
+    throw createGraphQLError("Schema is not configured to execute subscription operation.", {
+      nodes: operation
+    });
+  }
+  const { fields: rootFields } = collectFields(schema, fragments, variableValues, rootType, operation.selectionSet);
+  const [responseName, fieldNodes] = [...rootFields.entries()][0];
+  const fieldName = fieldNodes[0].name.value;
+  const fieldDef = getFieldDef(schema, rootType, fieldNodes[0]);
+  if (!fieldDef) {
+    throw createGraphQLError(`The subscription field "${fieldName}" is not defined.`, {
+      nodes: fieldNodes
+    });
+  }
+  const path = addPath(void 0, responseName, rootType.name);
+  const info = buildResolveInfo(exeContext, fieldDef, fieldNodes, rootType, path);
+  try {
+    const args = getArgumentValues(fieldDef, fieldNodes[0], variableValues);
+    const contextValue = exeContext.contextValue;
+    const resolveFn = fieldDef.subscribe ?? exeContext.subscribeFieldResolver;
+    const result = resolveFn(rootValue, args, contextValue, info);
+    if (isPromise(result)) {
+      return result.then((result2) => assertEventStream(result2, exeContext.signal, exeContext.onSignalAbort)).then(void 0, (error) => {
+        throw locatedError(error, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+      });
+    }
+    return assertEventStream(result, exeContext.signal, exeContext.onSignalAbort);
+  } catch (error) {
+    throw locatedError(error, fieldNodes, pathToArray(path), exeContext.schemaCoordinateInErrors && info);
+  }
+}
+function assertEventStream(result, signal, onSignalAbort) {
+  signal?.throwIfAborted();
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (!isAsyncIterable(result)) {
+    throw createGraphQLError(`Subscription field must return Async Iterable. Received: ${inspect(result)}.`);
+  }
+  if (onSignalAbort) {
+    return {
+      [Symbol.asyncIterator]() {
+        const asyncIterator = result[Symbol.asyncIterator]();
+        if (asyncIterator.return) {
+          onSignalAbort?.(() => {
+            asyncIterator.return?.();
+          });
+        }
+        return asyncIterator;
+      }
+    };
+  }
+  return result;
+}
+function executeDeferredFragment(exeContext, parentType, sourceValue, fields, label, path, parentContext) {
+  const asyncPayloadRecord = new DeferredFragmentRecord({
+    label,
+    path,
+    parentContext,
+    exeContext
+  });
+  let promiseOrData;
+  try {
+    promiseOrData = executeFields(exeContext, parentType, sourceValue, path, fields, asyncPayloadRecord);
+    if (isPromise(promiseOrData)) {
+      promiseOrData = promiseOrData.then(null, (e) => {
+        asyncPayloadRecord.errors.push(e);
+        return null;
+      });
+    }
+  } catch (e) {
+    asyncPayloadRecord.errors.push(e);
+    promiseOrData = null;
+  }
+  asyncPayloadRecord.addData(promiseOrData);
+}
+function executeStreamField(path, itemPath, item, exeContext, fieldNodes, info, itemType, label, parentContext) {
+  const asyncPayloadRecord = new StreamRecord({
+    label,
+    path: itemPath,
+    parentContext,
+    exeContext
+  });
+  let completedItem;
+  try {
+    try {
+      if (isPromise(item)) {
+        completedItem = item.then((resolved) => completeValue(exeContext, itemType, fieldNodes, info, itemPath, resolved, asyncPayloadRecord));
+      } else {
+        completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
+      }
+      if (isPromise(completedItem)) {
+        completedItem = completedItem.then(void 0, (rawError) => {
+          rawError = coerceError(rawError);
+          const error = locatedError(rawError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+          const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+          filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+          return handledError;
+        });
+      }
+    } catch (rawError) {
+      const coercedError = coerceError(rawError);
+      const error = locatedError(coercedError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+      completedItem = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+      filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+    }
+  } catch (error) {
+    asyncPayloadRecord.errors.push(error);
+    filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+    asyncPayloadRecord.addItems(null);
+    return asyncPayloadRecord;
+  }
+  let completedItems;
+  if (isPromise(completedItem)) {
+    completedItems = completedItem.then((value) => [value], (error) => {
+      asyncPayloadRecord.errors.push(error);
+      filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+      return null;
+    });
+  } else {
+    completedItems = [completedItem];
+  }
+  asyncPayloadRecord.addItems(completedItems);
+  return asyncPayloadRecord;
+}
+async function executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath) {
+  let item;
+  try {
+    const { value, done } = await iterator.next();
+    if (done) {
+      asyncPayloadRecord.setIsCompletedIterator();
+      return { done, value: void 0 };
+    }
+    item = value;
+  } catch (rawError) {
+    const coercedError = coerceError(rawError);
+    const error = locatedError(coercedError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+    const value = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+    return { done: true, value };
+  }
+  let completedItem;
+  try {
+    completedItem = completeValue(exeContext, itemType, fieldNodes, info, itemPath, item, asyncPayloadRecord);
+    if (isPromise(completedItem)) {
+      completedItem = completedItem.then(void 0, (rawError) => {
+        const error = locatedError(rawError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+        const handledError = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+        filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+        return handledError;
+      });
+    }
+    return { done: false, value: completedItem };
+  } catch (rawError) {
+    const error = locatedError(rawError, fieldNodes, pathToArray(itemPath), exeContext.schemaCoordinateInErrors && info);
+    const value = handleFieldError(error, itemType, asyncPayloadRecord.errors);
+    filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
+    return { done: false, value };
+  }
+}
+async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNodes, info, itemType, path, label, parentContext) {
+  let index = initialIndex;
+  let previousAsyncPayloadRecord = parentContext ?? void 0;
+  while (true) {
+    const itemPath = addPath(path, index, void 0);
+    const asyncPayloadRecord = new StreamRecord({
+      label,
+      path: itemPath,
+      parentContext: previousAsyncPayloadRecord,
+      iterator,
+      exeContext
+    });
+    let iteration;
+    try {
+      iteration = await executeStreamIteratorItem(iterator, exeContext, fieldNodes, info, itemType, asyncPayloadRecord, itemPath);
+    } catch (error) {
+      asyncPayloadRecord.errors.push(error);
+      filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+      asyncPayloadRecord.addItems(null);
+      if (iterator?.return) {
+        iterator.return().catch(() => {
+        });
+      }
+      return;
+    }
+    const { done, value: completedItem } = iteration;
+    let completedItems;
+    if (isPromise(completedItem)) {
+      completedItems = completedItem.then((value) => [value], (error) => {
+        asyncPayloadRecord.errors.push(error);
+        filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
+        return null;
+      });
+    } else {
+      completedItems = [completedItem];
+    }
+    asyncPayloadRecord.addItems(completedItems);
+    if (done) {
+      break;
+    }
+    previousAsyncPayloadRecord = asyncPayloadRecord;
+    index++;
+  }
+}
+function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
+  const nullPathArray = pathToArray(nullPath);
+  exeContext.subsequentPayloads.forEach((asyncRecord) => {
+    if (asyncRecord === currentAsyncRecord) {
+      return;
+    }
+    for (let i = 0; i < nullPathArray.length; i++) {
+      if (asyncRecord.path[i] !== nullPathArray[i]) {
+        return;
+      }
+    }
+    if (isStreamPayload(asyncRecord) && asyncRecord.iterator?.return) {
+      asyncRecord.iterator.return().catch(() => {
+      });
+    }
+    exeContext.subsequentPayloads.delete(asyncRecord);
+  });
+}
+function getCompletedIncrementalResults(exeContext) {
+  const incrementalResults = [];
+  for (const asyncPayloadRecord of exeContext.subsequentPayloads) {
+    const incrementalResult = {};
+    if (!asyncPayloadRecord.isCompleted) {
+      continue;
+    }
+    exeContext.subsequentPayloads.delete(asyncPayloadRecord);
+    if (isStreamPayload(asyncPayloadRecord)) {
+      const items = asyncPayloadRecord.items;
+      if (asyncPayloadRecord.isCompletedIterator) {
+        continue;
+      }
+      incrementalResult.items = items;
+    } else {
+      const data = asyncPayloadRecord.data;
+      incrementalResult.data = data ?? null;
+    }
+    incrementalResult.path = asyncPayloadRecord.path;
+    if (asyncPayloadRecord.label) {
+      incrementalResult.label = asyncPayloadRecord.label;
+    }
+    if (asyncPayloadRecord.errors.length > 0) {
+      incrementalResult.errors = asyncPayloadRecord.errors;
+    }
+    incrementalResults.push(incrementalResult);
+  }
+  return incrementalResults;
+}
+function yieldSubsequentPayloads(exeContext) {
+  let isDone = false;
+  async function next() {
+    if (isDone) {
+      return { value: void 0, done: true };
+    }
+    const subSequentPayloadPromises = Array.from(exeContext.subsequentPayloads).map((record) => record.promise);
+    if (exeContext.signalPromise) {
+      await Promise.race([exeContext.signalPromise, ...subSequentPayloadPromises]);
+    } else {
+      await Promise.race(subSequentPayloadPromises);
+    }
+    if (isDone) {
+      return { value: void 0, done: true };
+    }
+    const incremental = getCompletedIncrementalResults(exeContext);
+    const hasNext = exeContext.subsequentPayloads.size > 0;
+    if (!incremental.length && hasNext) {
+      return next();
+    }
+    if (!hasNext) {
+      isDone = true;
+    }
+    return {
+      value: incremental.length ? { incremental, hasNext } : { hasNext },
+      done: false
+    };
+  }
+  function returnStreamIterators() {
+    const promises = [];
+    exeContext.subsequentPayloads.forEach((asyncPayloadRecord) => {
+      if (isStreamPayload(asyncPayloadRecord) && asyncPayloadRecord.iterator?.return) {
+        promises.push(asyncPayloadRecord.iterator.return());
+      }
+    });
+    return Promise.all(promises);
+  }
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next,
+    async return() {
+      await returnStreamIterators();
+      isDone = true;
+      return { value: void 0, done: true };
+    },
+    async throw(error) {
+      await returnStreamIterators();
+      isDone = true;
+      throw error;
+    },
+    async [DisposableSymbols.asyncDispose]() {
+      await returnStreamIterators();
+      isDone = true;
+    }
+  };
+}
+class DeferredFragmentRecord {
+  type;
+  errors;
+  label;
+  path;
+  promise;
+  data;
+  parentContext;
+  isCompleted;
+  _exeContext;
+  _resolve;
+  constructor(opts) {
+    this.type = "defer";
+    this.label = opts.label;
+    this.path = pathToArray(opts.path);
+    this.parentContext = opts.parentContext;
+    this.errors = [];
+    this._exeContext = opts.exeContext;
+    this._exeContext.subsequentPayloads.add(this);
+    this.isCompleted = false;
+    this.data = null;
+    this.promise = new Promise((resolve) => {
+      this._resolve = (MaybePromise) => {
+        resolve(MaybePromise);
+      };
+    }).then((data) => {
+      this.data = data;
+      this.isCompleted = true;
+    });
+  }
+  addData(data) {
+    const parentData = this.parentContext?.promise;
+    if (parentData) {
+      this._resolve?.(parentData.then(() => data));
+      return;
+    }
+    this._resolve?.(data);
+  }
+}
+class StreamRecord {
+  type;
+  errors;
+  label;
+  path;
+  items;
+  promise;
+  parentContext;
+  iterator;
+  isCompletedIterator;
+  isCompleted;
+  _exeContext;
+  _resolve;
+  constructor(opts) {
+    this.type = "stream";
+    this.items = null;
+    this.label = opts.label;
+    this.path = pathToArray(opts.path);
+    this.parentContext = opts.parentContext;
+    this.iterator = opts.iterator;
+    this.errors = [];
+    this._exeContext = opts.exeContext;
+    this._exeContext.subsequentPayloads.add(this);
+    this.isCompleted = false;
+    this.items = null;
+    this.promise = new Promise((resolve) => {
+      this._resolve = (MaybePromise) => {
+        resolve(MaybePromise);
+      };
+    }).then((items) => {
+      this.items = items;
+      this.isCompleted = true;
+    });
+  }
+  addItems(items) {
+    const parentData = this.parentContext?.promise;
+    if (parentData) {
+      this._resolve?.(parentData.then(() => items));
+      return;
+    }
+    this._resolve?.(items);
+  }
+  setIsCompletedIterator() {
+    this.isCompletedIterator = true;
+  }
+}
+function isStreamPayload(asyncPayload) {
+  return asyncPayload.type === "stream";
+}
+function getFieldDef(schema, parentType, fieldNode) {
+  const fieldName = fieldNode.name.value;
+  if (fieldName === SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return SchemaMetaFieldDef;
+  } else if (fieldName === TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return TypeMetaFieldDef;
+  } else if (fieldName === TypeNameMetaFieldDef.name) {
+    return TypeNameMetaFieldDef;
+  }
+  return parentType.getFields()[fieldName];
+}
+export {
+  CRITICAL_ERROR,
+  buildExecutionContext,
+  buildResolveInfo,
+  defaultFieldResolver,
+  defaultTypeResolver,
+  execute,
+  flattenIncrementalResults,
+  getFieldDef,
+  getFragmentsFromDocument,
+  isIncrementalResults,
+  subscribe
+};
+//# sourceMappingURL=execute.js.map