chore: propagate federated directive definitions, subgraph schema nod…

composition/package.json

@@ -30,7 +30,7 @@
   "dependencies": {
     "@graphql-tools/merge": "^9.0.0",
     "@graphql-tools/schema": "^10.0.0",
-    "@graphql-tools/utils": "^10.1.0",
+    "@graphql-tools/utils": "^10.10.2",
     "core-js": "^3.41.0",
     "graphql": "^16.9.0",
     "lodash": "^4.17.21",

composition/src/buildASTSchema/buildASTSchema.ts

@@ -4,12 +4,12 @@ import { extendSchemaImpl } from './extendSchema';
 import { GraphQLSchemaValidationOptions } from 'graphql/type/schema';
 
 export interface BuildASTSchemaOptions extends GraphQLSchemaValidationOptions {
+  addInvalidExtensionOrphans?: boolean;
   /**
    * Set to true to assume the SDL is valid.
    *
    * Default: false
    */
-  addInvalidExtensionOrphans?: boolean;
   assumeValidSDL?: boolean | undefined;
 }
 

composition/src/federation/types.ts

@@ -1,5 +1,5 @@
 import { Warning } from '../warnings/types';
-import { ConstDirectiveNode, DocumentNode, GraphQLSchema, StringValueNode } from 'graphql';
+import { ConstDirectiveNode, DirectiveDefinitionNode, DocumentNode, GraphQLSchema, StringValueNode } from 'graphql';
 import {
   ConfigureDescriptionData,
   ExtensionType,
@@ -9,7 +9,7 @@ import {
 import { FieldConfiguration } from '../router-configuration/types';
 import { Subgraph, SubgraphConfig } from '../subgraph/types';
 import { SupportedRouterCompatibilityVersion } from '../router-compatibility-version/router-compatibility-version';
-import { ContractName } from '../types/types';
+import { ContractName, DirectiveName, SubgraphName, TypeName } from '../types/types';
 
 export type FederationFailure = {
   errors: Array<Error>;
@@ -18,6 +18,7 @@ export type FederationFailure = {
 };
 
 export type FederationSuccess = {
+  directiveDefinitionByName: Map<DirectiveName, DirectiveDefinitionNode>;
   fieldConfigurations: Array<FieldConfiguration>;
   federatedGraphAST: DocumentNode;
   federatedGraphClientSchema: GraphQLSchema;
@@ -38,13 +39,14 @@ export type FederationResultWithContractsFailure = {
 };
 
 export type FederationResultWithContractsSuccess = {
+  directiveDefinitionByName: Map<DirectiveName, DirectiveDefinitionNode>;
   fieldConfigurations: Array<FieldConfiguration>;
   federatedGraphAST: DocumentNode;
   federatedGraphClientSchema: GraphQLSchema;
   federatedGraphSchema: GraphQLSchema;
   federationResultByContractName: Map<string, FederationResult>;
-  parentDefinitionDataByTypeName: Map<string, ParentDefinitionData>;
-  subgraphConfigBySubgraphName: Map<string, SubgraphConfig>;
+  parentDefinitionDataByTypeName: Map<TypeName, ParentDefinitionData>;
+  subgraphConfigBySubgraphName: Map<SubgraphName, SubgraphConfig>;
   success: true;
   warnings: Array<Warning>;
   shouldIncludeClientSchema?: boolean;

composition/src/schema-building/utils.ts

@@ -58,6 +58,7 @@ import {
   INPUT_FIELD,
   INPUT_NODE_KINDS,
   INT_SCALAR,
+  KEY,
   MUTATION,
   OUTPUT_NODE_KINDS,
   PERSISTED_CLIENT_DIRECTIVES,
@@ -80,6 +81,7 @@ import {
 import { InputNodeKind, InvalidRequiredInputValueData, OutputNodeKind } from '../utils/types';
 import { getDescriptionFromString } from '../v1/federation/utils';
 import { DirectiveName, FieldName, SubgraphName, TypeName } from '../types/types';
+import { DEFAULT_DEPRECATION_REASON } from 'graphql';
 
 export function newPersistedDirectivesData(): PersistedDirectivesData {
   return {
@@ -237,7 +239,32 @@ export function childMapToValueArray<T extends ChildData, U extends ChildDefinit
     if (isFieldData(childData)) {
       propagateFieldDataArguments(childData);
     }
-    for (const directiveNodes of childData.directivesByDirectiveName.values()) {
+    for (const [directiveName, directiveNodes] of childData.directivesByDirectiveName) {
+      if (directiveName === DEPRECATED) {
+        // @deprecated is non-repeatable
+        const directiveNode = directiveNodes[0];
+        if (!directiveNode) {
+          continue;
+        }
+        if (directiveNode.arguments?.length) {
+          childData.node.directives.push(directiveNode);
+          continue;
+        }
+        childData.node.directives.push({
+          ...directiveNode,
+          arguments: [
+            {
+              kind: Kind.ARGUMENT,
+              value: {
+                kind: Kind.STRING,
+                value: DEFAULT_DEPRECATION_REASON,
+              },
+              name: stringToNameNode(REASON),
+            },
+          ],
+        });
+        continue;
+      }
       childData.node.directives.push(...directiveNodes);
     }
     valueArray.push(childData.node);

composition/src/v1/federation/federation-factory.ts

@@ -255,13 +255,14 @@ export class FederationFactory {
   authorizationDataByParentTypeName: Map<TypeName, AuthorizationData>;
   coordsByNamedTypeName = new Map<TypeName, Set<string>>();
   disableResolvabilityValidation: boolean = false;
-  clientDefinitions: (MutableDefinitionNode | DefinitionNode)[] = [];
+  directiveDefinitionByName = new Map<DirectiveName, DirectiveDefinitionNode>();
+  clientDefinitions: Array<MutableDefinitionNode | DefinitionNode> = [];
   currentSubgraphName = '';
   concreteTypeNamesByAbstractTypeName: Map<TypeName, Set<TypeName>>;
   subgraphNamesByNamedTypeNameByFieldCoords = new Map<string, Map<string, Set<string>>>();
   entityDataByTypeName: Map<TypeName, EntityData>;
   entityInterfaceFederationDataByTypeName: Map<string, EntityInterfaceFederationData>;
-  errors: Error[] = [];
+  errors: Array<Error> = [];
   fieldConfigurationByFieldCoords = new Map<string, FieldConfiguration>();
   fieldCoordsByNamedTypeName: Map<TypeName, Set<FieldCoords>>;
   inaccessibleCoords = new Set<string>();
@@ -286,10 +287,10 @@ export class FederationFactory {
   ]);
   potentialPersistedDirectiveDefinitionDataByDirectiveName = new Map<string, PersistedDirectiveDefinitionData>();
   referencedPersistedDirectiveNames = new Set<DirectiveName>();
-  routerDefinitions: (MutableDefinitionNode | DefinitionNode)[] = [];
+  routerDefinitions: Array<MutableDefinitionNode | DefinitionNode> = [];
   subscriptionFilterDataByFieldPath = new Map<string, SubscriptionFilterData>();
   tagNamesByCoords = new Map<string, Set<string>>();
-  warnings: Warning[];
+  warnings: Array<Warning>;
 
   constructor({
     authorizationDataByParentTypeName,
@@ -2324,6 +2325,7 @@ export class FederationFactory {
         continue;
       }
       const dependencies = DEPENDENCIES_BY_DIRECTIVE_NAME.get(directiveName) ?? [];
+      this.directiveDefinitionByName.set(directiveName, definition);
       if (CLIENT_PERSISTED_DIRECTIVE_NAMES.has(directiveName)) {
         this.clientDefinitions.push(definition);
         addIterableToSet({
@@ -2896,12 +2898,13 @@ export class FederationFactory {
       upsertAuthorizationConfiguration(this.fieldConfigurationByFieldCoords, authorizationData);
     }
     return {
+      directiveDefinitionByName: this.directiveDefinitionByName,
       fieldConfigurations: Array.from(this.fieldConfigurationByFieldCoords.values()),
-      subgraphConfigBySubgraphName,
       federatedGraphAST: newRouterAST,
       federatedGraphSchema: buildASTSchema(newRouterAST, { assumeValid: true, assumeValidSDL: true }),
       federatedGraphClientSchema: newClientSchema,
       parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+      subgraphConfigBySubgraphName,
       success: true,
       warnings: this.warnings,
       ...this.getClientSchemaObjectBoolean(),
@@ -3188,12 +3191,13 @@ export class FederationFactory {
       upsertAuthorizationConfiguration(this.fieldConfigurationByFieldCoords, authorizationData);
     }
     return {
+      directiveDefinitionByName: this.directiveDefinitionByName,
       fieldConfigurations: Array.from(this.fieldConfigurationByFieldCoords.values()),
-      subgraphConfigBySubgraphName,
       federatedGraphAST: newRouterAST,
       federatedGraphSchema: buildASTSchema(newRouterAST, { assumeValid: true, assumeValidSDL: true }),
       federatedGraphClientSchema: newClientSchema,
       parentDefinitionDataByTypeName: this.parentDefinitionDataByTypeName,
+      subgraphConfigBySubgraphName,
       success: true,
       warnings: this.warnings,
       ...this.getClientSchemaObjectBoolean(),

composition/src/v1/normalization/normalization-factory.ts

@@ -40,6 +40,8 @@ import {
   ScalarTypeNode,
   SchemaNode,
   setToNamedTypeNodeArray,
+  stringToNamedTypeNode,
+  stringToNameNode,
   UnionTypeNode,
 } from '../../ast/utils';
 import {
@@ -260,6 +262,7 @@ import {
   CONSUMER_INACTIVE_THRESHOLD,
   CONSUMER_NAME,
   DEFAULT_EDFS_PROVIDER_ID,
+  DEPRECATED,
   DESCRIPTION_OVERRIDE,
   EDFS_KAFKA_PUBLISH,
   EDFS_KAFKA_SUBSCRIBE,
@@ -305,6 +308,7 @@ import {
   PROVIDER_TYPE_REDIS,
   PUBLISH,
   QUERY,
+  REASON,
   REQUEST,
   REQUIRE_FETCH_REASONS,
   REQUIRES_SCOPES,
@@ -361,6 +365,7 @@ import { ImplementationErrors, InvalidFieldImplementation } from '../../utils/ty
 import { DirectiveName, FieldName, SubgraphName, TypeName } from '../../types/types';
 import { HandleFieldInheritableDirectivesParams, ValidateOneOfDirectiveParams } from './params';
 import { EDFS_NATS_STREAM_CONFIGURATION_DEFINITION } from '../constants/non-directive-definitions';
+import { DEFAULT_DEPRECATION_REASON } from 'graphql/index';
 
 export function normalizeSubgraphFromString(subgraphSDL: string, noLocation = true): NormalizationResult {
   const { error, documentNode } = safeParse(subgraphSDL, noLocation);
@@ -3106,7 +3111,7 @@ export class NormalizationFactory {
     directiveCoords: string,
     removeInheritedDirectives = false,
   ): ConstDirectiveNode[] {
-    const flattenedArray: ConstDirectiveNode[] = [];
+    const flattenedArray: Array<ConstDirectiveNode> = [];
     for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
       if (removeInheritedDirectives && INHERITABLE_DIRECTIVE_NAMES.has(directiveName)) {
         continue;
@@ -3198,11 +3203,33 @@ export class NormalizationFactory {
   }
 
   getSchemaNodeByData(schemaData: SchemaData): SchemaDefinitionNode {
+    const operationTypes: Array<OperationTypeDefinitionNode> = [];
+    for (const operationTypeNode of Object.values(OperationTypeNode)) {
+      const node = schemaData.operationTypes.get(operationTypeNode);
+      if (node) {
+        operationTypes.push(node);
+        continue;
+      }
+      const defaultRootTypeName = getOrThrowError(
+        operationTypeNodeToDefaultType,
+        operationTypeNode,
+        'operationTypeNodeToDefaultType',
+      );
+      if (!this.parentDefinitionDataByTypeName.has(defaultRootTypeName)) {
+        continue;
+      }
+      operationTypes.push({
+        kind: Kind.OPERATION_TYPE_DEFINITION,
+        operation: operationTypeNode,
+        type: stringToNamedTypeNode(defaultRootTypeName),
+      });
+    }
+
     return {
       description: schemaData.description,
       directives: this.getValidFlattenedDirectiveArray(schemaData.directivesByDirectiveName, schemaData.name),
       kind: schemaData.kind,
-      operationTypes: mapToArrayOfValues(schemaData.operationTypes),
+      operationTypes,
     };
   }
 
@@ -3459,22 +3486,34 @@ export class NormalizationFactory {
     definitions.push(...dependencies);
   }
 
+  #addSchemaDefinitionNode(definitions: Array<DefinitionNode>): void {
+    const schemaNode = this.getSchemaNodeByData(this.schemaData);
+    if (schemaNode.operationTypes.length > 0) {
+      definitions.push(schemaNode);
+      return;
+    }
+    if (schemaNode.directives?.length) {
+      definitions.push({
+        directives: schemaNode.directives,
+        kind: Kind.SCHEMA_EXTENSION,
+      });
+    }
+  }
+
   normalize(document: DocumentNode): NormalizationResult {
     // Collect any renamed root types
     upsertDirectiveSchemaAndEntityDefinitions(this, document);
     upsertParentsAndChildren(this, document);
     const definitions: DefinitionNode[] = [];
     this.#addDirectiveDefinitionsToDocument(definitions);
     this.validateDirectives(this.schemaData, SCHEMA);
+    this.#addSchemaDefinitionNode(definitions);
     for (const [parentTypeName, parentData] of this.parentDefinitionDataByTypeName) {
       this.validateDirectives(parentData, parentTypeName);
     }
     if (this.invalidORScopesCoords.size > 0) {
       this.errors.push(orScopesLimitError(MAX_OR_SCOPES, [...this.invalidORScopesCoords]));
     }
-    if (this.schemaData.operationTypes.size > 0) {
-      definitions.push(this.getSchemaNodeByData(this.schemaData));
-    }
     /*
      * Sometimes an @openfed__configureDescription directive is defined before a description is, e.g., on an extension.
      * If at this stage there is still no description, it is propagated as an error.
@@ -3752,7 +3791,7 @@ export class NormalizationFactory {
       persistedDirectiveDefinitionDataByDirectiveName,
       subgraphAST: newAST,
       subgraphString: print(newAST),
-      schema: buildASTSchema(newAST, { assumeValid: true, assumeValidSDL: true }),
+      schema: buildASTSchema(newAST, { addInvalidExtensionOrphans: true, assumeValid: true, assumeValidSDL: true }),
       success: true,
       warnings: this.warnings,
     };