| 'use strict'; |
| |
| Object.defineProperty(exports, '__esModule', { |
| value: true, |
| }); |
| exports.valueFromAST = valueFromAST; |
| |
| var _inspect = require('../jsutils/inspect.js'); |
| |
| var _invariant = require('../jsutils/invariant.js'); |
| |
| var _keyMap = require('../jsutils/keyMap.js'); |
| |
| var _kinds = require('../language/kinds.js'); |
| |
| var _definition = require('../type/definition.js'); |
| |
| /** |
| * Produces a JavaScript value given a GraphQL Value AST. |
| * |
| * A GraphQL type must be provided, which will be used to interpret different |
| * GraphQL Value literals. |
| * |
| * Returns `undefined` when the value could not be validly coerced according to |
| * the provided type. |
| * |
| * | GraphQL Value | JSON Value | |
| * | -------------------- | ------------- | |
| * | Input Object | Object | |
| * | List | Array | |
| * | Boolean | Boolean | |
| * | String | String | |
| * | Int / Float | Number | |
| * | Enum Value | Unknown | |
| * | NullValue | null | |
| * |
| */ |
| function valueFromAST(valueNode, type, variables) { |
| if (!valueNode) { |
| // When there is no node, then there is also no value. |
| // Importantly, this is different from returning the value null. |
| return; |
| } |
| |
| if (valueNode.kind === _kinds.Kind.VARIABLE) { |
| const variableName = valueNode.name.value; |
| |
| if (variables == null || variables[variableName] === undefined) { |
| // No valid return value. |
| return; |
| } |
| |
| const variableValue = variables[variableName]; |
| |
| if (variableValue === null && (0, _definition.isNonNullType)(type)) { |
| return; // Invalid: intentionally return no value. |
| } // Note: This does no further checking that this variable is correct. |
| // This assumes that this query has been validated and the variable |
| // usage here is of the correct type. |
| |
| return variableValue; |
| } |
| |
| if ((0, _definition.isNonNullType)(type)) { |
| if (valueNode.kind === _kinds.Kind.NULL) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| return valueFromAST(valueNode, type.ofType, variables); |
| } |
| |
| if (valueNode.kind === _kinds.Kind.NULL) { |
| // This is explicitly returning the value null. |
| return null; |
| } |
| |
| if ((0, _definition.isListType)(type)) { |
| const itemType = type.ofType; |
| |
| if (valueNode.kind === _kinds.Kind.LIST) { |
| const coercedValues = []; |
| |
| for (const itemNode of valueNode.values) { |
| if (isMissingVariable(itemNode, variables)) { |
| // If an array contains a missing variable, it is either coerced to |
| // null or if the item type is non-null, it considered invalid. |
| if ((0, _definition.isNonNullType)(itemType)) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedValues.push(null); |
| } else { |
| const itemValue = valueFromAST(itemNode, itemType, variables); |
| |
| if (itemValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedValues.push(itemValue); |
| } |
| } |
| |
| return coercedValues; |
| } |
| |
| const coercedValue = valueFromAST(valueNode, itemType, variables); |
| |
| if (coercedValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| return [coercedValue]; |
| } |
| |
| if ((0, _definition.isInputObjectType)(type)) { |
| if (valueNode.kind !== _kinds.Kind.OBJECT) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| const coercedObj = Object.create(null); |
| const fieldNodes = (0, _keyMap.keyMap)( |
| valueNode.fields, |
| (field) => field.name.value, |
| ); |
| |
| for (const field of Object.values(type.getFields())) { |
| const fieldNode = fieldNodes[field.name]; |
| |
| if (!fieldNode || isMissingVariable(fieldNode.value, variables)) { |
| if (field.defaultValue !== undefined) { |
| coercedObj[field.name] = field.defaultValue; |
| } else if ((0, _definition.isNonNullType)(field.type)) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| continue; |
| } |
| |
| const fieldValue = valueFromAST(fieldNode.value, field.type, variables); |
| |
| if (fieldValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedObj[field.name] = fieldValue; |
| } |
| |
| return coercedObj; |
| } |
| |
| if ((0, _definition.isLeafType)(type)) { |
| // Scalars and Enums fulfill parsing a literal value via parseLiteral(). |
| // Invalid values represent a failure to parse correctly, in which case |
| // no value is returned. |
| let result; |
| |
| try { |
| result = type.parseLiteral(valueNode, variables); |
| } catch (_error) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| if (result === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| return result; |
| } |
| /* c8 ignore next 3 */ |
| // Not reachable, all possible input types have been considered. |
| |
| false || |
| (0, _invariant.invariant)( |
| false, |
| 'Unexpected input type: ' + (0, _inspect.inspect)(type), |
| ); |
| } // Returns true if the provided valueNode is a variable which is not defined |
| // in the set of variables. |
| |
| function isMissingVariable(valueNode, variables) { |
| return ( |
| valueNode.kind === _kinds.Kind.VARIABLE && |
| (variables == null || variables[valueNode.name.value] === undefined) |
| ); |
| } |