| /** @category Validation Rules */ |
| import { inspect } from '../../jsutils/inspect.mjs'; |
| import { GraphQLError } from '../../error/GraphQLError.mjs'; |
| import { Kind } from '../../language/kinds.mjs'; |
| import { |
| isInputObjectType, |
| isNonNullType, |
| isNullableType, |
| } from '../../type/definition.mjs'; |
| import { isTypeSubTypeOf } from '../../utilities/typeComparators.mjs'; |
| import { typeFromAST } from '../../utilities/typeFromAST.mjs'; |
| |
| /** |
| * Variables in allowed position |
| * |
| * Variable usages must be compatible with the arguments they are passed to. |
| * |
| * See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed |
| * @param context - The validation context used while checking the document. |
| * @returns A visitor that reports validation errors for this rule. |
| * @example |
| * ```ts |
| * import { buildSchema, parse, validate } from 'graphql'; |
| * import { VariablesInAllowedPositionRule } from 'graphql/validation'; |
| * |
| * const schema = buildSchema(` |
| * type Query { |
| * field(arg: ID!): String |
| * } |
| * `); |
| * |
| * const invalidDocument = parse(` |
| * query ($id: String) { field(arg: $id) } |
| * `); |
| * const invalidErrors = validate(schema, invalidDocument, [VariablesInAllowedPositionRule]); |
| * |
| * invalidErrors.length; // => 1 |
| * |
| * const validDocument = parse(` |
| * query ($id: ID!) { field(arg: $id) } |
| * `); |
| * const validErrors = validate(schema, validDocument, [VariablesInAllowedPositionRule]); |
| * |
| * validErrors; // => [] |
| * ``` |
| */ |
| export function VariablesInAllowedPositionRule(context) { |
| let varDefMap = Object.create(null); |
| return { |
| OperationDefinition: { |
| enter() { |
| varDefMap = Object.create(null); |
| }, |
| |
| leave(operation) { |
| const usages = context.getRecursiveVariableUsages(operation); |
| |
| for (const { node, type, defaultValue, parentType } of usages) { |
| const varName = node.name.value; |
| const varDef = varDefMap[varName]; |
| |
| if (varDef && type) { |
| // A var type is allowed if it is the same or more strict (e.g. is |
| // a subtype of) than the expected type. It can be more strict if |
| // the variable type is non-null when the expected type is nullable. |
| // If both are list types, the variable item type can be more strict |
| // than the expected item type (contravariant). |
| const schema = context.getSchema(); |
| const varType = typeFromAST(schema, varDef.type); |
| |
| if ( |
| varType && |
| !allowedVariableUsage( |
| schema, |
| varType, |
| varDef.defaultValue, |
| type, |
| defaultValue, |
| ) |
| ) { |
| const varTypeStr = inspect(varType); |
| const typeStr = inspect(type); |
| context.reportError( |
| new GraphQLError( |
| `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`, |
| { |
| nodes: [varDef, node], |
| }, |
| ), |
| ); |
| } |
| |
| if ( |
| isInputObjectType(parentType) && |
| parentType.isOneOf && |
| isNullableType(varType) |
| ) { |
| context.reportError( |
| new GraphQLError( |
| `Variable "$${varName}" is of type "${varType}" but must be non-nullable to be used for OneOf Input Object "${parentType}".`, |
| { |
| nodes: [varDef, node], |
| }, |
| ), |
| ); |
| } |
| } |
| } |
| }, |
| }, |
| |
| VariableDefinition(node) { |
| varDefMap[node.variable.name.value] = node; |
| }, |
| }; |
| } |
| /** |
| * Returns true if the variable is allowed in the location it was found, |
| * including considering if default values exist for either the variable |
| * or the location at which it is located. |
| * |
| * OneOf Input Object Type fields are considered separately above to |
| * provide a more descriptive error message. |
| * |
| * @internal |
| */ |
| |
| function allowedVariableUsage( |
| schema, |
| varType, |
| varDefaultValue, |
| locationType, |
| locationDefaultValue, |
| ) { |
| if (isNonNullType(locationType) && !isNonNullType(varType)) { |
| const hasNonNullVariableDefaultValue = |
| varDefaultValue != null && varDefaultValue.kind !== Kind.NULL; |
| const hasLocationDefaultValue = locationDefaultValue !== undefined; |
| |
| if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) { |
| return false; |
| } |
| |
| const nullableLocationType = locationType.ofType; |
| return isTypeSubTypeOf(schema, varType, nullableLocationType); |
| } |
| |
| return isTypeSubTypeOf(schema, varType, locationType); |
| } |