Also add isRequiredInput()

Author: leebyron

src/index.d.ts

@@ -94,6 +94,7 @@ export {
   isWrappingType,
   isNullableType,
   isNamedType,
+  isRequiredInput,
   isRequiredArgument,
   isRequiredInputField,
   isSpecifiedScalarType,

src/index.js

@@ -93,6 +93,7 @@ export {
   isWrappingType,
   isNullableType,
   isNamedType,
+  isRequiredInput,
   isRequiredArgument,
   isRequiredInputField,
   isSpecifiedScalarType,

src/type/__tests__/predicate-test.js

@@ -49,8 +49,7 @@ import {
   isWrappingType,
   isNullableType,
   isNamedType,
-  isRequiredArgument,
-  isRequiredInputField,
+  isRequiredInput,
   assertType,
   assertScalarType,
   assertObjectType,
@@ -562,7 +561,7 @@ describe('Type predicates', () => {
     });
   });
 
-  describe('isRequiredArgument', () => {
+  describe('isRequiredInput', () => {
     function buildArg(config: {|
       type: GraphQLInputType,
       defaultValue?: mixed,
@@ -582,35 +581,33 @@ describe('Type predicates', () => {
       const requiredArg = buildArg({
         type: new GraphQLNonNull(GraphQLString),
       });
-      expect(isRequiredArgument(requiredArg)).to.equal(true);
+      expect(isRequiredInput(requiredArg)).to.equal(true);
     });
 
     it('returns false for optional arguments', () => {
       const optArg1 = buildArg({
         type: GraphQLString,
       });
-      expect(isRequiredArgument(optArg1)).to.equal(false);
+      expect(isRequiredInput(optArg1)).to.equal(false);
 
       const optArg2 = buildArg({
         type: GraphQLString,
         defaultValue: null,
       });
-      expect(isRequiredArgument(optArg2)).to.equal(false);
+      expect(isRequiredInput(optArg2)).to.equal(false);
 
       const optArg3 = buildArg({
         type: new GraphQLList(new GraphQLNonNull(GraphQLString)),
       });
-      expect(isRequiredArgument(optArg3)).to.equal(false);
+      expect(isRequiredInput(optArg3)).to.equal(false);
 
       const optArg4 = buildArg({
         type: new GraphQLNonNull(GraphQLString),
         defaultValue: 'default',
       });
-      expect(isRequiredArgument(optArg4)).to.equal(false);
+      expect(isRequiredInput(optArg4)).to.equal(false);
     });
-  });
 
-  describe('isRequiredInputField', () => {
     function buildInputField(config: {|
       type: GraphQLInputType,
       defaultValue?: mixed,
@@ -630,31 +627,31 @@ describe('Type predicates', () => {
       const requiredField = buildInputField({
         type: new GraphQLNonNull(GraphQLString),
       });
-      expect(isRequiredInputField(requiredField)).to.equal(true);
+      expect(isRequiredInput(requiredField)).to.equal(true);
     });
 
     it('returns false for optional input field', () => {
       const optField1 = buildInputField({
         type: GraphQLString,
       });
-      expect(isRequiredInputField(optField1)).to.equal(false);
+      expect(isRequiredInput(optField1)).to.equal(false);
 
       const optField2 = buildInputField({
         type: GraphQLString,
         defaultValue: null,
       });
-      expect(isRequiredInputField(optField2)).to.equal(false);
+      expect(isRequiredInput(optField2)).to.equal(false);
 
       const optField3 = buildInputField({
         type: new GraphQLList(new GraphQLNonNull(GraphQLString)),
       });
-      expect(isRequiredInputField(optField3)).to.equal(false);
+      expect(isRequiredInput(optField3)).to.equal(false);
 
       const optField4 = buildInputField({
         type: new GraphQLNonNull(GraphQLString),
         defaultValue: 'default',
       });
-      expect(isRequiredInputField(optField4)).to.equal(false);
+      expect(isRequiredInput(optField4)).to.equal(false);
     });
   });
 });

src/type/definition.d.ts

@@ -571,6 +571,8 @@ export type GraphQLFieldMap<TSource, TContext> = ObjMap<
   GraphQLField<TSource, TContext>
 >;
 
+export function isRequiredInput(input: GraphQLInputValue<any>): boolean;
+
 export interface GraphQLInputValue<Extensions> {
   name: string;
   description: Maybe<string>;

src/type/definition.js

@@ -952,14 +952,16 @@ export type GraphQLField<
 
 export type GraphQLArgument = GraphQLInputValue;
 
-export function isRequiredArgument(arg: GraphQLArgument): boolean %checks {
-  return isNonNullType(arg.type) && arg.defaultValue === undefined;
-}
+export const isRequiredArgument = isRequiredInput;
 
 export type GraphQLFieldMap<TSource, TContext> = ObjMap<
   GraphQLField<TSource, TContext>,
 >;
 
+export function isRequiredInput(input: GraphQLInputValue): boolean %checks {
+  return isNonNullType(input.type) && input.defaultValue === undefined;
+}
+
 /**
  * @internal
  */
@@ -1570,10 +1572,6 @@ export type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;
 
 export type GraphQLInputField = GraphQLInputValue;
 
-export function isRequiredInputField(
-  field: GraphQLInputField,
-): boolean %checks {
-  return isNonNullType(field.type) && field.defaultValue === undefined;
-}
+export const isRequiredInputField = isRequiredInput;
 
 export type GraphQLInputFieldMap = ObjMap<GraphQLInputField>;

src/type/index.d.ts

@@ -30,6 +30,7 @@ export {
   isWrappingType,
   isNullableType,
   isNamedType,
+  isRequiredInput,
   isRequiredArgument,
   isRequiredInputField,
   // Assertions

src/type/index.js

@@ -29,6 +29,7 @@ export {
   isWrappingType,
   isNullableType,
   isNamedType,
+  isRequiredInput,
   isRequiredArgument,
   isRequiredInputField,
   // Assertions

src/type/validate.js

@@ -34,8 +34,7 @@ import {
   isNonNullType,
   isInputType,
   isOutputType,
-  isRequiredArgument,
-  isRequiredInputField,
+  isRequiredInput,
 } from './definition';
 
 /**
@@ -180,7 +179,7 @@ function validateDirectives(context: SchemaValidationContext): void {
         );
       }
 
-      if (isRequiredArgument(arg) && arg.deprecationReason != null) {
+      if (isRequiredInput(arg) && arg.deprecationReason != null) {
         context.reportError(
           `Required argument @${directive.name}(${arg.name}:) cannot be deprecated.`,
           [getDeprecatedDirectiveNode(arg.astNode), arg.astNode?.type],
@@ -292,7 +291,7 @@ function validateFields(
         );
       }
 
-      if (isRequiredArgument(arg) && arg.deprecationReason != null) {
+      if (isRequiredInput(arg) && arg.deprecationReason != null) {
         context.reportError(
           `Required argument ${type.name}.${field.name}(${argName}:) cannot be deprecated.`,
           [getDeprecatedDirectiveNode(arg.astNode), arg.astNode?.type],
@@ -411,7 +410,7 @@ function validateTypeImplementsInterface(
     for (const typeArg of typeField.args) {
       const argName = typeArg.name;
       const ifaceArg = ifaceField.args.find((arg) => arg.name === argName);
-      if (!ifaceArg && isRequiredArgument(typeArg)) {
+      if (!ifaceArg && isRequiredInput(typeArg)) {
         context.reportError(
           `Object field ${type.name}.${fieldName} includes required argument ${argName} that is missing from the Interface field ${iface.name}.${fieldName}.`,
           [typeArg.astNode, ifaceField.astNode],
@@ -529,7 +528,7 @@ function validateInputFields(
       );
     }
 
-    if (isRequiredInputField(field) && field.deprecationReason != null) {
+    if (isRequiredInput(field) && field.deprecationReason != null) {
       context.reportError(
         `Required input field ${inputObj.name}.${field.name} cannot be deprecated.`,
         [

src/utilities/findBreakingChanges.js

@@ -29,8 +29,7 @@ import {
   isNonNullType,
   isListType,
   isNamedType,
-  isRequiredArgument,
-  isRequiredInputField,
+  isRequiredInput,
 } from '../type/definition';
 
 import { astFromValue } from './astFromValue';
@@ -133,7 +132,7 @@ function findDirectiveChanges(
     const argsDiff = diff(oldDirective.args, newDirective.args);
 
     for (const newArg of argsDiff.added) {
-      if (isRequiredArgument(newArg)) {
+      if (isRequiredInput(newArg)) {
         schemaChanges.push({
           type: BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED,
           description: `A required arg ${newArg.name} on directive ${oldDirective.name} was added.`,
@@ -229,7 +228,7 @@ function findInputObjectTypeChanges(
   );
 
   for (const newField of fieldsDiff.added) {
-    if (isRequiredInputField(newField)) {
+    if (isRequiredInput(newField)) {
       schemaChanges.push({
         type: BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED,
         description: `A required field ${newField.name} on input type ${oldType.name} was added.`,
@@ -427,7 +426,7 @@ function findArgChanges(
   }
 
   for (const newArg of argsDiff.added) {
-    if (isRequiredArgument(newArg)) {
+    if (isRequiredInput(newArg)) {
       schemaChanges.push({
         type: BreakingChangeType.REQUIRED_ARG_ADDED,
         description: `A required arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`,

src/validation/rules/ProvidedRequiredArgumentsRule.js

@@ -9,7 +9,7 @@ import { Kind } from '../../language/kinds';
 import { print } from '../../language/printer';
 
 import { specifiedDirectives } from '../../type/directives';
-import { isType, isRequiredArgument } from '../../type/definition';
+import { isType, isRequiredInput } from '../../type/definition';
 
 import type {
   ValidationContext,
@@ -41,7 +41,7 @@ export function ProvidedRequiredArgumentsRule(
           fieldNode.arguments?.map((arg) => arg.name.value),
         );
         for (const argDef of fieldDef.args) {
-          if (!providedArgs.has(argDef.name) && isRequiredArgument(argDef)) {
+          if (!providedArgs.has(argDef.name) && isRequiredInput(argDef)) {
             const argTypeStr = inspect(argDef.type);
             context.reportError(
               new GraphQLError(
@@ -68,7 +68,7 @@ export function ProvidedRequiredArgumentsOnDirectivesRule(
   const definedDirectives = schema?.getDirectives() ?? specifiedDirectives;
   for (const directive of definedDirectives) {
     requiredArgsMap[directive.name] = keyMap(
-      directive.args.filter(isRequiredArgument),
+      directive.args.filter(isRequiredInput),
       (arg) => arg.name,
     );
   }
@@ -80,7 +80,7 @@ export function ProvidedRequiredArgumentsOnDirectivesRule(
       const argNodes = def.arguments ?? [];
 
       requiredArgsMap[def.name.value] = keyMap(
-        argNodes.filter(isRequiredArgumentNode),
+        argNodes.filter(isRequiredInputNode),
         (arg) => arg.name.value,
       );
     }
@@ -115,6 +115,6 @@ export function ProvidedRequiredArgumentsOnDirectivesRule(
   };
 }
 
-function isRequiredArgumentNode(arg: InputValueDefinitionNode): boolean {
+function isRequiredInputNode(arg: InputValueDefinitionNode): boolean {
   return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
 }