| import objectValues from "../polyfills/objectValues.mjs"; |
| import keyMap from "../jsutils/keyMap.mjs"; |
| import inspect from "../jsutils/inspect.mjs"; |
| import invariant from "../jsutils/invariant.mjs"; |
| import { Kind } from "../language/kinds.mjs"; |
| import { isLeafType, isInputObjectType, isListType, isNonNullType } from "../type/definition.mjs"; |
| /** |
| * 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 | Mixed | |
| * | NullValue | null | |
| * |
| */ |
| |
| export 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 === Kind.VARIABLE) { |
| var variableName = valueNode.name.value; |
| |
| if (variables == null || variables[variableName] === undefined) { |
| // No valid return value. |
| return; |
| } |
| |
| var variableValue = variables[variableName]; |
| |
| if (variableValue === null && 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 (isNonNullType(type)) { |
| if (valueNode.kind === Kind.NULL) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| return valueFromAST(valueNode, type.ofType, variables); |
| } |
| |
| if (valueNode.kind === Kind.NULL) { |
| // This is explicitly returning the value null. |
| return null; |
| } |
| |
| if (isListType(type)) { |
| var itemType = type.ofType; |
| |
| if (valueNode.kind === Kind.LIST) { |
| var coercedValues = []; |
| |
| for (var _i2 = 0, _valueNode$values2 = valueNode.values; _i2 < _valueNode$values2.length; _i2++) { |
| var itemNode = _valueNode$values2[_i2]; |
| |
| 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 (isNonNullType(itemType)) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedValues.push(null); |
| } else { |
| var itemValue = valueFromAST(itemNode, itemType, variables); |
| |
| if (itemValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedValues.push(itemValue); |
| } |
| } |
| |
| return coercedValues; |
| } |
| |
| var coercedValue = valueFromAST(valueNode, itemType, variables); |
| |
| if (coercedValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| return [coercedValue]; |
| } |
| |
| if (isInputObjectType(type)) { |
| if (valueNode.kind !== Kind.OBJECT) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| var coercedObj = Object.create(null); |
| var fieldNodes = keyMap(valueNode.fields, function (field) { |
| return field.name.value; |
| }); |
| |
| for (var _i4 = 0, _objectValues2 = objectValues(type.getFields()); _i4 < _objectValues2.length; _i4++) { |
| var field = _objectValues2[_i4]; |
| var fieldNode = fieldNodes[field.name]; |
| |
| if (!fieldNode || isMissingVariable(fieldNode.value, variables)) { |
| if (field.defaultValue !== undefined) { |
| coercedObj[field.name] = field.defaultValue; |
| } else if (isNonNullType(field.type)) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| continue; |
| } |
| |
| var fieldValue = valueFromAST(fieldNode.value, field.type, variables); |
| |
| if (fieldValue === undefined) { |
| return; // Invalid: intentionally return no value. |
| } |
| |
| coercedObj[field.name] = fieldValue; |
| } |
| |
| return coercedObj; |
| } |
| |
| /* istanbul ignore else */ |
| if (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. |
| var 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; |
| } // Not reachable. All possible input types have been considered. |
| |
| |
| /* istanbul ignore next */ |
| invariant(false, 'Unexpected input type: ' + 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 === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === undefined); |
| } |