graphql 16.11.0 → 16.13.0

package/utilities/resolveSchemaCoordinate.js

@@ -0,0 +1,260 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+});
+exports.resolveASTSchemaCoordinate = resolveASTSchemaCoordinate;
+exports.resolveSchemaCoordinate = resolveSchemaCoordinate;
+
+var _inspect = require('../jsutils/inspect.js');
+
+var _kinds = require('../language/kinds.js');
+
+var _parser = require('../language/parser.js');
+
+var _definition = require('../type/definition.js');
+
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ */
+function resolveSchemaCoordinate(schema, schemaCoordinate) {
+  return resolveASTSchemaCoordinate(
+    schema,
+    (0, _parser.parseSchemaCoordinate)(schemaCoordinate),
+  );
+}
+/**
+ * TypeCoordinate : Name
+ */
+
+function resolveTypeCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of {Name}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 2. Return the type in the {schema} named {typeName} if it exists.
+
+  if (type == null) {
+    return;
+  }
+
+  return {
+    kind: 'NamedType',
+    type,
+  };
+}
+/**
+ * MemberCoordinate : Name . Name
+ */
+
+function resolveMemberCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and must be an Enum, Input Object, Object or Interface type.
+
+  if (!type) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        typeName,
+      )} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (
+    !(0, _definition.isEnumType)(type) &&
+    !(0, _definition.isInputObjectType)(type) &&
+    !(0, _definition.isObjectType)(type) &&
+    !(0, _definition.isInterfaceType)(type)
+  ) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        typeName,
+      )} to be an Enum, Input Object, Object or Interface type.`,
+    );
+  } // 4. If {type} is an Enum type:
+
+  if ((0, _definition.isEnumType)(type)) {
+    // 1. Let {enumValueName} be the value of the second {Name}.
+    const enumValueName = schemaCoordinate.memberName.value;
+    const enumValue = type.getValue(enumValueName); // 2. Return the enum value of {type} named {enumValueName} if it exists.
+
+    if (enumValue == null) {
+      return;
+    }
+
+    return {
+      kind: 'EnumValue',
+      type,
+      enumValue,
+    };
+  } // 5. Otherwise, if {type} is an Input Object type:
+
+  if ((0, _definition.isInputObjectType)(type)) {
+    // 1. Let {inputFieldName} be the value of the second {Name}.
+    const inputFieldName = schemaCoordinate.memberName.value;
+    const inputField = type.getFields()[inputFieldName]; // 2. Return the input field of {type} named {inputFieldName} if it exists.
+
+    if (inputField == null) {
+      return;
+    }
+
+    return {
+      kind: 'InputField',
+      type,
+      inputField,
+    };
+  } // 6. Otherwise:
+  // 1. Let {fieldName} be the value of the second {Name}.
+
+  const fieldName = schemaCoordinate.memberName.value;
+  const field = type.getFields()[fieldName]; // 2. Return the field of {type} named {fieldName} if it exists.
+
+  if (field == null) {
+    return;
+  }
+
+  return {
+    kind: 'Field',
+    type,
+    field,
+  };
+}
+/**
+ * ArgumentCoordinate : Name . Name ( Name : )
+ */
+
+function resolveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and be an Object or Interface type.
+
+  if (type == null) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        typeName,
+      )} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (
+    !(0, _definition.isObjectType)(type) &&
+    !(0, _definition.isInterfaceType)(type)
+  ) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        typeName,
+      )} to be an object type or interface type.`,
+    );
+  } // 4. Let {fieldName} be the value of the second {Name}.
+  // 5. Let {field} be the field of {type} named {fieldName}.
+
+  const fieldName = schemaCoordinate.fieldName.value;
+  const field = type.getFields()[fieldName]; // 7. Assert: {field} must exist.
+
+  if (field == null) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        fieldName,
+      )} to exist as a field of type ${(0, _inspect.inspect)(
+        typeName,
+      )} in the schema.`,
+    );
+  } // 7. Let {fieldArgumentName} be the value of the third {Name}.
+
+  const fieldArgumentName = schemaCoordinate.argumentName.value;
+  const fieldArgument = field.args.find(
+    (arg) => arg.name === fieldArgumentName,
+  ); // 8. Return the argument of {field} named {fieldArgumentName} if it exists.
+
+  if (fieldArgument == null) {
+    return;
+  }
+
+  return {
+    kind: 'FieldArgument',
+    type,
+    field,
+    fieldArgument,
+  };
+}
+/**
+ * DirectiveCoordinate : \@ Name
+ */
+
+function resolveDirectiveCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of {Name}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 2. Return the directive in the {schema} named {directiveName} if it exists.
+
+  if (!directive) {
+    return;
+  }
+
+  return {
+    kind: 'Directive',
+    directive,
+  };
+}
+/**
+ * DirectiveArgumentCoordinate : \@ Name ( Name : )
+ */
+
+function resolveDirectiveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of the first {Name}.
+  // 2. Let {directive} be the directive in the {schema} named {directiveName}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 3. Assert {directive} must exist.
+
+  if (!directive) {
+    throw new Error(
+      `Expected ${(0, _inspect.inspect)(
+        directiveName,
+      )} to be defined as a directive in the schema.`,
+    );
+  } // 4. Let {directiveArgumentName} be the value of the second {Name}.
+
+  const {
+    argumentName: { value: directiveArgumentName },
+  } = schemaCoordinate;
+  const directiveArgument = directive.args.find(
+    (arg) => arg.name === directiveArgumentName,
+  ); // 5. Return the argument of {directive} named {directiveArgumentName} if it exists.
+
+  if (!directiveArgument) {
+    return;
+  }
+
+  return {
+    kind: 'DirectiveArgument',
+    directive,
+    directiveArgument,
+  };
+}
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ */
+
+function resolveASTSchemaCoordinate(schema, schemaCoordinate) {
+  switch (schemaCoordinate.kind) {
+    case _kinds.Kind.TYPE_COORDINATE:
+      return resolveTypeCoordinate(schema, schemaCoordinate);
+
+    case _kinds.Kind.MEMBER_COORDINATE:
+      return resolveMemberCoordinate(schema, schemaCoordinate);
+
+    case _kinds.Kind.ARGUMENT_COORDINATE:
+      return resolveArgumentCoordinate(schema, schemaCoordinate);
+
+    case _kinds.Kind.DIRECTIVE_COORDINATE:
+      return resolveDirectiveCoordinate(schema, schemaCoordinate);
+
+    case _kinds.Kind.DIRECTIVE_ARGUMENT_COORDINATE:
+      return resolveDirectiveArgumentCoordinate(schema, schemaCoordinate);
+  }
+}

package/utilities/resolveSchemaCoordinate.mjs

@@ -0,0 +1,243 @@
+import { inspect } from '../jsutils/inspect.mjs';
+import { Kind } from '../language/kinds.mjs';
+import { parseSchemaCoordinate } from '../language/parser.mjs';
+import {
+  isEnumType,
+  isInputObjectType,
+  isInterfaceType,
+  isObjectType,
+} from '../type/definition.mjs';
+
+/**
+ * A schema coordinate is resolved in the context of a GraphQL schema to
+ * uniquely identify a schema element. It returns undefined if the schema
+ * coordinate does not resolve to a schema element, meta-field, or introspection
+ * schema element. It will throw if the containing schema element (if
+ * applicable) does not exist.
+ *
+ * https://spec.graphql.org/draft/#sec-Schema-Coordinates.Semantics
+ */
+export function resolveSchemaCoordinate(schema, schemaCoordinate) {
+  return resolveASTSchemaCoordinate(
+    schema,
+    parseSchemaCoordinate(schemaCoordinate),
+  );
+}
+/**
+ * TypeCoordinate : Name
+ */
+
+function resolveTypeCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of {Name}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 2. Return the type in the {schema} named {typeName} if it exists.
+
+  if (type == null) {
+    return;
+  }
+
+  return {
+    kind: 'NamedType',
+    type,
+  };
+}
+/**
+ * MemberCoordinate : Name . Name
+ */
+
+function resolveMemberCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and must be an Enum, Input Object, Object or Interface type.
+
+  if (!type) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (
+    !isEnumType(type) &&
+    !isInputObjectType(type) &&
+    !isObjectType(type) &&
+    !isInterfaceType(type)
+  ) {
+    throw new Error(
+      `Expected ${inspect(
+        typeName,
+      )} to be an Enum, Input Object, Object or Interface type.`,
+    );
+  } // 4. If {type} is an Enum type:
+
+  if (isEnumType(type)) {
+    // 1. Let {enumValueName} be the value of the second {Name}.
+    const enumValueName = schemaCoordinate.memberName.value;
+    const enumValue = type.getValue(enumValueName); // 2. Return the enum value of {type} named {enumValueName} if it exists.
+
+    if (enumValue == null) {
+      return;
+    }
+
+    return {
+      kind: 'EnumValue',
+      type,
+      enumValue,
+    };
+  } // 5. Otherwise, if {type} is an Input Object type:
+
+  if (isInputObjectType(type)) {
+    // 1. Let {inputFieldName} be the value of the second {Name}.
+    const inputFieldName = schemaCoordinate.memberName.value;
+    const inputField = type.getFields()[inputFieldName]; // 2. Return the input field of {type} named {inputFieldName} if it exists.
+
+    if (inputField == null) {
+      return;
+    }
+
+    return {
+      kind: 'InputField',
+      type,
+      inputField,
+    };
+  } // 6. Otherwise:
+  // 1. Let {fieldName} be the value of the second {Name}.
+
+  const fieldName = schemaCoordinate.memberName.value;
+  const field = type.getFields()[fieldName]; // 2. Return the field of {type} named {fieldName} if it exists.
+
+  if (field == null) {
+    return;
+  }
+
+  return {
+    kind: 'Field',
+    type,
+    field,
+  };
+}
+/**
+ * ArgumentCoordinate : Name . Name ( Name : )
+ */
+
+function resolveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {typeName} be the value of the first {Name}.
+  // 2. Let {type} be the type in the {schema} named {typeName}.
+  const typeName = schemaCoordinate.name.value;
+  const type = schema.getType(typeName); // 3. Assert: {type} must exist, and be an Object or Interface type.
+
+  if (type == null) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be defined as a type in the schema.`,
+    );
+  }
+
+  if (!isObjectType(type) && !isInterfaceType(type)) {
+    throw new Error(
+      `Expected ${inspect(typeName)} to be an object type or interface type.`,
+    );
+  } // 4. Let {fieldName} be the value of the second {Name}.
+  // 5. Let {field} be the field of {type} named {fieldName}.
+
+  const fieldName = schemaCoordinate.fieldName.value;
+  const field = type.getFields()[fieldName]; // 7. Assert: {field} must exist.
+
+  if (field == null) {
+    throw new Error(
+      `Expected ${inspect(fieldName)} to exist as a field of type ${inspect(
+        typeName,
+      )} in the schema.`,
+    );
+  } // 7. Let {fieldArgumentName} be the value of the third {Name}.
+
+  const fieldArgumentName = schemaCoordinate.argumentName.value;
+  const fieldArgument = field.args.find(
+    (arg) => arg.name === fieldArgumentName,
+  ); // 8. Return the argument of {field} named {fieldArgumentName} if it exists.
+
+  if (fieldArgument == null) {
+    return;
+  }
+
+  return {
+    kind: 'FieldArgument',
+    type,
+    field,
+    fieldArgument,
+  };
+}
+/**
+ * DirectiveCoordinate : \@ Name
+ */
+
+function resolveDirectiveCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of {Name}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 2. Return the directive in the {schema} named {directiveName} if it exists.
+
+  if (!directive) {
+    return;
+  }
+
+  return {
+    kind: 'Directive',
+    directive,
+  };
+}
+/**
+ * DirectiveArgumentCoordinate : \@ Name ( Name : )
+ */
+
+function resolveDirectiveArgumentCoordinate(schema, schemaCoordinate) {
+  // 1. Let {directiveName} be the value of the first {Name}.
+  // 2. Let {directive} be the directive in the {schema} named {directiveName}.
+  const directiveName = schemaCoordinate.name.value;
+  const directive = schema.getDirective(directiveName); // 3. Assert {directive} must exist.
+
+  if (!directive) {
+    throw new Error(
+      `Expected ${inspect(
+        directiveName,
+      )} to be defined as a directive in the schema.`,
+    );
+  } // 4. Let {directiveArgumentName} be the value of the second {Name}.
+
+  const {
+    argumentName: { value: directiveArgumentName },
+  } = schemaCoordinate;
+  const directiveArgument = directive.args.find(
+    (arg) => arg.name === directiveArgumentName,
+  ); // 5. Return the argument of {directive} named {directiveArgumentName} if it exists.
+
+  if (!directiveArgument) {
+    return;
+  }
+
+  return {
+    kind: 'DirectiveArgument',
+    directive,
+    directiveArgument,
+  };
+}
+/**
+ * Resolves schema coordinate from a parsed SchemaCoordinate node.
+ */
+
+export function resolveASTSchemaCoordinate(schema, schemaCoordinate) {
+  switch (schemaCoordinate.kind) {
+    case Kind.TYPE_COORDINATE:
+      return resolveTypeCoordinate(schema, schemaCoordinate);
+
+    case Kind.MEMBER_COORDINATE:
+      return resolveMemberCoordinate(schema, schemaCoordinate);
+
+    case Kind.ARGUMENT_COORDINATE:
+      return resolveArgumentCoordinate(schema, schemaCoordinate);
+
+    case Kind.DIRECTIVE_COORDINATE:
+      return resolveDirectiveCoordinate(schema, schemaCoordinate);
+
+    case Kind.DIRECTIVE_ARGUMENT_COORDINATE:
+      return resolveDirectiveArgumentCoordinate(schema, schemaCoordinate);
+  }
+}

