Unify InputValueConfig in schema definition

Defines a central `GraphQLInputValueConfig` and `GraphQLInputValue` as well as single definitions for converting between them, unifying this common functionality between input values and arguments.

This is a pre-req for #3049

Author: leebyron

src/index.d.ts

@@ -145,9 +145,13 @@ export {
   GraphQLSchemaExtensions,
   GraphQLDirectiveConfig,
   GraphQLDirectiveExtensions,
+  GraphQLDirectiveArgument,
+  GraphQLDirectiveArgumentConfig,
   GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
+  GraphQLInputValue,
+  GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,
   GraphQLEnumValue,

src/index.js

@@ -144,6 +144,10 @@ export type {
   GraphQLDirectiveConfig,
   GraphQLArgument,
   GraphQLArgumentConfig,
+  GraphQLDirectiveArgument,
+  GraphQLDirectiveArgumentConfig,
+  GraphQLInputValue,
+  GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumValue,
   GraphQLEnumValueConfig,

src/type/definition.d.ts

@@ -441,10 +441,6 @@ export class GraphQLObjectType<TSource = any, TContext = any> {
   get [Symbol.toStringTag](): string;
 }
 
-export function argsToArgsConfig(
-  args: ReadonlyArray<GraphQLArgument>,
-): GraphQLFieldConfigArgumentMap;
-
 export interface GraphQLObjectTypeConfig<TSource, TContext> {
   name: string;
   description?: Maybe<string>;
@@ -545,14 +541,7 @@ export interface GraphQLArgumentExtensions {
   [attributeName: string]: unknown;
 }
 
-export interface GraphQLArgumentConfig {
-  description?: Maybe<string>;
-  type: GraphQLInputType;
-  defaultValue?: unknown;
-  deprecationReason?: Maybe<string>;
-  extensions?: Maybe<Readonly<GraphQLArgumentExtensions>>;
-  astNode?: Maybe<InputValueDefinitionNode>;
-}
+export type GraphQLArgumentConfig = GraphQLInputValueConfig<GraphQLArgumentExtensions>;
 
 export type GraphQLFieldConfigMap<TSource, TContext> = ObjMap<
   GraphQLFieldConfig<TSource, TContext>
@@ -574,21 +563,32 @@ export interface GraphQLField<
   astNode?: Maybe<FieldDefinitionNode>;
 }
 
-export interface GraphQLArgument {
+export type GraphQLArgument = GraphQLInputValue<GraphQLArgumentExtensions>;
+
+export function isRequiredArgument(arg: GraphQLArgument): boolean;
+
+export type GraphQLFieldMap<TSource, TContext> = ObjMap<
+  GraphQLField<TSource, TContext>
+>;
+
+export interface GraphQLInputValue<Extensions> {
   name: string;
   description: Maybe<string>;
   type: GraphQLInputType;
   defaultValue: unknown;
   deprecationReason: Maybe<string>;
-  extensions: Maybe<Readonly<GraphQLArgumentExtensions>>;
+  extensions: Maybe<Readonly<Extensions>>;
   astNode: Maybe<InputValueDefinitionNode>;
 }
 
-export function isRequiredArgument(arg: GraphQLArgument): boolean;
-
-export type GraphQLFieldMap<TSource, TContext> = ObjMap<
-  GraphQLField<TSource, TContext>
->;
+export interface GraphQLInputValueConfig<Extensions> {
+  description?: Maybe<string>;
+  type: GraphQLInputType;
+  defaultValue?: unknown;
+  deprecationReason?: Maybe<string>;
+  extensions?: Maybe<Readonly<Extensions>>;
+  astNode?: Maybe<InputValueDefinitionNode>;
+}
 
 /**
  * Custom extensions
@@ -913,29 +913,14 @@ export interface GraphQLInputObjectTypeConfig {
  * an object which can contain all the values you need.
  */
 export interface GraphQLInputFieldExtensions {
-  [attributeName: string]: any;
+  [attributeName: string]: unknown;
 }
 
-export interface GraphQLInputFieldConfig {
-  description?: Maybe<string>;
-  type: GraphQLInputType;
-  defaultValue?: unknown;
-  deprecationReason?: Maybe<string>;
-  extensions?: Maybe<Readonly<GraphQLInputFieldExtensions>>;
-  astNode?: Maybe<InputValueDefinitionNode>;
-}
+export type GraphQLInputFieldConfig = GraphQLInputValueConfig<GraphQLInputFieldExtensions>;
 
 export type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;
 
-export interface GraphQLInputField {
-  name: string;
-  description?: Maybe<string>;
-  type: GraphQLInputType;
-  defaultValue?: unknown;
-  deprecationReason: Maybe<string>;
-  extensions: Maybe<Readonly<GraphQLInputFieldExtensions>>;
-  astNode?: Maybe<InputValueDefinitionNode>;
-}
+export type GraphQLInputField = GraphQLInputValue<GraphQLInputFieldExtensions>;
 
 export function isRequiredInputField(field: GraphQLInputField): boolean;
 

src/type/definition.js

@@ -821,7 +821,9 @@ function defineFieldMap<TSource, TContext>(
       name: fieldName,
       description: fieldConfig.description,
       type: fieldConfig.type,
-      args: defineArguments(argsConfig),
+      args: Object.entries(argsConfig).map(([argName, argConfig]) =>
+        defineInputValue(argConfig, argName),
+      ),
       resolve: fieldConfig.resolve,
       subscribe: fieldConfig.subscribe,
       deprecationReason: fieldConfig.deprecationReason,
@@ -831,20 +833,6 @@ function defineFieldMap<TSource, TContext>(
   });
 }
 
-export function defineArguments(
-  config: GraphQLFieldConfigArgumentMap,
-): $ReadOnlyArray<GraphQLArgument> {
-  return Object.entries(config).map(([argName, argConfig]) => ({
-    name: argName,
-    description: argConfig.description,
-    type: argConfig.type,
-    defaultValue: argConfig.defaultValue,
-    deprecationReason: argConfig.deprecationReason,
-    extensions: argConfig.extensions && toObjMap(argConfig.extensions),
-    astNode: argConfig.astNode,
-  }));
-}
-
 function isPlainObj(obj: mixed): boolean {
   return isObjectLike(obj) && !Array.isArray(obj);
 }
@@ -855,7 +843,7 @@ function fieldsToFieldsConfig(
   return mapValue(fields, (field) => ({
     description: field.description,
     type: field.type,
-    args: argsToArgsConfig(field.args),
+    args: keyValMap(field.args, (arg) => arg.name, inputValueToConfig),
     resolve: field.resolve,
     subscribe: field.subscribe,
     deprecationReason: field.deprecationReason,
@@ -864,26 +852,6 @@ function fieldsToFieldsConfig(
   }));
 }
 
-/**
- * @internal
- */
-export function argsToArgsConfig(
-  args: $ReadOnlyArray<GraphQLArgument>,
-): GraphQLFieldConfigArgumentMap {
-  return keyValMap(
-    args,
-    (arg) => arg.name,
-    (arg) => ({
-      description: arg.description,
-      type: arg.type,
-      defaultValue: arg.defaultValue,
-      deprecationReason: arg.deprecationReason,
-      extensions: arg.extensions,
-      astNode: arg.astNode,
-    }),
-  );
-}
-
 export type GraphQLObjectTypeConfig<TSource, TContext> = {|
   name: string,
   description?: ?string,
@@ -960,14 +928,7 @@ export type GraphQLFieldConfig<
 
 export type GraphQLFieldConfigArgumentMap = ObjMap<GraphQLArgumentConfig>;
 
-export type GraphQLArgumentConfig = {|
-  description?: ?string,
-  type: GraphQLInputType,
-  defaultValue?: mixed,
-  extensions?: ?ReadOnlyObjMapLike<mixed>,
-  deprecationReason?: ?string,
-  astNode?: ?InputValueDefinitionNode,
-|};
+export type GraphQLArgumentConfig = GraphQLInputValueConfig;
 
 export type GraphQLFieldConfigMap<TSource, TContext> = ObjMap<
   GraphQLFieldConfig<TSource, TContext>,
@@ -989,7 +950,55 @@ export type GraphQLField<
   astNode: ?FieldDefinitionNode,
 |};
 
-export type GraphQLArgument = {|
+export type GraphQLArgument = GraphQLInputValue;
+
+export function isRequiredArgument(arg: GraphQLArgument): boolean %checks {
+  return isNonNullType(arg.type) && arg.defaultValue === undefined;
+}
+
+export type GraphQLFieldMap<TSource, TContext> = ObjMap<
+  GraphQLField<TSource, TContext>,
+>;
+
+/**
+ * @internal
+ */
+export function defineInputValue(
+  config: GraphQLInputValueConfig,
+  name: string,
+): GraphQLInputValue {
+  devAssert(
+    !('resolve' in config),
+    `${name} has a resolve property, but inputs cannot define resolvers.`,
+  );
+  return {
+    name,
+    description: config.description,
+    type: config.type,
+    defaultValue: config.defaultValue,
+    deprecationReason: config.deprecationReason,
+    extensions: config.extensions && toObjMap(config.extensions),
+    astNode: config.astNode,
+  };
+}
+
+/**
+ * @internal
+ */
+export function inputValueToConfig(
+  inputValue: GraphQLInputValue,
+): GraphQLInputValueConfig {
+  return {
+    description: inputValue.description,
+    type: inputValue.type,
+    defaultValue: inputValue.defaultValue,
+    deprecationReason: inputValue.deprecationReason,
+    extensions: inputValue.extensions,
+    astNode: inputValue.astNode,
+  };
+}
+
+export type GraphQLInputValue = {|
   name: string,
   description: ?string,
   type: GraphQLInputType,
@@ -999,13 +1008,14 @@ export type GraphQLArgument = {|
   astNode: ?InputValueDefinitionNode,
 |};
 
-export function isRequiredArgument(arg: GraphQLArgument): boolean %checks {
-  return isNonNullType(arg.type) && arg.defaultValue === undefined;
-}
-
-export type GraphQLFieldMap<TSource, TContext> = ObjMap<
-  GraphQLField<TSource, TContext>,
->;
+export type GraphQLInputValueConfig = {|
+  description?: ?string,
+  type: GraphQLInputType,
+  defaultValue?: mixed,
+  deprecationReason?: ?string,
+  extensions?: ?ReadOnlyObjMapLike<mixed>,
+  astNode?: ?InputValueDefinitionNode,
+|};
 
 /**
  * Interface Type Definition
@@ -1497,18 +1507,10 @@ export class GraphQLInputObjectType {
   }
 
   toConfig(): GraphQLInputObjectTypeNormalizedConfig {
-    const fields = mapValue(this.getFields(), (field) => ({
-      description: field.description,
-      type: field.type,
-      defaultValue: field.defaultValue,
-      extensions: field.extensions,
-      astNode: field.astNode,
-    }));
-
     return {
       name: this.name,
       description: this.description,
-      fields,
+      fields: mapValue(this.getFields(), inputValueToConfig),
       extensions: this.extensions,
       astNode: this.astNode,
       extensionASTNodes: this.extensionASTNodes,
@@ -1542,16 +1544,7 @@ function defineInputFieldMap(
       !('resolve' in fieldConfig),
       `${config.name}.${fieldName} field has a resolve property, but Input Types cannot define resolvers.`,
     );
-
-    return {
-      name: fieldName,
-      description: fieldConfig.description,
-      type: fieldConfig.type,
-      defaultValue: fieldConfig.defaultValue,
-      deprecationReason: fieldConfig.deprecationReason,
-      extensions: fieldConfig.extensions && toObjMap(fieldConfig.extensions),
-      astNode: fieldConfig.astNode,
-    };
+    return defineInputValue(fieldConfig, fieldName);
   });
 }
 
@@ -1571,26 +1564,11 @@ type GraphQLInputObjectTypeNormalizedConfig = {|
   extensionASTNodes: $ReadOnlyArray<InputObjectTypeExtensionNode>,
 |};
 
-export type GraphQLInputFieldConfig = {|
-  description?: ?string,
-  type: GraphQLInputType,
-  defaultValue?: mixed,
-  deprecationReason?: ?string,
-  extensions?: ?ReadOnlyObjMapLike<mixed>,
-  astNode?: ?InputValueDefinitionNode,
-|};
+export type GraphQLInputFieldConfig = GraphQLInputValueConfig;
 
 export type GraphQLInputFieldConfigMap = ObjMap<GraphQLInputFieldConfig>;
 
-export type GraphQLInputField = {|
-  name: string,
-  description: ?string,
-  type: GraphQLInputType,
-  defaultValue: mixed,
-  deprecationReason: ?string,
-  extensions: ?ReadOnlyObjMap<mixed>,
-  astNode: ?InputValueDefinitionNode,
-|};
+export type GraphQLInputField = GraphQLInputValue;
 
 export function isRequiredInputField(
   field: GraphQLInputField,