Update @specified directive implementation

docs/APIReference-TypeSystem.md

@@ -209,6 +209,7 @@ type GraphQLScalarTypeConfig<InternalType> = {
   serialize: (value: mixed) => ?InternalType;
   parseValue?: (value: mixed) => ?InternalType;
   parseLiteral?: (valueAST: Value) => ?InternalType;
+  specifiedBy?: string;
 }
 ```
 

src/type/__tests__/definition-test.js

@@ -44,6 +44,16 @@ describe('Type System: Scalars', () => {
     expect(() => new GraphQLScalarType({ name: 'SomeScalar' })).not.to.throw();
   });
 
+  it('accepts a Scalar type defining specifiedBy', () => {
+    expect(
+      () =>
+        new GraphQLScalarType({
+          name: 'SomeScalar',
+          specifiedBy: 'https://tools.ietf.org/html/rfc4122',
+        }),
+    ).not.to.throw();
+  });
+
   it('accepts a Scalar type defining parseValue and parseLiteral', () => {
     expect(
       () =>
@@ -118,6 +128,19 @@ describe('Type System: Scalars', () => {
       'SomeScalar must provide both "parseValue" and "parseLiteral" functions.',
     );
   });
+
+  it('rejects a Scalar type defining specifiedBy with an incorrect type', () => {
+    expect(
+      () =>
+        new GraphQLScalarType({
+          name: 'SomeScalar',
+          // $DisableFlowOnNegativeTest
+          specifiedBy: {},
+        }),
+    ).to.throw(
+      'SomeScalar must provide "specifiedBy" as a string, but got: {}.',
+    );
+  });
 });
 
 describe('Type System: Objects', () => {

src/type/definition.d.ts

@@ -291,6 +291,7 @@ export class GraphQLScalarType {
   extensions: Maybe<Readonly<Record<string, any>>>;
   astNode: Maybe<ScalarTypeDefinitionNode>;
   extensionASTNodes: Maybe<ReadonlyArray<ScalarTypeExtensionNode>>;
+  specifiedBy?: Maybe<string>;
 
   constructor(config: GraphQLScalarTypeConfig<any, any>);
 
@@ -300,6 +301,7 @@ export class GraphQLScalarType {
     parseLiteral: GraphQLScalarLiteralParser<any>;
     extensions: Maybe<Readonly<Record<string, any>>>;
     extensionASTNodes: ReadonlyArray<ScalarTypeExtensionNode>;
+    specifiedBy: Maybe<string>;
   };
 
   toString(): string;
@@ -330,6 +332,7 @@ export interface GraphQLScalarTypeConfig<TInternal, TExternal> {
   extensions?: Maybe<Readonly<Record<string, any>>>;
   astNode?: Maybe<ScalarTypeDefinitionNode>;
   extensionASTNodes?: Maybe<ReadonlyArray<ScalarTypeExtensionNode>>;
+  specifiedBy?: Maybe<string>;
 }
 
 /**
@@ -409,7 +412,6 @@ export interface GraphQLObjectTypeConfig<
 > {
   name: string;
   description?: Maybe<string>;
-  specifiedBy?: string;
   interfaces?: Thunk<Maybe<GraphQLInterfaceType[]>>;
   fields: Thunk<GraphQLFieldConfigMap<TSource, TContext, TArgs>>;
   isTypeOf?: Maybe<GraphQLIsTypeOfFn<TSource, TContext>>;

src/type/definition.js

@@ -552,6 +552,7 @@ export class GraphQLScalarType {
   extensions: ?ReadOnlyObjMap<mixed>;
   astNode: ?ScalarTypeDefinitionNode;
   extensionASTNodes: ?$ReadOnlyArray<ScalarTypeExtensionNode>;
+  specifiedBy: ?string;
 
   constructor(config: GraphQLScalarTypeConfig<*, *>): void {
     const parseValue = config.parseValue || identityFunc;
@@ -564,6 +565,7 @@ export class GraphQLScalarType {
     this.extensions = config.extensions && toObjMap(config.extensions);
     this.astNode = config.astNode;
     this.extensionASTNodes = undefineIfEmpty(config.extensionASTNodes);
+    this.specifiedBy = config.specifiedBy;
 
     devAssert(typeof config.name === 'string', 'Must provide name.');
     devAssert(
@@ -578,6 +580,14 @@ export class GraphQLScalarType {
         `${this.name} must provide both "parseValue" and "parseLiteral" functions.`,
       );
     }
+
+    if (config.specifiedBy) {
+      devAssert(
+        typeof config.specifiedBy === 'string',
+        `${this.name} must provide "specifiedBy" as a string, ` +
+          `but got: ${inspect(config.specifiedBy)}.`,
+      );
+    }
   }
 
   toConfig(): {|
@@ -587,6 +597,7 @@ export class GraphQLScalarType {
     parseLiteral: GraphQLScalarLiteralParser<*>,
     extensions: ?ReadOnlyObjMap<mixed>,
     extensionASTNodes: ?$ReadOnlyArray<ScalarTypeExtensionNode>,
+    specifiedBy: ?string,
   |} {
     return {
       name: this.name,
@@ -597,6 +608,7 @@ export class GraphQLScalarType {
       extensions: this.extensions,
       astNode: this.astNode,
       extensionASTNodes: this.extensionASTNodes,
+      specifiedBy: this.specifiedBy,
     };
   }
 

src/type/introspection.js

@@ -8,10 +8,9 @@ import invariant from '../jsutils/invariant';
 import { print } from '../language/printer';
 import { DirectiveLocation } from '../language/directiveLocation';
 import { astFromValue } from '../utilities/astFromValue';
-import { getDirectiveValues } from '../execution/values';
 
 import { type GraphQLSchema } from './schema';
-import { type GraphQLDirective, GraphQLSpecifiedDirective } from './directives';
+import { type GraphQLDirective } from './directives';
 import { GraphQLString, GraphQLBoolean } from './scalars';
 import {
   type GraphQLType,
@@ -224,17 +223,8 @@ export const __Type = new GraphQLObjectType({
       },
       specifiedBy: {
         type: GraphQLString,
-        resolve: type => {
-          if (!isScalarType(type) || !type.astNode) {
-            return null;
-          }
-
-          const specified = getDirectiveValues(
-            GraphQLSpecifiedDirective,
-            type.astNode,
-          );
-          return specified && specified.by;
-        },
+        resolve: obj =>
+          obj.specifiedBy !== undefined ? obj.specifiedBy : undefined,
       },
       fields: {
         type: GraphQLList(GraphQLNonNull(__Field)),

src/utilities/__tests__/buildASTSchema-test.js

@@ -746,6 +746,25 @@ describe('Schema Builder', () => {
     });
   });
 
+  it('Supports @specified', () => {
+    const sdl = dedent`
+      type Query {
+        someUUID: UUID @deprecated
+      }
+
+      scalar UUID @specified(by: "https://tools.ietf.org/html/rfc4122")
+    `;
+    expect(cycleSDL(sdl)).to.equal(sdl);
+
+    const schema = buildSchema(sdl);
+
+    const uuid = assertScalarType(schema.getType('UUID'));
+
+    expect(uuid).to.include({
+      specifiedBy: 'https://tools.ietf.org/html/rfc4122',
+    });
+  });
+
   it('Correctly assign AST nodes', () => {
     const sdl = dedent`
       schema {

src/utilities/__tests__/buildClientSchema-test.js

@@ -530,6 +530,18 @@ describe('Type System: build schema from introspection', () => {
     expect(cycleIntrospection(sdl)).to.equal(sdl);
   });
 
+  it('builds a schema with specified by', () => {
+    const sdl = dedent`
+      type Query {
+        someUUID: UUID
+      }
+
+      scalar UUID @specified(by: "https://tools.ietf.org/html/rfc4122")
+    `;
+
+    expect(cycleIntrospection(sdl)).to.equal(sdl);
+  });
+
   it('can use client schema for limited execution', () => {
     const schema = buildSchema(`
       scalar CustomScalar

src/utilities/buildASTSchema.js

@@ -446,6 +446,7 @@ export class ASTDefinitionBuilder {
           name,
           description,
           astNode,
+          specifiedBy: getSpecifiedBy(astNode),
         });
       case Kind.INPUT_OBJECT_TYPE_DEFINITION:
         return new GraphQLInputObjectType({
@@ -475,6 +476,14 @@ function getDeprecationReason(
   return deprecated && (deprecated.reason: any);
 }
 
+/**
+ * Given a scalar node, returns the string value for specifiedBy string.
+ */
+function getSpecifiedBy(node: ScalarTypeDefinitionNode): ?string {
+  const specified = getDirectiveValues(GraphQLSpecifiedDirective, node);
+  return specified && (specified.by: any);
+}
+
 /**
  * Given an ast node, returns its string description.
  * @deprecated: provided to ease adoption and will be removed in v16.

src/utilities/buildClientSchema.js

@@ -229,6 +229,7 @@ export function buildClientSchema(
     return new GraphQLScalarType({
       name: scalarIntrospection.name,
       description: scalarIntrospection.description,
+      specifiedBy: scalarIntrospection.specifiedBy,
     });
   }
 

src/utilities/getIntrospectionQuery.d.ts

@@ -49,6 +49,7 @@ export interface IntrospectionScalarType {
   readonly kind: 'SCALAR';
   readonly name: string;
   readonly description?: Maybe<string>;
+  readonly specifiedBy?: Maybe<string>;
 }
 
 export interface IntrospectionObjectType {

src/utilities/getIntrospectionQuery.js

@@ -142,6 +142,7 @@ export type IntrospectionScalarType = {|
   +kind: 'SCALAR',
   +name: string,
   +description?: ?string,
+  +specifiedBy: ?string,
 |};
 
 export type IntrospectionObjectType = {|

src/utilities/schemaPrinter.js

@@ -177,7 +177,11 @@ export function printType(type: GraphQLNamedType, options?: Options): string {
 }
 
 function printScalar(type: GraphQLScalarType, options): string {
-  return printDescription(options, type) + `scalar ${type.name}`;
+  return (
+    printDescription(options, type) +
+    `scalar ${type.name}` +
+    printSpecifiedBy(type)
+  );
 }
 
 function printImplementedInterfaces(
@@ -317,6 +321,15 @@ function printDeprecated(fieldOrEnumVal) {
   return ' @deprecated';
 }
 
+function printSpecifiedBy(scalar) {
+  if (!scalar.specifiedBy) {
+    return '';
+  }
+  const by = scalar.specifiedBy;
+  const byAST = astFromValue(by, GraphQLString);
+  return ' @specified(by: ' + print(byAST) + ')';
+}
+
 function printDescription(
   options,
   def,