Preserve defaultValue literals

Fixes #3051

Author: leebyron

src/execution/values.js

@@ -17,6 +17,7 @@ import type { GraphQLSchema } from '../type/schema';
 import type { GraphQLField } from '../type/definition';
 import type { GraphQLDirective } from '../type/directives';
 import { isInputType, isNonNullType } from '../type/definition';
+import { getCoercedDefaultValue } from '../type/defaultValues';
 
 import { typeFromAST } from '../utilities/typeFromAST';
 import { valueFromAST } from '../utilities/valueFromAST';
@@ -173,8 +174,11 @@ export function getArgumentValues(
     const argumentNode = argNodeMap[name];
 
     if (!argumentNode) {
-      if (argDef.defaultValue !== undefined) {
-        coercedValues[name] = argDef.defaultValue;
+      if (argDef.defaultValue) {
+        coercedValues[name] = getCoercedDefaultValue(
+          argDef.defaultValue,
+          argDef.type,
+        );
       } else if (isNonNullType(argType)) {
         throw new GraphQLError(
           `Argument "${name}" of required type "${inspect(argType)}" ` +
@@ -194,8 +198,11 @@ export function getArgumentValues(
         variableValues == null ||
         !hasOwnProperty(variableValues, variableName)
       ) {
-        if (argDef.defaultValue !== undefined) {
-          coercedValues[name] = argDef.defaultValue;
+        if (argDef.defaultValue) {
+          coercedValues[name] = getCoercedDefaultValue(
+            argDef.defaultValue,
+            argDef.type,
+          );
         } else if (isNonNullType(argType)) {
           throw new GraphQLError(
             `Argument "${name}" of required type "${inspect(argType)}" ` +

src/index.d.ts

@@ -126,6 +126,9 @@ export {
   // Validate GraphQL schema.
   validateSchema,
   assertValidSchema,
+  // Operate on default values.
+  getCoercedDefaultValue,
+  getLiteralDefaultValue,
 } from './type/index';
 
 export {
@@ -150,6 +153,7 @@ export {
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,

src/index.js

@@ -125,6 +125,9 @@ export {
   // Validate GraphQL schema.
   validateSchema,
   assertValidSchema,
+  // Operate on default values.
+  getCoercedDefaultValue,
+  getLiteralDefaultValue,
 } from './type/index';
 
 export type {
@@ -146,6 +149,7 @@ export type {
   GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumValue,

src/type/__tests__/predicate-test.js

@@ -69,6 +69,7 @@ import {
   assertNamedType,
   getNullableType,
   getNamedType,
+  defineInputValue,
 } from '../definition';
 
 const ObjectType = new GraphQLObjectType({ name: 'Object', fields: {} });
@@ -562,19 +563,14 @@ describe('Type predicates', () => {
   });
 
   describe('isRequiredInput', () => {
-    function buildArg(config: {|
+    function buildArg({
+      type,
+      defaultValue,
+    }: {|
       type: GraphQLInputType,
       defaultValue?: mixed,
     |}): GraphQLArgument {
-      return {
-        name: 'someArg',
-        type: config.type,
-        description: undefined,
-        defaultValue: config.defaultValue,
-        deprecationReason: null,
-        extensions: undefined,
-        astNode: undefined,
-      };
+      return defineInputValue({ type, defaultValue }, 'someArg');
     }
 
     it('returns true for required arguments', () => {
@@ -608,19 +604,14 @@ describe('Type predicates', () => {
       expect(isRequiredInput(optArg4)).to.equal(false);
     });
 
-    function buildInputField(config: {|
+    function buildInputField({
+      type,
+      defaultValue,
+    }: {|
       type: GraphQLInputType,
       defaultValue?: mixed,
     |}): GraphQLInputField {
-      return {
-        name: 'someInputField',
-        type: config.type,
-        description: undefined,
-        defaultValue: config.defaultValue,
-        deprecationReason: null,
-        extensions: undefined,
-        astNode: undefined,
-      };
+      return defineInputValue({ type, defaultValue }, 'someInputField');
     }
 
     it('returns true for required input field', () => {

src/type/defaultValues.d.ts

@@ -0,0 +1,13 @@
+import { ConstValueNode } from '../language/ast';
+
+import { GraphQLInputType, GraphQLDefaultValueUsage } from './definition';
+
+export function getLiteralDefaultValue(
+  usage: GraphQLDefaultValueUsage,
+  type: GraphQLInputType,
+): ConstValueNode;
+
+export function getCoercedDefaultValue(
+  usage: GraphQLDefaultValueUsage,
+  type: GraphQLInputType,
+): unknown;

src/type/defaultValues.js

@@ -0,0 +1,29 @@
+import { invariant } from '../jsutils/invariant';
+import type { ConstValueNode } from '../language/ast';
+
+import { astFromValue } from '../utilities/astFromValue';
+import { valueFromAST } from '../utilities/valueFromAST';
+
+import type { GraphQLInputType, GraphQLDefaultValueUsage } from './definition';
+
+export function getLiteralDefaultValue(
+  usage: GraphQLDefaultValueUsage,
+  type: GraphQLInputType,
+): ConstValueNode {
+  if (!usage.literal) {
+    const literal = astFromValue(usage.value, type);
+    invariant(literal, 'Value cannot be converted to literal for this type');
+    usage.literal = literal;
+  }
+  return usage.literal;
+}
+
+export function getCoercedDefaultValue(
+  usage: GraphQLDefaultValueUsage,
+  type: GraphQLInputType,
+): mixed {
+  if (usage.value === undefined) {
+    usage.value = valueFromAST(usage.literal, type);
+  }
+  return usage.value;
+}

src/type/definition.d.ts

@@ -23,6 +23,7 @@ import {
   FieldNode,
   FragmentDefinitionNode,
   ValueNode,
+  ConstValueNode,
   ScalarTypeExtensionNode,
   UnionTypeExtensionNode,
   EnumTypeExtensionNode,
@@ -575,12 +576,17 @@ export interface GraphQLInputValue<Extensions> {
   name: string;
   description: Maybe<string>;
   type: GraphQLInputType;
-  defaultValue: unknown;
+  defaultValue: Maybe<GraphQLDefaultValueUsage>;
   deprecationReason: Maybe<string>;
   extensions: Maybe<Readonly<Extensions>>;
   astNode: Maybe<InputValueDefinitionNode>;
 }
 
+export interface GraphQLDefaultValueUsage {
+  value: unknown;
+  literal: Maybe<ConstValueNode>;
+}
+
 export interface GraphQLInputValueConfig<Extensions> {
   description?: Maybe<string>;
   type: GraphQLInputType;

src/type/definition.js

@@ -41,6 +41,7 @@ import type {
   FieldNode,
   FragmentDefinitionNode,
   ValueNode,
+  ConstValueNode,
 } from '../language/ast';
 
 import { valueFromASTUntyped } from '../utilities/valueFromASTUntyped';
@@ -971,11 +972,18 @@ export function defineInputValue(
     !('resolve' in config),
     `${name} has a resolve property, but inputs cannot define resolvers.`,
   );
+  let defaultValue;
+  if (config.defaultValue !== undefined || config.defaultValueLiteral) {
+    defaultValue = {
+      value: config.defaultValue,
+      literal: config.defaultValueLiteral,
+    };
+  }
   return {
     name,
     description: config.description,
     type: config.type,
-    defaultValue: config.defaultValue,
+    defaultValue,
     deprecationReason: config.deprecationReason,
     extensions: config.extensions && toObjMap(config.extensions),
     astNode: config.astNode,
@@ -991,7 +999,8 @@ export function inputValueToConfig(
   return {
     description: inputValue.description,
     type: inputValue.type,
-    defaultValue: inputValue.defaultValue,
+    defaultValue: inputValue.defaultValue?.value,
+    defaultValueLiteral: inputValue.defaultValue?.literal,
     deprecationReason: inputValue.deprecationReason,
     extensions: inputValue.extensions,
     astNode: inputValue.astNode,
@@ -1002,16 +1011,22 @@ export type GraphQLInputValue = {|
   name: string,
   description: ?string,
   type: GraphQLInputType,
-  defaultValue: mixed,
+  defaultValue: ?GraphQLDefaultValueUsage,
   deprecationReason: ?string,
   extensions: ?ReadOnlyObjMap<mixed>,
   astNode: ?InputValueDefinitionNode,
 |};
 
+export type GraphQLDefaultValueUsage = {|
+  value: mixed,
+  literal: ?ConstValueNode,
+|};
+
 export type GraphQLInputValueConfig = {|
   description?: ?string,
   type: GraphQLInputType,
   defaultValue?: mixed,
+  defaultValueLiteral?: ?ConstValueNode,
   deprecationReason?: ?string,
   extensions?: ?ReadOnlyObjMapLike<mixed>,
   astNode?: ?InputValueDefinitionNode,

src/type/index.d.ts

@@ -82,6 +82,7 @@ export {
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,
@@ -117,6 +118,11 @@ export {
   GraphQLScalarLiteralParser,
 } from './definition';
 
+export {
+  getCoercedDefaultValue,
+  getLiteralDefaultValue,
+} from './defaultValues';
+
 export {
   // Predicate
   isDirective,

src/type/index.js

@@ -136,6 +136,7 @@ export type {
   GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumValue,
@@ -162,5 +163,10 @@ export type {
   GraphQLScalarLiteralParser,
 } from './definition';
 
+export {
+  getCoercedDefaultValue,
+  getLiteralDefaultValue,
+} from './defaultValues';
+
 // Validate GraphQL schema.
 export { validateSchema, assertValidSchema } from './validate';