Preserve defaultValue literals

Fixes #3051
graphql · May 15, 2021 · 5686d3e · 5686d3e
1 parent 5e2b6d5
commit 5686d3e
Show file tree

Hide file tree

Showing 25 changed files with 275 additions and 81 deletions.
diff --git a/src/execution/values.js b/src/execution/values.js
@@ -22,6 +22,7 @@ import { typeFromAST } from '../utilities/typeFromAST';
 import {
   coerceInputValue,
   coerceInputLiteral,
+  coerceDefaultValue,
 } from '../utilities/coerceInputValue';
 
 type CoercedVariableValues =
@@ -178,8 +179,11 @@ export function getArgumentValues(
     const argumentNode = argNodeMap[name];
 
     if (!argumentNode) {
-      if (argDef.defaultValue !== undefined) {
-        coercedValues[name] = argDef.defaultValue;
+      if (argDef.defaultValue) {
+        coercedValues[name] = coerceDefaultValue(
+          argDef.defaultValue,
+          argDef.type,
+        );
       } else if (isNonNullType(argType)) {
         throw new GraphQLError(
           `Argument "${name}" of required type "${inspect(argType)}" ` +
@@ -199,8 +203,11 @@ export function getArgumentValues(
         variableValues == null ||
         !hasOwnProperty(variableValues, variableName)
       ) {
-        if (argDef.defaultValue !== undefined) {
-          coercedValues[name] = argDef.defaultValue;
+        if (argDef.defaultValue) {
+          coercedValues[name] = coerceDefaultValue(
+            argDef.defaultValue,
+            argDef.type,
+          );
         } else if (isNonNullType(argType)) {
           throw new GraphQLError(
             `Argument "${name}" of required type "${inspect(argType)}" ` +

diff --git a/src/index.d.ts b/src/index.d.ts
@@ -150,6 +150,7 @@ export {
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,

diff --git a/src/index.js b/src/index.js
@@ -146,6 +146,7 @@ export type {
   GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumValue,

diff --git a/src/type/__tests__/definition-test.js b/src/type/__tests__/definition-test.js
@@ -818,6 +818,67 @@ describe('Type System: Input Objects', () => {
       );
     });
   });
+
+  describe('Input Object fields may have default values', () => {
+    it('accepts an Input Object type with a default value', () => {
+      const inputObjType = new GraphQLInputObjectType({
+        name: 'SomeInputObject',
+        fields: {
+          f: { type: ScalarType, defaultValue: 3 },
+        },
+      });
+      expect(inputObjType.getFields()).to.deep.equal({
+        f: {
+          name: 'f',
+          description: undefined,
+          type: ScalarType,
+          defaultValue: { value: 3 },
+          deprecationReason: undefined,
+          extensions: undefined,
+          astNode: undefined,
+        },
+      });
+    });
+
+    it('accepts an Input Object type with a default value literal', () => {
+      const inputObjType = new GraphQLInputObjectType({
+        name: 'SomeInputObject',
+        fields: {
+          f: {
+            type: ScalarType,
+            defaultValueLiteral: { kind: 'IntValue', value: '3' },
+          },
+        },
+      });
+      expect(inputObjType.getFields()).to.deep.equal({
+        f: {
+          name: 'f',
+          description: undefined,
+          type: ScalarType,
+          defaultValue: { literal: { kind: 'IntValue', value: '3' } },
+          deprecationReason: undefined,
+          extensions: undefined,
+          astNode: undefined,
+        },
+      });
+    });
+
+    it('rejects an Input Object type with potentially conflicting default values', () => {
+      const inputObjType = new GraphQLInputObjectType({
+        name: 'SomeInputObject',
+        fields: {
+          f: {
+            type: ScalarType,
+            defaultValue: 3,
+            defaultValueLiteral: { kind: 'IntValue', value: '3' },
+          },
+        },
+      });
+      expect(() => inputObjType.getFields()).to.throw(
+        'f has both a defaultValue and a defaultValueLiteral property, but only one must be provided.',
+      );
+    });
+  });
 });
 
 describe('Type System: List', () => {

diff --git a/src/type/__tests__/predicate-test.js b/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', () => {

diff --git a/src/type/definition.d.ts b/src/type/definition.d.ts
@@ -23,6 +23,7 @@ import {
   FieldNode,
   FragmentDefinitionNode,
   ValueNode,
+  ConstValueNode,
   ScalarTypeExtensionNode,
   UnionTypeExtensionNode,
   EnumTypeExtensionNode,
@@ -575,12 +576,16 @@ 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 type GraphQLDefaultValueUsage =
+  | { value: unknown; literal?: never }
+  | { literal: ConstValueNode; value?: never };
+
 export interface GraphQLInputValueConfig<Extensions> {
   description?: Maybe<string>;
   type: GraphQLInputType;

diff --git a/src/type/definition.js b/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,21 @@ export function defineInputValue(
     !('resolve' in config),
     `${name} has a resolve property, but inputs cannot define resolvers.`,
   );
+  let defaultValue;
+  if (config.defaultValue !== undefined || config.defaultValueLiteral) {
+    devAssert(
+      config.defaultValue === undefined || !config.defaultValueLiteral,
+      `${name} has both a defaultValue and a defaultValueLiteral property, but only one must be provided.`,
+    );
+    defaultValue = config.defaultValueLiteral
+      ? { literal: config.defaultValueLiteral }
+      : { value: config.defaultValue };
+  }
   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 +1002,12 @@ export function inputValueToConfig(
   return {
     description: inputValue.description,
     type: inputValue.type,
-    defaultValue: inputValue.defaultValue,
+    defaultValue: inputValue.defaultValue?.literal
+      ? undefined
+      : inputValue.defaultValue?.value,
+    defaultValueLiteral: inputValue.defaultValue?.literal
+      ? inputValue.defaultValue.literal
+      : undefined,
     deprecationReason: inputValue.deprecationReason,
     extensions: inputValue.extensions,
     astNode: inputValue.astNode,
@@ -1002,16 +1018,21 @@ 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,

diff --git a/src/type/index.d.ts b/src/type/index.d.ts
@@ -82,6 +82,7 @@ export {
   GraphQLArgumentConfig,
   GraphQLArgumentExtensions,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumTypeExtensions,

diff --git a/src/type/index.js b/src/type/index.js
@@ -136,6 +136,7 @@ export type {
   GraphQLArgument,
   GraphQLArgumentConfig,
   GraphQLInputValue,
+  GraphQLDefaultValueUsage,
   GraphQLInputValueConfig,
   GraphQLEnumTypeConfig,
   GraphQLEnumValue,

diff --git a/src/type/introspection.js b/src/type/introspection.js
@@ -384,8 +384,14 @@ export const __InputValue: GraphQLObjectType = new GraphQLObjectType({
           'A GraphQL-formatted string representing the default value for this input value.',
         resolve(inputValue) {
           const { type, defaultValue } = inputValue;
-          const valueAST = astFromValue(defaultValue, type);
-          return valueAST ? print(valueAST) : null;
+          if (!defaultValue) {
+            return null;
+          }
+          const literal = defaultValue.literal
+            ? defaultValue.literal
+            : astFromValue(defaultValue.value, type);
+          invariant(literal, 'Invalid default value');
+          return print(literal);
         },
       },
       isDeprecated: {

diff --git a/src/utilities/TypeInfo.d.ts b/src/utilities/TypeInfo.d.ts
@@ -12,6 +12,7 @@ import {
   GraphQLField,
   GraphQLArgument,
   GraphQLEnumValue,
+  GraphQLDefaultValueUsage,
 } from '../type/definition';
 
 /**
@@ -35,7 +36,7 @@ export class TypeInfo {
   getInputType(): Maybe<GraphQLInputType>;
   getParentInputType(): Maybe<GraphQLInputType>;
   getFieldDef(): Maybe<GraphQLField<unknown, unknown>>;
-  getDefaultValue(): Maybe<unknown>;
+  getDefaultValue(): Maybe<GraphQLDefaultValueUsage>;
   getDirective(): Maybe<GraphQLDirective>;
   getArgument(): Maybe<GraphQLArgument>;
   getEnumValue(): Maybe<GraphQLEnumValue>;

diff --git a/src/utilities/TypeInfo.js b/src/utilities/TypeInfo.js
@@ -15,6 +15,7 @@ import type {
   GraphQLArgument,
   GraphQLInputField,
   GraphQLEnumValue,
+  GraphQLDefaultValueUsage,
 } from '../type/definition';
 import {
   isObjectType,
@@ -47,7 +48,7 @@ export class TypeInfo {
   _parentTypeStack: Array<?GraphQLCompositeType>;
   _inputTypeStack: Array<?GraphQLInputType>;
   _fieldDefStack: Array<?GraphQLField<mixed, mixed>>;
-  _defaultValueStack: Array<?mixed>;
+  _defaultValueStack: Array<?GraphQLDefaultValueUsage>;
   _directive: ?GraphQLDirective;
   _argument: ?GraphQLArgument;
   _enumValue: ?GraphQLEnumValue;
@@ -115,7 +116,7 @@ export class TypeInfo {
     }
   }
 
-  getDefaultValue(): ?mixed {
+  getDefaultValue(): ?GraphQLDefaultValueUsage {
     if (this._defaultValueStack.length > 0) {
       return this._defaultValueStack[this._defaultValueStack.length - 1];
     }
@@ -209,7 +210,7 @@ export class TypeInfo {
           }
         }
         this._argument = argDef;
-        this._defaultValueStack.push(argDef ? argDef.defaultValue : undefined);
+        this._defaultValueStack.push(argDef?.defaultValue);
         this._inputTypeStack.push(isInputType(argType) ? argType : undefined);
         break;
       }
@@ -233,9 +234,7 @@ export class TypeInfo {
             inputFieldType = inputField.type;
           }
         }
-        this._defaultValueStack.push(
-          inputField ? inputField.defaultValue : undefined,
-        );
+        this._defaultValueStack.push(inputField?.defaultValue);
         this._inputTypeStack.push(
           isInputType(inputFieldType) ? inputFieldType : undefined,
         );

diff --git a/src/utilities/__tests__/astFromValue-test.js b/src/utilities/__tests__/astFromValue-test.js
@@ -51,6 +51,8 @@ describe('astFromValue', () => {
       kind: 'BooleanValue',
       value: false,
     });
+
+    expect(astFromValue(null, NonNullBoolean)).to.equal(null);
   });
 
   it('converts Int values to Int ASTs', () => {