@pome-sh/cli 0.2.0 → 0.4.0

package/node_modules/graphql/execution/values.js

@@ -0,0 +1,444 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.getArgumentValues = getArgumentValues;
+exports.getDirectiveValues = getDirectiveValues;
+exports.getVariableValues = getVariableValues;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _keyMap = require('../jsutils/keyMap.js');
+
+var _printPathArray = require('../jsutils/printPathArray.js');
+
+var _GraphQLError = require('../error/GraphQLError.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _printer = require('../language/printer.js');
+
+var _definition = require('../type/definition.js');
+
+var _coerceInputValue = require('../utilities/coerceInputValue.js');
+
+var _typeFromAST = require('../utilities/typeFromAST.js');
+
+var _valueFromAST = require('../utilities/valueFromAST.js');
+
+/** @category Values */
+
+/**
+ * Prepares an object map of variableValues of the correct type based on the
+ * provided variable definitions and arbitrary input. If the input cannot be
+ * parsed to match the variable definitions, GraphQLError values are returned.
+ *
+ * Note: Returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ * @param schema - GraphQL schema to use.
+ * @param varDefNodes - The variable definition AST nodes to coerce.
+ * @param inputs - The runtime variable values keyed by variable name.
+ * @param options - Optional variable coercion options, including error limits.
+ * @returns Coerced variable values, or request errors.
+ * @example
+ * ```ts
+ * // Coerce provided variables and apply operation defaults.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($stars: Int!, $limit: Int = 10) {
+ *     reviews(stars: $stars, limit: $limit)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { stars: '5' },
+ * );
+ *
+ * result; // => { coerced: { stars: 5, limit: 10 } }
+ * ```
+ * @example
+ * ```ts
+ * // This variant uses maxErrors to cap reported coercion errors.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getVariableValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   input ReviewInput {
+ *     stars: Int!
+ *   }
+ *
+ *   type Query {
+ *     review(input: ReviewInput!): String
+ *   }
+ * `);
+ * const document = parse(`
+ *   query ($first: ReviewInput!, $second: ReviewInput!) {
+ *     first: review(input: $first)
+ *     second: review(input: $second)
+ *   }
+ * `);
+ * const operation = document.definitions[0];
+ *
+ * const result = getVariableValues(
+ *   schema,
+ *   operation.variableDefinitions,
+ *   { first: { stars: 'bad' }, second: { stars: 'also bad' } },
+ *   { maxErrors: 1 },
+ * );
+ *
+ * result.errors.length; // => 2
+ * result.errors[1].message; // matches /error limit reached/
+ * ```
+ */
+function getVariableValues(schema, varDefNodes, inputs, options) {
+  const errors = [];
+  const maxErrors =
+    options === null || options === void 0 ? void 0 : options.maxErrors;
+
+  try {
+    const coerced = coerceVariableValues(
+      schema,
+      varDefNodes,
+      inputs,
+      (error) => {
+        if (maxErrors != null && errors.length >= maxErrors) {
+          throw new _GraphQLError.GraphQLError(
+            'Too many errors processing variables, error limit reached. Execution aborted.',
+          );
+        }
+
+        errors.push(error);
+      },
+    );
+
+    if (errors.length === 0) {
+      return {
+        coerced,
+      };
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+
+  return {
+    errors,
+  };
+}
+
+function coerceVariableValues(schema, varDefNodes, inputs, onError) {
+  const coercedValues = Object.create(null);
+
+  for (const varDefNode of varDefNodes) {
+    const varName = varDefNode.variable.name.value;
+    const varType = (0, _typeFromAST.typeFromAST)(schema, varDefNode.type);
+
+    if (!(0, _definition.isInputType)(varType)) {
+      // Must use input types for variables. This should be caught during
+      // validation, however is checked again here for safety.
+      const varTypeStr = (0, _printer.print)(varDefNode.type);
+      onError(
+        new _GraphQLError.GraphQLError(
+          `Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`,
+          {
+            nodes: varDefNode.type,
+          },
+        ),
+      );
+      continue;
+    }
+
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
+        coercedValues[varName] = (0, _valueFromAST.valueFromAST)(
+          varDefNode.defaultValue,
+          varType,
+        );
+      } else if ((0, _definition.isNonNullType)(varType)) {
+        const varTypeStr = (0, _inspect.inspect)(varType);
+        onError(
+          new _GraphQLError.GraphQLError(
+            `Variable "$${varName}" of required type "${varTypeStr}" was not provided.`,
+            {
+              nodes: varDefNode,
+            },
+          ),
+        );
+      }
+
+      continue;
+    }
+
+    const value = inputs[varName];
+
+    if (value === null && (0, _definition.isNonNullType)(varType)) {
+      const varTypeStr = (0, _inspect.inspect)(varType);
+      onError(
+        new _GraphQLError.GraphQLError(
+          `Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`,
+          {
+            nodes: varDefNode,
+          },
+        ),
+      );
+      continue;
+    }
+
+    coercedValues[varName] = (0, _coerceInputValue.coerceInputValue)(
+      value,
+      varType,
+      (path, invalidValue, error) => {
+        let prefix =
+          `Variable "$${varName}" got invalid value ` +
+          (0, _inspect.inspect)(invalidValue);
+
+        if (path.length > 0) {
+          prefix += ` at "${varName}${(0, _printPathArray.printPathArray)(
+            path,
+          )}"`;
+        }
+
+        onError(
+          new _GraphQLError.GraphQLError(prefix + '; ' + error.message, {
+            nodes: varDefNode,
+            originalError: error,
+          }),
+        );
+      },
+    );
+  }
+
+  return { ...coercedValues };
+}
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: Returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ * @param def - The field or directive definition whose arguments should be coerced.
+ * @param node - The AST node to inspect.
+ * @param variableValues - The runtime variable values keyed by variable name.
+ * @returns Coerced argument values keyed by argument name.
+ * @example
+ * ```ts
+ * // Read literal argument values and defaults.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!, limit: Int = 10): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('{ reviews(stars: 5) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getArgumentValues(fieldDef, fieldNode); // => { stars: 5, limit: 10 }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves argument values from operation variables.
+ * import { parse } from 'graphql/language';
+ * import { buildSchema } from 'graphql/utilities';
+ * import { getArgumentValues } from 'graphql/execution';
+ *
+ * const schema = buildSchema(`
+ *   type Query {
+ *     reviews(stars: Int!): [String]
+ *   }
+ * `);
+ * const fieldDef = schema.getQueryType().getFields().reviews;
+ * const document = parse('query ($stars: Int!) { reviews(stars: $stars) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getArgumentValues(fieldDef, fieldNode, { stars: 5 }); // => { stars: 5 }
+ * getArgumentValues(fieldDef, fieldNode, {}); // throws an error
+ * ```
+ */
+
+function getArgumentValues(def, node, variableValues) {
+  var _node$arguments;
+
+  const coercedValues = Object.create(null); // FIXME: https://github.com/graphql/graphql-js/issues/2203
+
+  /* c8 ignore next */
+
+  const argumentNodes =
+    (_node$arguments = node.arguments) !== null && _node$arguments !== void 0
+      ? _node$arguments
+      : [];
+  const argNodeMap = (0, _keyMap.keyMap)(
+    argumentNodes,
+    (arg) => arg.name.value,
+  );
+
+  for (const argDef of def.args) {
+    const name = argDef.name;
+    const argType = argDef.type;
+    const argumentNode = argNodeMap[name];
+
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if ((0, _definition.isNonNullType)(argType)) {
+        throw new _GraphQLError.GraphQLError(
+          `Argument "${name}" of required type "${(0, _inspect.inspect)(
+            argType,
+          )}" ` + 'was not provided.',
+          {
+            nodes: node,
+          },
+        );
+      }
+
+      continue;
+    }
+
+    const valueNode = argumentNode.value;
+    let isNull = valueNode.kind === _kinds.Kind.NULL;
+
+    if (valueNode.kind === _kinds.Kind.VARIABLE) {
+      const variableName = valueNode.name.value;
+
+      if (
+        variableValues == null ||
+        !hasOwnProperty(variableValues, variableName)
+      ) {
+        if (argDef.defaultValue !== undefined) {
+          coercedValues[name] = argDef.defaultValue;
+        } else if ((0, _definition.isNonNullType)(argType)) {
+          throw new _GraphQLError.GraphQLError(
+            `Argument "${name}" of required type "${(0, _inspect.inspect)(
+              argType,
+            )}" ` +
+              `was provided the variable "$${variableName}" which was not provided a runtime value.`,
+            {
+              nodes: valueNode,
+            },
+          );
+        }
+
+        continue;
+      }
+
+      isNull = variableValues[variableName] == null;
+    }
+
+    if (isNull && (0, _definition.isNonNullType)(argType)) {
+      throw new _GraphQLError.GraphQLError(
+        `Argument "${name}" of non-null type "${(0, _inspect.inspect)(
+          argType,
+        )}" ` + 'must not be null.',
+        {
+          nodes: valueNode,
+        },
+      );
+    }
+
+    const coercedValue = (0, _valueFromAST.valueFromAST)(
+      valueNode,
+      argType,
+      variableValues,
+    );
+
+    if (coercedValue === undefined) {
+      // Note: ValuesOfCorrectTypeRule validation should catch this before
+      // execution. This is a runtime check to ensure execution does not
+      // continue with an invalid argument value.
+      throw new _GraphQLError.GraphQLError(
+        `Argument "${name}" has invalid value ${(0, _printer.print)(
+          valueNode,
+        )}.`,
+        {
+          nodes: valueNode,
+        },
+      );
+    }
+
+    coercedValues[name] = coercedValue;
+  }
+
+  return { ...coercedValues };
+}
+/**
+ * AST node shape accepted by getDirectiveValues.
+ * @internal
+ */
+
+/**
+ * Prepares an object map of argument values given a directive definition
+ * and a AST node which may contain directives. Optionally also accepts a map
+ * of variable values.
+ *
+ * If the directive does not exist on the node, returns undefined.
+ *
+ * Note: Returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ * @param directiveDef - The directive definition whose arguments should be coerced.
+ * @param node - The AST node to inspect.
+ * @param variableValues - The runtime variable values keyed by variable name.
+ * @returns Coerced directive argument values keyed by argument name.
+ * @example
+ * ```ts
+ * // Read literal directive arguments from a node.
+ * import { parse } from 'graphql/language';
+ * import { GraphQLSkipDirective } from 'graphql/type';
+ * import { getDirectiveValues } from 'graphql/execution';
+ *
+ * const document = parse('{ name @skip(if: true) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getDirectiveValues(GraphQLSkipDirective, fieldNode); // => { if: true }
+ * ```
+ * @example
+ * ```ts
+ * // This variant resolves directive arguments from variables and handles absent directives.
+ * import { parse } from 'graphql/language';
+ * import { GraphQLIncludeDirective } from 'graphql/type';
+ * import { getDirectiveValues } from 'graphql/execution';
+ *
+ * const document = parse('query ($includeName: Boolean!) { name @include(if: $includeName) }');
+ * const fieldNode = document.definitions[0].selectionSet.selections[0];
+ *
+ * getDirectiveValues(GraphQLIncludeDirective, fieldNode, {
+ *   includeName: false,
+ * }); // => { if: false }
+ * getDirectiveValues(GraphQLIncludeDirective, { directives: [] }); // => undefined
+ * ```
+ */
+function getDirectiveValues(directiveDef, node, variableValues) {
+  var _node$directives;
+
+  const directiveNode =
+    (_node$directives = node.directives) === null || _node$directives === void 0
+      ? void 0
+      : _node$directives.find(
+          (directive) => directive.name.value === directiveDef.name,
+        );
+
+  if (directiveNode) {
+    return getArgumentValues(directiveDef, directiveNode, variableValues);
+  }
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}