package/validation/rules/ValuesOfCorrectTypeRule.js

@@ -85,13 +85,7 @@ function ValuesOfCorrectTypeRule(context) {
       }
 
       if (type.isOneOf) {
-        validateOneOfInputObject(
-          context,
-          node,
-          type,
-          fieldNodeMap,
-          variableDefinitions,
-        );
+        validateOneOfInputObject(context, node, type, fieldNodeMap);
       }
     },
 
@@ -138,6 +132,11 @@ function ValuesOfCorrectTypeRule(context) {
     EnumValue: (node) => isValidValueNode(context, node),
     IntValue: (node) => isValidValueNode(context, node),
     FloatValue: (node) => isValidValueNode(context, node),
+    // Descriptions are string values that would not validate according
+    // to the below logic, but since (per the specification) descriptions must
+    // not affect validation, they are ignored entirely when visiting the AST
+    // and do not require special handling.
+    // See https://spec.graphql.org/draft/#sec-Descriptions
     StringValue: (node) => isValidValueNode(context, node),
     BooleanValue: (node) => isValidValueNode(context, node),
   };
@@ -214,13 +213,7 @@ function isValidValueNode(context, node) {
   }
 }
 
-function validateOneOfInputObject(
-  context,
-  node,
-  type,
-  fieldNodeMap,
-  variableDefinitions,
-) {
+function validateOneOfInputObject(context, node, type, fieldNodeMap) {
   var _fieldNodeMap$keys$;
 
   const keys = Object.keys(fieldNodeMap);
@@ -244,9 +237,6 @@ function validateOneOfInputObject(
       ? void 0
       : _fieldNodeMap$keys$.value;
   const isNullLiteral = !value || value.kind === _kinds.Kind.NULL;
-  const isVariable =
-    (value === null || value === void 0 ? void 0 : value.kind) ===
-    _kinds.Kind.VARIABLE;
 
   if (isNullLiteral) {
     context.reportError(
@@ -257,24 +247,5 @@ function validateOneOfInputObject(
         },
       ),
     );
-    return;
-  }
-
-  if (isVariable) {
-    const variableName = value.name.value;
-    const definition = variableDefinitions[variableName];
-    const isNullableVariable =
-      definition.type.kind !== _kinds.Kind.NON_NULL_TYPE;
-
-    if (isNullableVariable) {
-      context.reportError(
-        new _GraphQLError.GraphQLError(
-          `Variable "${variableName}" must be non-nullable to be used for OneOf Input Object "${type.name}".`,
-          {
-            nodes: [node],
-          },
-        ),
-      );
-    }
   }
 }

package/validation/rules/ValuesOfCorrectTypeRule.mjs

@@ -74,13 +74,7 @@ export function ValuesOfCorrectTypeRule(context) {
       }
 
       if (type.isOneOf) {
-        validateOneOfInputObject(
-          context,
-          node,
-          type,
-          fieldNodeMap,
-          variableDefinitions,
-        );
+        validateOneOfInputObject(context, node, type, fieldNodeMap);
       }
     },
 
