@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/execution/execute.cjs

@@ -0,0 +1,600 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const devAssert = require("../jsutils/devAssert.cjs");
+const inspect = require("../jsutils/inspect.cjs");
+const invariant = require("../jsutils/invariant.cjs");
+const isIterableObject = require("../jsutils/isIterableObject.cjs");
+const isObjectLike = require("../jsutils/isObjectLike.cjs");
+const isPromise = require("../jsutils/isPromise.cjs");
+const memoize3 = require("../jsutils/memoize3.cjs");
+const Path = require("../jsutils/Path.cjs");
+const promiseForObject = require("../jsutils/promiseForObject.cjs");
+const promiseReduce = require("../jsutils/promiseReduce.cjs");
+const GraphQLError = require("../error/GraphQLError.cjs");
+const locatedError = require("../error/locatedError.cjs");
+const ast = require("../language/ast.cjs");
+const kinds = require("../language/kinds.cjs");
+const definition = require("../type/definition.cjs");
+const introspection = require("../type/introspection.cjs");
+const validate = require("../type/validate.cjs");
+const collectFields = require("./collectFields.cjs");
+const values = require("./values.cjs");
+const collectSubfields = memoize3.memoize3(
+  (exeContext, returnType, fieldNodes) => collectFields.collectSubfields(
+    exeContext.schema,
+    exeContext.fragments,
+    exeContext.variableValues,
+    returnType,
+    fieldNodes
+  )
+);
+function execute(args) {
+  arguments.length < 2 || devAssert.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.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 executeSync(args) {
+  const result = execute(args);
+  if (isPromise.isPromise(result)) {
+    throw new Error("GraphQL execution failed to complete synchronously.");
+  }
+  return result;
+}
+function buildResponse(data, errors) {
+  return errors.length === 0 ? {
+    data
+  } : {
+    errors,
+    data
+  };
+}
+function assertValidExecutionArguments(schema, document, rawVariableValues) {
+  document || devAssert.devAssert(false, "Must provide document.");
+  validate.assertValidSchema(schema);
+  rawVariableValues == null || isObjectLike.isObjectLike(rawVariableValues) || devAssert.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;
+  const {
+    schema,
+    document,
+    rootValue,
+    contextValue,
+    variableValues: rawVariableValues,
+    operationName,
+    fieldResolver,
+    typeResolver,
+    subscribeFieldResolver
+  } = args;
+  let operation;
+  const fragments = /* @__PURE__ */ Object.create(null);
+  for (const definition2 of document.definitions) {
+    switch (definition2.kind) {
+      case kinds.Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== void 0) {
+            return [
+              new GraphQLError.GraphQLError(
+                "Must provide operation name if query contains multiple operations."
+              )
+            ];
+          }
+          operation = definition2;
+        } else if (((_definition$name = definition2.name) === null || _definition$name === void 0 ? void 0 : _definition$name.value) === operationName) {
+          operation = definition2;
+        }
+        break;
+      case kinds.Kind.FRAGMENT_DEFINITION:
+        fragments[definition2.name.value] = definition2;
+        break;
+    }
+  }
+  if (!operation) {
+    if (operationName != null) {
+      return [new GraphQLError.GraphQLError(`Unknown operation named "${operationName}".`)];
+    }
+    return [new GraphQLError.GraphQLError("Must provide an operation.")];
+  }
+  const variableDefinitions = (_operation$variableDe = operation.variableDefinitions) !== null && _operation$variableDe !== void 0 ? _operation$variableDe : [];
+  const coercedVariableValues = values.getVariableValues(
+    schema,
+    variableDefinitions,
+    rawVariableValues !== null && rawVariableValues !== void 0 ? rawVariableValues : {},
+    {
+      maxErrors: 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.GraphQLError(
+      `Schema is not configured to execute ${operation.operation} operation.`,
+      {
+        nodes: operation
+      }
+    );
+  }
+  const rootFields = collectFields.collectFields(
+    exeContext.schema,
+    exeContext.fragments,
+    exeContext.variableValues,
+    rootType,
+    operation.selectionSet
+  );
+  const path = void 0;
+  switch (operation.operation) {
+    case ast.OperationTypeNode.QUERY:
+      return executeFields(exeContext, rootType, rootValue, path, rootFields);
+    case ast.OperationTypeNode.MUTATION:
+      return executeFieldsSerially(
+        exeContext,
+        rootType,
+        rootValue,
+        path,
+        rootFields
+      );
+    case ast.OperationTypeNode.SUBSCRIPTION:
+      return executeFields(exeContext, rootType, rootValue, path, rootFields);
+  }
+}
+function executeFieldsSerially(exeContext, parentType, sourceValue, path, fields) {
+  return promiseReduce.promiseReduce(
+    fields.entries(),
+    (results, [responseName, fieldNodes]) => {
+      const fieldPath = Path.addPath(path, responseName, parentType.name);
+      const result = executeField(
+        exeContext,
+        parentType,
+        sourceValue,
+        fieldNodes,
+        fieldPath
+      );
+      if (result === void 0) {
+        return results;
+      }
+      if (isPromise.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;
+  for (const [responseName, fieldNodes] of fields.entries()) {
+    const fieldPath = Path.addPath(path, responseName, parentType.name);
+    const result = executeField(
+      exeContext,
+      parentType,
+      sourceValue,
+      fieldNodes,
+      fieldPath
+    );
+    if (result !== void 0) {
+      results[responseName] = result;
+      if (isPromise.isPromise(result)) {
+        containsPromise = true;
+      }
+    }
+  }
+  if (!containsPromise) {
+    return results;
+  }
+  return promiseForObject.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 = values.getArgumentValues(
+      fieldDef,
+      fieldNodes[0],
+      exeContext.variableValues
+    );
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(source, args, contextValue, info);
+    let completed;
+    if (isPromise.isPromise(result)) {
+      completed = result.then(
+        (resolved) => completeValue(exeContext, returnType, fieldNodes, info, path, resolved)
+      );
+    } else {
+      completed = completeValue(
+        exeContext,
+        returnType,
+        fieldNodes,
+        info,
+        path,
+        result
+      );
+    }
+    if (isPromise.isPromise(completed)) {
+      return completed.then(void 0, (rawError) => {
+        const error = locatedError.locatedError(rawError, fieldNodes, Path.pathToArray(path));
+        return handleFieldError(error, returnType, exeContext);
+      });
+    }
+    return completed;
+  } catch (rawError) {
+    const error = locatedError.locatedError(rawError, fieldNodes, Path.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 (definition.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 (definition.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 (definition.isListType(returnType)) {
+    return completeListValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  if (definition.isLeafType(returnType)) {
+    return completeLeafValue(returnType, result);
+  }
+  if (definition.isAbstractType(returnType)) {
+    return completeAbstractValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  if (definition.isObjectType(returnType)) {
+    return completeObjectValue(
+      exeContext,
+      returnType,
+      fieldNodes,
+      info,
+      path,
+      result
+    );
+  }
+  invariant.invariant(
+    false,
+    "Cannot complete value of unexpected output type: " + inspect.inspect(returnType)
+  );
+}
+function completeListValue(exeContext, returnType, fieldNodes, info, path, result) {
+  if (!isIterableObject.isIterableObject(result)) {
+    throw new GraphQLError.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 = Path.addPath(path, index, void 0);
+    try {
+      let completedItem;
+      if (isPromise.isPromise(item)) {
+        completedItem = item.then(
+          (resolved) => completeValue(
+            exeContext,
+            itemType,
+            fieldNodes,
+            info,
+            itemPath,
+            resolved
+          )
+        );
+      } else {
+        completedItem = completeValue(
+          exeContext,
+          itemType,
+          fieldNodes,
+          info,
+          itemPath,
+          item
+        );
+      }
+      if (isPromise.isPromise(completedItem)) {
+        containsPromise = true;
+        return completedItem.then(void 0, (rawError) => {
+          const error = locatedError.locatedError(
+            rawError,
+            fieldNodes,
+            Path.pathToArray(itemPath)
+          );
+          return handleFieldError(error, itemType, exeContext);
+        });
+      }
+      return completedItem;
+    } catch (rawError) {
+      const error = locatedError.locatedError(rawError, fieldNodes, Path.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.inspect(returnType)}.serialize(${inspect.inspect(result)})\` to return non-nullable value, returned: ${inspect.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.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.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 (definition.isObjectType(runtimeTypeName)) {
+    throw new GraphQLError.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.GraphQLError(
+      `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}" with value ${inspect.inspect(result)}, received "${inspect.inspect(runtimeTypeName)}".`
+    );
+  }
+  const runtimeType = exeContext.schema.getType(runtimeTypeName);
+  if (runtimeType == null) {
+    throw new GraphQLError.GraphQLError(
+      `Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+      {
+        nodes: fieldNodes
+      }
+    );
+  }
+  if (!definition.isObjectType(runtimeType)) {
+    throw new GraphQLError.GraphQLError(
+      `Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`,
+      {
+        nodes: fieldNodes
+      }
+    );
+  }
+  if (!exeContext.schema.isSubType(returnType, runtimeType)) {
+    throw new GraphQLError.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.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.GraphQLError(
+    `Expected value of type "${returnType.name}" but got: ${inspect.inspect(result)}.`,
+    {
+      nodes: fieldNodes
+    }
+  );
+}
+const defaultTypeResolver = function(value, contextValue, info, abstractType) {
+  if (isObjectLike.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.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.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 === introspection.SchemaMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return introspection.SchemaMetaFieldDef;
+  } else if (fieldName === introspection.TypeMetaFieldDef.name && schema.getQueryType() === parentType) {
+    return introspection.TypeMetaFieldDef;
+  } else if (fieldName === introspection.TypeNameMetaFieldDef.name) {
+    return introspection.TypeNameMetaFieldDef;
+  }
+  return parentType.getFields()[fieldName];
+}
+exports.assertValidExecutionArguments = assertValidExecutionArguments;
+exports.buildExecutionContext = buildExecutionContext;
+exports.buildResolveInfo = buildResolveInfo;
+exports.defaultFieldResolver = defaultFieldResolver;
+exports.defaultTypeResolver = defaultTypeResolver;
+exports.execute = execute;
+exports.executeSync = executeSync;
+exports.getFieldDef = getFieldDef;
+//# sourceMappingURL=execute.cjs.map