Introspection related changes

BoD · BoD · commit 519cd493c4b0 · 2026-01-06T18:23:16.000+01:00
diff --git a/src/type/__tests__/directive-test.ts b/src/type/__tests__/directive-test.ts
@@ -73,6 +73,22 @@ describe('Type System: Directive', () => {
     });
   });
 
+  it('defines a deprecated directive', () => {
+    const directive = new GraphQLDirective({
+      name: 'Foo',
+      locations: [DirectiveLocation.QUERY],
+      deprecationReason: 'Some reason',
+    });
+
+    expect(directive).to.deep.include({
+      name: 'Foo',
+      args: [],
+      isRepeatable: false,
+      locations: ['QUERY'],
+      deprecationReason: 'Some reason',
+    });
+  });
+
   it('can be stringified, JSON.stringified and Object.toStringified', () => {
     const directive = new GraphQLDirective({
       name: 'Foo',
diff --git a/src/type/__tests__/introspection-test.ts b/src/type/__tests__/introspection-test.ts
@@ -156,7 +156,17 @@ describe('Introspection', () => {
                 },
                 {
                   name: 'directives',
-                  args: [],
+                  args: [
+                    {
+                      name: 'includeDeprecated',
+                      type: {
+                        kind: 'SCALAR',
+                        name: 'Boolean',
+                        ofType: null,
+                      },
+                      defaultValue: 'false',
+                    },
+                  ],
                   type: {
                     kind: 'NON_NULL',
                     name: null,
@@ -805,6 +815,32 @@ describe('Introspection', () => {
                   isDeprecated: false,
                   deprecationReason: null,
                 },
+                {
+                  name: 'isDeprecated',
+                  args: [],
+                  type: {
+                    kind: 'NON_NULL',
+                    name: null,
+                    ofType: {
+                      kind: 'SCALAR',
+                      name: 'Boolean',
+                      ofType: null,
+                    },
+                  },
+                  isDeprecated: false,
+                  deprecationReason: null,
+                },
+                {
+                  name: 'deprecationReason',
+                  args: [],
+                  type: {
+                    kind: 'SCALAR',
+                    name: 'String',
+                    ofType: null,
+                  },
+                  isDeprecated: false,
+                  deprecationReason: null,
+                },
               ],
               inputFields: null,
               interfaces: [],
@@ -1760,4 +1796,70 @@ describe('Introspection', () => {
     });
     expect(result).to.not.have.property('errors');
   });
+
+  it('identifies deprecated directives', () => {
+    const schema = buildSchema(`
+      type Query {
+        someField: String
+      }
+      directive @isNotDeprecated on FIELD_DEFINITION
+      directive @isDeprecated @deprecated(reason: "No longer supported") on FIELD_DEFINITION
+    `);
+
+    const source = `
+      {
+        __schema {
+          directives(includeDeprecated: true) {
+            name
+            isDeprecated
+            deprecationReason
+          }
+        }
+      }
+    `;
+
+    expect(graphqlSync({ schema, source })).to.deep.equal({
+      data: {
+        __schema: {
+          directives: [
+            {
+              name: 'isNotDeprecated',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+            {
+              name: 'isDeprecated',
+              isDeprecated: true,
+              deprecationReason: 'No longer supported',
+            },
+            {
+              name: 'include',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+            {
+              name: 'skip',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+            {
+              name: 'deprecated',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+            {
+              name: 'specifiedBy',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+            {
+              name: 'oneOf',
+              isDeprecated: false,
+              deprecationReason: null,
+            },
+          ],
+        },
+      },
+    });
+  });
 });
diff --git a/src/type/directives.ts b/src/type/directives.ts
@@ -5,7 +5,10 @@ import { isObjectLike } from '../jsutils/isObjectLike';
 import type { Maybe } from '../jsutils/Maybe';
 import { toObjMap } from '../jsutils/toObjMap';
 
-import type { DirectiveDefinitionNode } from '../language/ast';
+import type {
+  DirectiveDefinitionNode,
+  DirectiveExtensionNode,
+} from '../language/ast';
 import { DirectiveLocation } from '../language/directiveLocation';
 
 import { assertName } from './assertName';
@@ -62,6 +65,7 @@ export class GraphQLDirective {
   deprecationReason: Maybe<string>;
   extensions: Readonly<GraphQLDirectiveExtensions>;
   astNode: Maybe<DirectiveDefinitionNode>;
+  extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
 
   constructor(config: Readonly<GraphQLDirectiveConfig>) {
     this.name = assertName(config.name);
@@ -71,6 +75,7 @@ export class GraphQLDirective {
     this.deprecationReason = config.deprecationReason;
     this.extensions = toObjMap(config.extensions);
     this.astNode = config.astNode;
+    this.extensionASTNodes = config.extensionASTNodes ?? [];
 
     devAssert(
       Array.isArray(config.locations),
@@ -100,6 +105,7 @@ export class GraphQLDirective {
       deprecationReason: this.deprecationReason,
       extensions: this.extensions,
       astNode: this.astNode,
+      extensionASTNodes: this.extensionASTNodes,
     };
   }
 
@@ -121,12 +127,14 @@ export interface GraphQLDirectiveConfig {
   deprecationReason?: Maybe<string>;
   extensions?: Maybe<Readonly<GraphQLDirectiveExtensions>>;
   astNode?: Maybe<DirectiveDefinitionNode>;
+  extensionASTNodes?: Maybe<ReadonlyArray<DirectiveExtensionNode>>;
 }
 
 interface GraphQLDirectiveNormalizedConfig extends GraphQLDirectiveConfig {
   args: GraphQLFieldConfigArgumentMap;
   isRepeatable: boolean;
   extensions: Readonly<GraphQLDirectiveExtensions>;
+  extensionASTNodes: ReadonlyArray<DirectiveExtensionNode>;
 }
 
 /**
diff --git a/src/type/introspection.ts b/src/type/introspection.ts
@@ -72,7 +72,15 @@ export const __Schema: GraphQLObjectType = new GraphQLObjectType({
         type: new GraphQLNonNull(
           new GraphQLList(new GraphQLNonNull(__Directive)),
         ),
-        resolve: (schema) => schema.getDirectives(),
+        args: {
+          includeDeprecated: { type: GraphQLBoolean, defaultValue: false },
+        },
+        resolve: (schema, { includeDeprecated }) =>
+          includeDeprecated
+            ? schema.getDirectives()
+            : schema
+                .getDirectives()
+                .filter((directive) => directive.deprecationReason == null),
       },
     } as GraphQLFieldConfigMap<GraphQLSchema, unknown>),
 });
@@ -117,6 +125,14 @@ export const __Directive: GraphQLObjectType = new GraphQLObjectType({
             : field.args.filter((arg) => arg.deprecationReason == null);
         },
       },
+      isDeprecated: {
+        type: new GraphQLNonNull(GraphQLBoolean),
+        resolve: (directive) => directive.deprecationReason != null,
+      },
+      deprecationReason: {
+        type: GraphQLString,
+        resolve: (directive) => directive.deprecationReason,
+      },
     } as GraphQLFieldConfigMap<GraphQLDirective, unknown>),
 });
 
diff --git a/src/utilities/__tests__/extendSchema-test.ts b/src/utilities/__tests__/extendSchema-test.ts
@@ -1318,5 +1318,20 @@ describe('extendSchema', () => {
         extend schema @foo
       `);
     });
+
+    it('extend directive to make it deprecated', () => {
+      const schema = buildSchema('directive @isDeprecated on FIELD_DEFINITION');
+      const extendAST = parse(`
+        extend directive @isDeprecated @deprecated(reason: "use another directive")
+      `);
+      const extendedSchema = extendSchema(schema, extendAST);
+
+      const someDirective = assertDirective(
+        extendedSchema.getDirective('isDeprecated'),
+      );
+      expect(someDirective).to.include({
+        deprecationReason: 'use another directive',
+      });
+    });
   });
 });
diff --git a/src/utilities/__tests__/printSchema-test.ts b/src/utilities/__tests__/printSchema-test.ts
@@ -717,7 +717,7 @@ describe('Type System Printer', () => {
         subscriptionType: __Type
 
         """A list of all directives supported by this server."""
-        directives: [__Directive!]!
+        directives(includeDeprecated: Boolean = false): [__Directive!]!
       }
 
       """
@@ -821,6 +821,8 @@ describe('Type System Printer', () => {
         isRepeatable: Boolean!
         locations: [__DirectiveLocation!]!
         args(includeDeprecated: Boolean = false): [__InputValue!]!
+        isDeprecated: Boolean!
+        deprecationReason: String
       }
 
       """
diff --git a/src/utilities/extendSchema.ts b/src/utilities/extendSchema.ts
@@ -7,6 +7,7 @@ import type { Maybe } from '../jsutils/Maybe';
 
 import type {
   DirectiveDefinitionNode,
+  DirectiveExtensionNode,
   DocumentNode,
   EnumTypeDefinitionNode,
   EnumTypeExtensionNode,
@@ -138,6 +139,7 @@ export function extendSchemaImpl(
   // Collect the type definitions and extensions found in the document.
   const typeDefs: Array<TypeDefinitionNode> = [];
   const typeExtensionsMap = Object.create(null);
+  const directiveExtensionsMap = Object.create(null);
 
   // New directives and types are separate because a directives and types can
   // have the same name. For example, a type named "skip".
@@ -162,6 +164,14 @@ export function extendSchemaImpl(
         : [def];
     } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
       directiveDefs.push(def);
+    } else if (def.kind === Kind.DIRECTIVE_EXTENSION) {
+      const extendedDirectiveName = def.name.value;
+      const existingDirectiveExtensions =
+        directiveExtensionsMap[extendedDirectiveName];
+      directiveExtensionsMap[extendedDirectiveName] =
+        existingDirectiveExtensions
+          ? existingDirectiveExtensions.concat([def])
+          : [def];
     }
   }
 
@@ -170,6 +180,7 @@ export function extendSchemaImpl(
   if (
     Object.keys(typeExtensionsMap).length === 0 &&
     typeDefs.length === 0 &&
+    Object.keys(directiveExtensionsMap).length === 0 &&
     directiveDefs.length === 0 &&
     schemaExtensions.length === 0 &&
     schemaDef == null
@@ -187,6 +198,11 @@ export function extendSchemaImpl(
     typeMap[name] = stdTypeMap[name] ?? buildType(typeNode);
   }
 
+  const directiveMap = Object.create(null);
+  for (const existingDirective of schemaConfig.directives) {
+    directiveMap[existingDirective.name] = extendDirective(existingDirective);
+  }
+
   const operationTypes = {
     // Get the extended root operation types.
     query: schemaConfig.query && replaceNamedType(schemaConfig.query),
@@ -199,12 +215,13 @@ export function extendSchemaImpl(
   };
 
   // Then produce and return a Schema config with these types.
+  const directives: Array<GraphQLDirective> = Object.values(directiveMap);
   return {
     description: schemaDef?.description?.value,
     ...operationTypes,
     types: Object.values(typeMap),
     directives: [
-      ...schemaConfig.directives.map(replaceDirective),
+      ...directives.map(replaceDirective),
       ...directiveDefs.map(buildDirective),
     ],
     extensions: Object.create(null),
@@ -415,6 +432,20 @@ export function extendSchemaImpl(
     return opTypes;
   }
 
+  function extendDirective(directive: GraphQLDirective): GraphQLDirective {
+    const config = directive.toConfig();
+    const extensions = directiveExtensionsMap[config.name] ?? [];
+    const deprecatedReason = extensions
+      .map((ext: DirectiveExtensionNode) => getDeprecationReason(ext))
+      .find((reason: Maybe<string>) => reason != null);
+
+    return new GraphQLDirective({
+      ...config,
+      deprecationReason: deprecatedReason,
+      extensionASTNodes: config.extensionASTNodes.concat(extensions),
+    });
+  }
+
   function getNamedType(node: NamedTypeNode): GraphQLNamedType {
     const name = node.name.value;
     const type = stdTypeMap[name] ?? typeMap[name];
@@ -443,6 +474,7 @@ export function extendSchemaImpl(
       locations: node.locations.map(({ value }) => value),
       isRepeatable: node.repeatable,
       args: buildArgumentMap(node.arguments),
+      deprecationReason: getDeprecationReason(node),
       astNode: node,
     });
   }
@@ -667,7 +699,9 @@ function getDeprecationReason(
   node:
     | EnumValueDefinitionNode
     | FieldDefinitionNode
-    | InputValueDefinitionNode,
+    | InputValueDefinitionNode
+    | DirectiveDefinitionNode
+    | DirectiveExtensionNode,
 ): Maybe<string> {
   const deprecated = getDirectiveValues(GraphQLDeprecatedDirective, node);
   // @ts-expect-error validated by `getDirectiveValues`

Original file line number	Diff line number	Diff line change
`@@ -717,7 +717,7 @@ describe('Type System Printer', () => {`
`717`	`717`	`subscriptionType: __Type`
`718`	`718`
`719`	`719`	`"""A list of all directives supported by this server."""`
`720`		`- directives: [__Directive!]!`
	`720`	`+ directives(includeDeprecated: Boolean = false): [__Directive!]!`
`721`	`721`	`}`
`722`	`722`
`723`	`723`	`"""`
`@@ -821,6 +821,8 @@ describe('Type System Printer', () => {`
`821`	`821`	`isRepeatable: Boolean!`
`822`	`822`	`locations: [__DirectiveLocation!]!`
`823`	`823`	`args(includeDeprecated: Boolean = false): [__InputValue!]!`
	`824`	`+ isDeprecated: Boolean!`
	`825`	`+ deprecationReason: String`
`824`	`826`	`}`
`825`	`827`
`826`	`828`	`"""`