@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/graphql/execution/execute.js

@@ -0,0 +1,606 @@
+import { devAssert } from "../jsutils/devAssert.js";
+import { inspect } from "../jsutils/inspect.js";
+import { invariant } from "../jsutils/invariant.js";
+import { isIterableObject } from "../jsutils/isIterableObject.js";
+import { isObjectLike } from "../jsutils/isObjectLike.js";
+import { isPromise } from "../jsutils/isPromise.js";
+import { memoize3 } from "../jsutils/memoize3.js";
+import { addPath, pathToArray } from "../jsutils/Path.js";
+import { promiseForObject } from "../jsutils/promiseForObject.js";
+import { promiseReduce } from "../jsutils/promiseReduce.js";
+import { GraphQLError } from "../error/GraphQLError.js";
+import { locatedError } from "../error/locatedError.js";
+import { OperationTypeNode } from "../language/ast.js";
+import { Kind } from "../language/kinds.js";
+import { isNonNullType, isListType, isLeafType, isAbstractType, isObjectType } from "../type/definition.js";
+import { SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef } from "../type/introspection.js";
+import { assertValidSchema } from "../type/validate.js";
+import { collectFields, collectSubfields as collectSubfields$1 } from "./collectFields.js";
+import { getVariableValues, getArgumentValues } from "./values.js";
+const collectSubfields = memoize3(
+  (exeContext, returnType, fieldNodes) => collectSubfields$1(
+    exeContext.schema,
+    exeContext.fragments,
+    exeContext.variableValues,
+    returnType,
+    fieldNodes
+  )
+);
+function execute(args) {
+  arguments.length < 2 || devAssert(
+    false,
+    "graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead."
+  );
+  const { schema, document, variableValues, rootValue } = args;
+  assertValidExecutionArguments(schema, document, variableValues);
+  const exeContext = buildExecutionContext(args);
+  if (!("schema" in exeContext)) {
+    return {
+      errors: exeContext
+    };
+  }
+  try {
+    const { operation } = exeContext;
+    const result = executeOperation(exeContext, operation, rootValue);
+    if (isPromise(result)) {
+      return result.then(
+        (data) => buildResponse(data, exeContext.errors),
+        (error) => {
+          exeContext.errors.push(error);
+          return buildResponse(null, exeContext.errors);
+        }
+      );
+    }
+    return buildResponse(result, exeContext.errors);
+  } catch (error) {
+    exeContext.errors.push(error);
+    return buildResponse(null, exeContext.errors);
+  }
+}
+function buildResponse(data, errors) {
+  return errors.length === 0 ? {
+    data
+  } : {
+    errors,
+    data
+  };
+}
+function assertValidExecutionArguments(schema, document, rawVariableValues) {
+  document || devAssert(false, "Must provide document.");
+  assertValidSchema(schema);
+  rawVariableValues == null || isObjectLike(rawVariableValues) || devAssert(
+    false,
+    "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."
+  );
+}
+function buildExecutionContext(args) {
+  var _definition$name, _operation$variableDe, _options$maxCoercionE;
+  const {
+    schema,
+    document,
+    rootValue,
+    contextValue,
+    variableValues: rawVariableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    subscribeFieldResolver,
+    options
+  } = args;
+  let operation;
+  const fragments = /* @__PURE__ */ Object.create(null);
+  for (const definition of document.definitions) {
+    switch (definition.kind) {
+      case Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== void 0) {
+            return [
+              new GraphQLError(
+                "Must provide operation name if query contains multiple operations."
+              )
+            ];
+          }
+          operation = definition;
+        } else if (((_definition$name = definition.name) === null || _definition$name === void 0 ? void 0 : _definition$name.value) === operationName) {
+          operation = definition;
+        }
+        break;
+      case Kind.FRAGMENT_DEFINITION:
+        fragments[definition.name.value] = definition;
+        break;
+    }
+  }
+  if (!operation) {
+    if (operationName != null) {
+      return [new GraphQLError(`Unknown operation named "${operationName}".`)];
+    }
+    return [new GraphQLError("Must provide an operation.")];
+  }
+  const variableDefinitions = (_operation$variableDe = operation.variableDefinitions) !== null && _operation$variableDe !== void 0 ? _operation$variableDe : [];
+  const coercedVariableValues = getVariableValues(
+    schema,
+    variableDefinitions,
+    rawVariableValues !== null && rawVariableValues !== void 0 ? rawVariableValues : {},
+    {
+      maxErrors: (_options$maxCoercionE = options === null || options === void 0 ? void 0 : options.maxCoercionErrors) !== null && _options$maxCoercionE !== void 0 ? _options$maxCoercionE : 50
+    }
+  );
+  if (coercedVariableValues.errors) {
+    return coercedVariableValues.errors;
+  }
+  return {
+    schema,
+    fragments,
+    rootValue,
+    contextValue,
+    operation,
+    variableValues: coercedVariableValues.coerced,
+    fieldResolver: fieldResolver !== null && fieldResolver !== void 0 ? fieldResolver : defaultFieldResolver,
+    typeResolver: typeResolver !== null && typeResolver !== void 0 ? typeResolver : defaultTypeResolver,
+    subscribeFieldResolver: subscribeFieldResolver !== null && subscribeFieldResolver !== void 0 ? subscribeFieldResolver : defaultFieldResolver,
+    errors: []
+  };
+}
+function executeOperation(exeContext, operation, rootValue) {
+  const rootType = exeContext.schema.getRootType(operation.operation);
+  if (rootType == null) {
+    throw new GraphQLError(
+      `Schema is not configured to execute ${operation.operation} operation.`,
+      {
+        nodes: operation
+      }
+    );
+  }
+  const rootFields = collectFields(
+    exeContext.schema,
+    exeContext.fragments,
+    exeContext.variableValues,
+    rootType,
+    operation.selectionSet
+  );
+  const path = void 0;
+  switch (operation.operation) {
+    case OperationTypeNode.QUERY:
+      return executeFields(exeContext, rootType, rootValue, path, rootFields);
+    case OperationTypeNode.MUTATION:
+      return executeFieldsSerially(
+        exeContext,
+        rootType,
+        rootValue,
+        path,
+        rootFields
+      );
+    case OperationTypeNode.SUBSCRIPTION:
+      return executeFields(exeContext, rootType, rootValue, path, rootFields);
+  }
+}
+function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+  return promiseReduce(
+    fields.entries(),
+    (results, [responseName, fieldNodes]) => {
+      const fieldPath = addPath(path, responseName, parentType.name);
+      const result = executeField(
+        exeContext,
+        parentType,
+        sourceValue,
+        fieldNodes,
+        fieldPath
+      );
+      if (result === void 0) {
+        return results;
+      }
+      if (isPromise(result)) {
+        return result.then((resolvedResult) => {
+          results[responseName] = resolvedResult;
+          return results;
+        });
+      }
+      results[responseName] = result;
+      return results;
+    },
+    /* @__PURE__ */ Object.create(null)
+  );
+}
+function executeFields(exeContext, parentType, sourceValue, path, fields) {
+  const results = /* @__PURE__ */ Object.create(null);
+  let containsPromise = false;
+  try {
+    for (const [responseName, fieldNodes] of fields.entries()) {
+      const fieldPath = addPath(path, responseName, parentType.name);
+      const result = executeField(
+        exeContext,
+        parentType,
+        sourceValue,
+        fieldNodes,
+        fieldPath
+      );
+      if (result !== void 0) {
+        results[responseName] = result;
+        if (isPromise(result)) {
+          containsPromise = true;
+        }
+      }
+    }
+  } catch (error) {
+    if (containsPromise) {
+      return promiseForObject(results).finally(() => {
+        throw error;
+      });
+    }
+    throw error;
+  }
+  if (!containsPromise) {
+    return results;
+  }
+  return promiseForObject(results);
+}
+function executeField(exeContext, parentType, source, fieldNodes, path) {
+  var _fieldDef$resolve;
+  const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
+  if (!fieldDef) {
+    return;
+  }
+  const returnType = fieldDef.type;
+  const resolveFn = (_fieldDef$resolve = fieldDef.resolve) !== null && _fieldDef$resolve !== void 0 ? _fieldDef$resolve : exeContext.fieldResolver;
+  const info = buildResolveInfo(
+    exeContext,
+    fieldDef,
+    fieldNodes,
+    parentType,
+    path
+  );
+  try {
+    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)
+      );
+    } else {
+      completed = completeValue(
+        exeContext,
+        returnType,
+        fieldNodes,
+        info,
+        path,
+        result
+      );
+    }
+    if (isPromise(completed)) {
+      return completed.then(void 0, (rawError) => {
+        const error = locatedError(rawError, fieldNodes, pathToArray(path));
+        return handleFieldError(error, returnType, exeContext);
+      });
+    }
+    return completed;
+  } catch (rawError) {
+    const error = locatedError(rawError, fieldNodes, pathToArray(path));
+    return handleFieldError(error, returnType, exeContext);
+  }
+}
+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
+  };
+}
+function handleFieldError(error, returnType, exeContext) {
+  if (isNonNullType(returnType)) {
+    throw error;
+  }
+  exeContext.errors.push(error);
+  return null;
+}
+function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (isNonNullType(returnType)) {
+    const completed = completeValue(
+      exeContext,
+      returnType.ofType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+    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
+    );
+  }
+  if (isLeafType(returnType)) {
+    return completeLeafValue(returnType, result);
+  }
+  if (isAbstractType(returnType)) {
+    return completeAbstractValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  if (isObjectType(returnType)) {
+    return completeObjectValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  invariant(
+    false,
+    "Cannot complete value of unexpected output type: " + inspect(returnType)
+  );
+}
+function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
+  if (!isIterableObject(result)) {
+    throw new GraphQLError(
+      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`
+    );
+  }
+  const itemType = returnType.ofType;
+  let containsPromise = false;
+  const completedResults = Array.from(result, (item, index) => {
+    const itemPath = addPath(path, index, void 0);
+    try {
+      let completedItem;
+      if (isPromise(item)) {
+        completedItem = item.then(
+          (resolved) => completeValue(
+            exeContext,
+            itemType,
+            fieldNodes,
+            info,
+            itemPath,
+            resolved
+          )
+        );
+      } else {
+        completedItem = completeValue(
+          exeContext,
+          itemType,
+          fieldNodes,
+          info,
+          itemPath,
+          item
+        );
+      }
+      if (isPromise(completedItem)) {
+        containsPromise = true;
+        return completedItem.then(void 0, (rawError) => {
+          const error = locatedError(
+            rawError,
+            fieldNodes,
+            pathToArray(itemPath)
+          );
+          return handleFieldError(error, itemType, exeContext);
+        });
+      }
+      return completedItem;
+    } catch (rawError) {
+      const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+      return handleFieldError(error, itemType, exeContext);
+    }
+  });
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeLeafValue(returnType, result) {
+  const serializedResult = returnType.serialize(result);
+  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) {
+  var _returnType$resolveTy;
+  const resolveTypeFn = (_returnType$resolveTy = returnType.resolveType) !== null && _returnType$resolveTy !== void 0 ? _returnType$resolveTy : 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
+      )
+    );
+  }
+  return completeObjectValue(
+    exeContext,
+    ensureValidRuntimeType(
+      runtimeType,
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      result
+    ),
+    fieldNodes,
+    info,
+    path,
+    result
+  );
+}
+function ensureValidRuntimeType(runtimeTypeName, exeContext, returnType, fieldNodes, info, result) {
+  if (runtimeTypeName == null) {
+    throw new GraphQLError(
+      `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.`,
+      fieldNodes
+    );
+  }
+  if (isObjectType(runtimeTypeName)) {
+    throw new GraphQLError(
+      "Support for returning GraphQLObjectType from resolveType was removed in graphql-js@16.0.0 please return type name instead."
+    );
+  }
+  if (typeof runtimeTypeName !== "string") {
+    throw new GraphQLError(
+      `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 new GraphQLError(
+      `Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+      {
+        nodes: fieldNodes
+      }
+    );
+  }
+  if (!isObjectType(runtimeType)) {
+    throw new GraphQLError(
+      `Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`,
+      {
+        nodes: fieldNodes
+      }
+    );
+  }
+  if (!exeContext.schema.isSubType(returnType, runtimeType)) {
+    throw new GraphQLError(
+      `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) {
+  const subFieldNodes = collectSubfields(exeContext, returnType, fieldNodes);
+  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 executeFields(
+          exeContext,
+          returnType,
+          result,
+          path,
+          subFieldNodes
+        );
+      });
+    }
+    if (!isTypeOf) {
+      throw invalidReturnTypeError(returnType, result, fieldNodes);
+    }
+  }
+  return executeFields(exeContext, returnType, result, path, subFieldNodes);
+}
+function invalidReturnTypeError(returnType, result, fieldNodes) {
+  return new GraphQLError(
+    `Expected value of type "${returnType.name}" but got: ${inspect(result)}.`,
+    {
+      nodes: fieldNodes
+    }
+  );
+}
+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) {
+        if (promisedIsTypeOfResults.length) {
+          Promise.allSettled(promisedIsTypeOfResults).catch(() => {
+          });
+        }
+        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 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 {
+  assertValidExecutionArguments,
+  buildExecutionContext,
+  buildResolveInfo,
+  defaultFieldResolver,
+  defaultTypeResolver,
+  execute,
+  getFieldDef
+};
+//# sourceMappingURL=execute.js.map