update to use spec wording

Author: magicmark

src/utilities/resolveSchemaCoordinate.ts

@@ -99,28 +99,26 @@ export function resolveSchemaCoordinate(
 }
 
 /**
- * SchemaCoordinate : Name
+ * TypeCoordinate : Name
  */
 function resolveTypeCoordinate(
   schema: GraphQLSchema,
   schemaCoordinate: TypeCoordinateNode,
 ): ResolvedNamedType | undefined {
-  // 1. Let {typeName} be the value of the first {Name}.
-  // 2. Let {type} be the type in the {schema} named {typeName}.
+  // 1. Let {typeName} be the value of {Name}.
   const typeName = schemaCoordinate.name.value;
   const type = schema.getType(typeName);
 
-  // 3. If {type} does not exist, return {null}.
-  if (!type) {
+  // 2. Return the type in the {schema} named {typeName}, or {null} if no such type exists.
+  if (type == null) {
     return;
   }
 
-  // 4. {type}
   return { kind: 'NamedType', type };
 }
 
 /**
- * SchemaCoordinate : Name . Name
+ * MemberCoordinate : Name . Name
  */
 function resolveMemberCoordinate(
   schema: GraphQLSchema,
@@ -131,69 +129,66 @@ function resolveMemberCoordinate(
   const typeName = schemaCoordinate.name.value;
   const type = schema.getType(typeName);
 
-  // 3. Assert {type} must exist.
+  // 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 object type, interface type, input object type, or enum type.`,
+    );
+  }
 
   // 4. If {type} is an Enum type:
   if (isEnumType(type)) {
-    // 5. Let {enumValueName} be the value of the second {Name}.
-    // 6. Let {enumValue} be the enum value of {type} named {enumValueName}.
+    // 1. Let {enumValueName} be the value of the second {Name}.
     const enumValueName = schemaCoordinate.memberName.value;
     const enumValue = type.getValue(enumValueName);
 
-    // 7. If {enumValue} does not exist, return {null}.
+    // 2. Return the enum value of {type} named {enumValueName}, or {null} if no such value exists.
     if (enumValue == null) {
       return;
     }
 
-    // 8. Return {enumValue}
     return { kind: 'EnumValue', type, enumValue };
   }
 
-  // 9. Otherwise if {type} is an Input Object type:
+  // 5. Otherwise, if {type} is an Input Object type:
   if (isInputObjectType(type)) {
-    // 10. Let {inputFieldName} be the value of the second {Name}.
-    // 11. Let {inputField} be the input field of {type} named {inputFieldName}.
+    // 1. Let {inputFieldName} be the value of the second {Name}.
     const inputFieldName = schemaCoordinate.memberName.value;
     const inputField = type.getFields()[inputFieldName];
 
-    // 12. If {inputField} does not exist, return {null}.
+    // 2. Return the input field of {type} named {inputFieldName}, or {null} if no such input field exists.
     if (inputField == null) {
       return;
     }
 
-    // 13. Return {inputField}
     return { kind: 'InputField', type, inputField };
   }
 
-  // 14. Otherwise:
-  // 15. Assert {type} must be an Object or Interface type.
-  if (!isObjectType(type) && !isInterfaceType(type)) {
-    throw new Error(
-      `Expected ${inspect(typeName)} to be an object type, interface type, input object type, or enum type.`,
-    );
-  }
-
-  // 16. Let {fieldName} be the value of the second {Name}.
-  // 17. Let {field} be the field of {type} named {fieldName}.
+  // 6. Otherwise:
+  // 1. Let {fieldName} be the value of the second {Name}.
   const fieldName = schemaCoordinate.memberName.value;
   const field = type.getFields()[fieldName];
 
-  // 18. If {field} does not exist, return {null}.
+  // 2. Return the field of {type} named {fieldName}, or {null} if no such field exists.
   if (field == null) {
     return;
   }
 
-  // 19. Return {field}
   return { kind: 'Field', type, field };
 }
 
 /**
- * SchemaCoordinate : Name . Name ( Name : )
+ * ArgumentCoordinate : Name . Name ( Name : )
  */
 function resolveArgumentCoordinate(
   schema: GraphQLSchema,
@@ -204,71 +199,65 @@ function resolveArgumentCoordinate(
   const typeName = schemaCoordinate.name.value;
   const type = schema.getType(typeName);
 
-  // 3. Assert {type} must exist.
+  // 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.`,
     );
   }
-
-  // 4. Assert {type} must be an Object or Interface type.
   if (!isObjectType(type) && !isInterfaceType(type)) {
     throw new Error(
       `Expected ${inspect(typeName)} to be an object type or interface type.`,
     );
   }
 
-  // 5. Let {fieldName} be the value of the second {Name}.
-  // 6. Let {field} be the field of {type} named {fieldName}.
+  // 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.
+  // 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.`,
     );
   }
 
-  // 8. Let {fieldArgumentName} be the value of the third {Name}.
-  // 9. Let {fieldArgument} be the argument of {field} named {fieldArgumentName}.
+  // 7. Let {fieldArgumentName} be the value of the third {Name}.
   const fieldArgumentName = schemaCoordinate.argumentName.value;
   const fieldArgument = field.args.find(
     (arg) => arg.name === fieldArgumentName,
   );
 
-  // 10. If {fieldArgument} does not exist, return {null}.
+  // 8. Return the argument of {field} named {fieldArgumentName}, or {null} if no such argument exists.
   if (fieldArgument == null) {
     return;
   }
 
-  // 11. Return {fieldArgument}.
   return { kind: 'FieldArgument', type, field, fieldArgument };
 }
 
 /**
- * SchemaCoordinate : @ Name
+ * DirectiveCoordinate : @ Name
  */
 function resolveDirectiveCoordinate(
   schema: GraphQLSchema,
   schemaCoordinate: DirectiveCoordinateNode,
 ): ResolvedDirective | undefined {
-  // 1. Let {directiveName} be the value of the first {Name}.
-  // 2. Let {directive} be the directive in the {schema} named {directiveName}.
+  // 1. Let {directiveName} be the value of {Name}.
   const directiveName = schemaCoordinate.name.value;
   const directive = schema.getDirective(directiveName);
 
-  // 3. If {directive} does not exist, return {null}.
+  // 2. Return the directive in the {schema} named {directiveName}, or {null} if no such directive exists.
   if (!directive) {
     return;
   }
 
-  // 4. Otherwise return {directive}.
   return { kind: 'Directive', directive };
 }
 
 /**
- * SchemaCoordinate : @ Name ( Name : )
+ * DirectiveArgumentCoordinate : @ Name ( Name : )
  */
 function resolveDirectiveArgumentCoordinate(
   schema: GraphQLSchema,
@@ -287,20 +276,18 @@ function resolveDirectiveArgumentCoordinate(
   }
 
   // 4. Let {directiveArgumentName} be the value of the second {Name}.
-  // 5. Let {directiveArgument} be the argument of {directive} named {directiveArgumentName}.
   const {
     argumentName: { value: directiveArgumentName },
   } = schemaCoordinate;
   const directiveArgument = directive.args.find(
     (arg) => arg.name === directiveArgumentName,
   );
 
-  // 6. If {directiveArgument} does not exist, return {null}.
+  // 5. Return the argument of {directive} named {directiveArgumentName}, or {null} if no such argument exists.
   if (!directiveArgument) {
     return;
   }
 
-  // 7. Return {directiveArgument}.
   return { kind: 'DirectiveArgument', directive, directiveArgument };
 }