@slicemachine/manager 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

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

@@ -1,600 +0,0 @@
-"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