You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
172 lines
5.0 KiB
172 lines
5.0 KiB
import { inspect } from '../jsutils/inspect.mjs'; |
|
import { invariant } from '../jsutils/invariant.mjs'; |
|
import { keyMap } from '../jsutils/keyMap.mjs'; |
|
import { Kind } from '../language/kinds.mjs'; |
|
import { |
|
isInputObjectType, |
|
isLeafType, |
|
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 | Unknown | |
|
* | 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) { |
|
const variableName = valueNode.name.value; |
|
|
|
if (variables == null || variables[variableName] === undefined) { |
|
// No valid return value. |
|
return; |
|
} |
|
|
|
const 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)) { |
|
const itemType = type.ofType; |
|
|
|
if (valueNode.kind === 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 (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 (isInputObjectType(type)) { |
|
if (valueNode.kind !== Kind.OBJECT) { |
|
return; // Invalid: intentionally return no value. |
|
} |
|
|
|
const coercedObj = Object.create(null); |
|
const fieldNodes = 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 (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 (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 || 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) |
|
); |
|
}
|
|
|