@@ -123,6 +117,11 @@ export function ValuesOfCorrectTypeRule(context) {
     EnumValue: (node) => isValidValueNode(context, node),
     IntValue: (node) => isValidValueNode(context, node),
     FloatValue: (node) => isValidValueNode(context, node),
+    // Descriptions are string values that would not validate according
+    // to the below logic, but since (per the specification) descriptions must
+    // not affect validation, they are ignored entirely when visiting the AST
+    // and do not require special handling.
+    // See https://spec.graphql.org/draft/#sec-Descriptions
     StringValue: (node) => isValidValueNode(context, node),
     BooleanValue: (node) => isValidValueNode(context, node),
   };
@@ -194,13 +193,7 @@ function isValidValueNode(context, node) {
   }
 }
 
-function validateOneOfInputObject(
-  context,
-  node,
-  type,
-  fieldNodeMap,
-  variableDefinitions,
-) {
+function validateOneOfInputObject(context, node, type, fieldNodeMap) {
   var _fieldNodeMap$keys$;
 
   const keys = Object.keys(fieldNodeMap);
@@ -224,9 +217,6 @@ function validateOneOfInputObject(
       ? void 0
       : _fieldNodeMap$keys$.value;
   const isNullLiteral = !value || value.kind === Kind.NULL;
-  const isVariable =
-    (value === null || value === void 0 ? void 0 : value.kind) ===
-    Kind.VARIABLE;
 
   if (isNullLiteral) {
     context.reportError(
@@ -234,23 +224,5 @@ function validateOneOfInputObject(
         nodes: [node],
       }),
     );
-    return;
-  }
-
-  if (isVariable) {
-    const variableName = value.name.value;
-    const definition = variableDefinitions[variableName];
-    const isNullableVariable = definition.type.kind !== Kind.NON_NULL_TYPE;
-
-    if (isNullableVariable) {
-      context.reportError(
-        new GraphQLError(
-          `Variable "${variableName}" must be non-nullable to be used for OneOf Input Object "${type.name}".`,
-          {
-            nodes: [node],
-          },
-        ),
-      );
-    }
   }
 }

package/validation/validate.js

@@ -10,8 +10,12 @@ exports.validateSDL = validateSDL;
 
 var _devAssert = require('../jsutils/devAssert.js');
 
+var _mapValue = require('../jsutils/mapValue.js');
+
 var _GraphQLError = require('../error/GraphQLError.js');
 
+var _ast = require('../language/ast.js');
+
 var _visitor = require('../language/visitor.js');
 
 var _validate = require('../type/validate.js');
@@ -22,6 +26,12 @@ var _specifiedRules = require('./specifiedRules.js');
 
 var _ValidationContext = require('./ValidationContext.js');
 
+// Per the specification, descriptions must not affect validation.
+// See https://spec.graphql.org/draft/#sec-Descriptions
+const QueryDocumentKeysToValidate = (0, _mapValue.mapValue)(
+  _ast.QueryDocumentKeys,
+  (keys) => keys.filter((key) => key !== 'description'),
+);
 /**
  * Implements the "Validation" section of the spec.
  *
@@ -42,6 +52,7 @@ var _ValidationContext = require('./ValidationContext.js');
  * Optionally a custom TypeInfo instance may be provided. If not provided, one
  * will be created from the provided schema.
  */
+
 function validate(
   schema,
   documentAST,
@@ -91,6 +102,7 @@ function validate(
     (0, _visitor.visit)(
       documentAST,
       (0, _TypeInfo.visitWithTypeInfo)(typeInfo, visitor),
+      QueryDocumentKeysToValidate,
     );
   } catch (e) {
     if (e !== abortObj) {