1 files changed, 228 insertions, 0 deletions
diff --git a/alarm/node_modules/graphql/execution/values.js b/alarm/node_modules/graphql/execution/values.js
new file mode 100644
index 0000000..ac4bba9
--- /dev/null
+++ b/alarm/node_modules/graphql/execution/values.js
@@ -0,0 +1,228 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVariableValues = getVariableValues;
+exports.getArgumentValues = getArgumentValues;
+exports.getDirectiveValues = getDirectiveValues;
+
+var _find = _interopRequireDefault(require("../polyfills/find.js"));
+
+var _keyMap = _interopRequireDefault(require("../jsutils/keyMap.js"));
+
+var _inspect = _interopRequireDefault(require("../jsutils/inspect.js"));
+
+var _printPathArray = _interopRequireDefault(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 _typeFromAST = require("../utilities/typeFromAST.js");
+
+var _valueFromAST = require("../utilities/valueFromAST.js");
+
+var _coerceInputValue = require("../utilities/coerceInputValue.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * 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, a GraphQLError will be thrown.
+ *
+ * Note: The 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.
+ *
+ * @internal
+ */
+function getVariableValues(schema, varDefNodes, inputs, options) {
+  var errors = [];
+  var maxErrors = options === null || options === void 0 ? void 0 : options.maxErrors;
+
+  try {
+    var coerced = coerceVariableValues(schema, varDefNodes, inputs, function (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: coerced
+      };
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+
+  return {
+    errors: errors
+  };
+}
+
+function coerceVariableValues(schema, varDefNodes, inputs, onError) {
+  var coercedValues = {};
+
+  var _loop = function _loop(_i2) {
+    var varDefNode = varDefNodes[_i2];
+    var varName = varDefNode.variable.name.value;
+    var 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.
+      var varTypeStr = (0, _printer.print)(varDefNode.type);
+      onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" expected value of type \"").concat(varTypeStr, "\" which cannot be used as an input type."), varDefNode.type));
+      return "continue";
+    }
+
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
+        coercedValues[varName] = (0, _valueFromAST.valueFromAST)(varDefNode.defaultValue, varType);
+      } else if ((0, _definition.isNonNullType)(varType)) {
+        var _varTypeStr = (0, _inspect.default)(varType);
+
+        onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" of required type \"").concat(_varTypeStr, "\" was not provided."), varDefNode));
+      }
+
+      return "continue";
+    }
+
+    var value = inputs[varName];
+
+    if (value === null && (0, _definition.isNonNullType)(varType)) {
+      var _varTypeStr2 = (0, _inspect.default)(varType);
+
+      onError(new _GraphQLError.GraphQLError("Variable \"$".concat(varName, "\" of non-null type \"").concat(_varTypeStr2, "\" must not be null."), varDefNode));
+      return "continue";
+    }
+
+    coercedValues[varName] = (0, _coerceInputValue.coerceInputValue)(value, varType, function (path, invalidValue, error) {
+      var prefix = "Variable \"$".concat(varName, "\" got invalid value ") + (0, _inspect.default)(invalidValue);
+
+      if (path.length > 0) {
+        prefix += " at \"".concat(varName).concat((0, _printPathArray.default)(path), "\"");
+      }
+
+      onError(new _GraphQLError.GraphQLError(prefix + '; ' + error.message, varDefNode, undefined, undefined, undefined, error.originalError));
+    });
+  };
+
+  for (var _i2 = 0; _i2 < varDefNodes.length; _i2++) {
+    var _ret = _loop(_i2);
+
+    if (_ret === "continue") continue;
+  }
+
+  return coercedValues;
+}
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The 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.
+ *
+ * @internal
+ */
+
+
+function getArgumentValues(def, node, variableValues) {
+  var _node$arguments;
+
+  var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
+
+  var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
+  var argNodeMap = (0, _keyMap.default)(argumentNodes, function (arg) {
+    return arg.name.value;
+  });
+
+  for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
+    var argDef = _def$args2[_i4];
+    var name = argDef.name;
+    var argType = argDef.type;
+    var argumentNode = argNodeMap[name];
+
+    if (!argumentNode) {
+      if (argDef.defaultValue !== undefined) {
+        coercedValues[name] = argDef.defaultValue;
+      } else if ((0, _definition.isNonNullType)(argType)) {
+        throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of required type \"").concat((0, _inspect.default)(argType), "\" ") + 'was not provided.', node);
+      }
+
+      continue;
+    }
+
+    var valueNode = argumentNode.value;
+    var isNull = valueNode.kind === _kinds.Kind.NULL;
+
+    if (valueNode.kind === _kinds.Kind.VARIABLE) {
+      var 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 \"".concat(name, "\" of required type \"").concat((0, _inspect.default)(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
+        }
+
+        continue;
+      }
+
+      isNull = variableValues[variableName] == null;
+    }
+
+    if (isNull && (0, _definition.isNonNullType)(argType)) {
+      throw new _GraphQLError.GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat((0, _inspect.default)(argType), "\" ") + 'must not be null.', valueNode);
+    }
+
+    var 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 \"".concat(name, "\" has invalid value ").concat((0, _printer.print)(valueNode), "."), valueNode);
+    }
+
+    coercedValues[name] = coercedValue;
+  }
+
+  return coercedValues;
+}
+/**
+ * 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: The 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.
+ */
+
+
+function getDirectiveValues(directiveDef, node, variableValues) {
+  var directiveNode = node.directives && (0, _find.default)(node.directives, function (directive) {
+    return directive.name.value === directiveDef.name;
+  });
+
+  if (directiveNode) {
+    return getArgumentValues(directiveDef, directiveNode, variableValues);
+  }
+}
+
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}