chore: selectively inject directive defs/deps

composition-go/composition_test.go

@@ -70,17 +70,12 @@ func normalizeWhiteSpace(s string) string {
 func TestFederateSubgraphs(t *testing.T) {
 	const (
 		expectedSDL = `
-			directive @authenticated on ENUM | FIELD_DEFINITION | INTERFACE | OBJECT | SCALAR
-
-			directive @deprecated(reason: String = "No longer supported") on ARGUMENT_DEFINITION | ENUM_VALUE | FIELD_DEFINITION | INPUT_FIELD_DEFINITION
-
-			directive @inaccessible on ARGUMENT_DEFINITION | ENUM | ENUM_VALUE | FIELD_DEFINITION | INPUT_FIELD_DEFINITION | INPUT_OBJECT | INTERFACE | OBJECT | SCALAR | UNION
-
 			directive @requiresScopes(scopes: [[openfed__Scope!]!]!) on ENUM | FIELD_DEFINITION | INTERFACE | OBJECT | SCALAR 
+
+			scalar openfed__Scope
 
-			directive @tag(name: String!) repeatable on ARGUMENT_DEFINITION | ENUM | ENUM_VALUE | FIELD_DEFINITION | INPUT_FIELD_DEFINITION | INPUT_OBJECT | INTERFACE | OBJECT | SCALAR | UNION
+			directive @authenticated on ENUM | FIELD_DEFINITION | INTERFACE | OBJECT | SCALAR
 
-			scalar openfed__Scope
 
 			type Query {
 				query(arg: String!): Nested

composition/src/index.ts

@@ -27,6 +27,12 @@ export * from './utils/utils';
 export * from './warnings/types';
 
 // v1
+export * from './v1/constants/constants';
+export * from './v1/constants/directive-definitions';
+export * from './v1/constants/integers';
+export * from './v1/constants/non-directive-definitions';
+export * from './v1/constants/strings';
+export * from './v1/constants/type-nodes';
 export * from './v1/federation/utils';
 export * from './v1/federation/walkers';
 export * from './v1/federation/types';
@@ -36,7 +42,5 @@ export * from './v1/normalization/types';
 export * from './v1/normalization/walkers';
 export * from './v1/schema-building/type-merging';
 export * from './v1/subgraph/subgraph';
-export * from './v1/utils/constants';
 export * from './v1/utils/utils';
-export * from './v1/utils/string-constants';
 export * from './v1/warnings/warnings';

composition/src/normalization/types.ts

@@ -11,7 +11,7 @@ import {
 } from '../schema-building/types';
 import { Graph } from '../resolvability-graph/graph';
 import { InternalSubgraph } from '../subgraph/types';
-import { DirectiveName } from '../types/types';
+import { DirectiveName, TypeName } from '../types/types';
 
 export type NormalizationFailure = {
   errors: Array<Error>;
@@ -23,7 +23,7 @@ export type NormalizationSuccess = {
   authorizationDataByParentTypeName: Map<string, AuthorizationData>;
   concreteTypeNamesByAbstractTypeName: Map<string, Set<string>>;
   conditionalFieldDataByCoordinates: Map<string, ConditionalFieldData>;
-  configurationDataByTypeName: Map<string, ConfigurationData>;
+  configurationDataByTypeName: Map<TypeName, ConfigurationData>;
   directiveDefinitionByDirectiveName: Map<DirectiveName, DirectiveDefinitionNode>;
   entityInterfaces: Map<string, EntityInterfaceSubgraphData>;
   entityDataByTypeName: Map<string, EntityData>;

composition/src/schema-building/ast.ts

@@ -263,7 +263,7 @@ export function getMutableUnionNode(nameNode: NameNode): MutableUnionNode {
   };
 }
 
-export type MutableTypeDefinitionNode =
+export type MutableDefinitionNode =
   | MutableDirectiveDefinitionNode
   | MutableEnumNode
   | MutableInputObjectNode

composition/src/schema-building/utils.ts

@@ -2,6 +2,7 @@ import {
   BooleanValueNode,
   ConstDirectiveNode,
   ConstValueNode,
+  DefinitionNode,
   DirectiveDefinitionNode,
   EnumValueDefinitionNode,
   EnumValueNode,
@@ -26,6 +27,7 @@ import {
   ExtensionType,
   ExternalFieldData,
   FieldData,
+  InputObjectDefinitionData,
   InputValueData,
   InterfaceDefinitionData,
   NodeData,
@@ -35,7 +37,7 @@ import {
   PersistedDirectivesData,
   SchemaData,
 } from './types';
-import { MutableFieldNode, MutableInputValueNode, MutableTypeDefinitionNode } from './ast';
+import { MutableDefinitionNode, MutableFieldNode, MutableInputValueNode } from './ast';
 import { ObjectTypeNode, setToNameNodeArray, stringToNameNode } from '../ast/utils';
 import {
   incompatibleInputValueDefaultValuesError,
@@ -46,7 +48,6 @@ import { SubscriptionFilterValue } from '../router-configuration/types';
 import {
   ARGUMENT,
   AUTHENTICATED,
-  AUTHORIZATION_DIRECTIVES,
   BOOLEAN_SCALAR,
   DEPRECATED,
   DEPRECATED_DEFAULT_ARGUMENT_VALUE,
@@ -58,7 +59,6 @@ import {
   INPUT_NODE_KINDS,
   INT_SCALAR,
   MUTATION,
-  NON_REPEATABLE_PERSISTED_DIRECTIVES,
   OUTPUT_NODE_KINDS,
   PERSISTED_CLIENT_DIRECTIVES,
   QUERY,
@@ -69,7 +69,6 @@ import {
   SHAREABLE,
   STRING_SCALAR,
   SUBSCRIPTION,
-  TAG,
 } from '../utils/string-constants';
 import {
   generateRequiresScopesDirective,
@@ -285,7 +284,7 @@ export function setParentDataExtensionType(existingData: ParentDefinitionData, i
   existingData.extensionType = ExtensionType.NONE;
 }
 
-function upsertDeprecatedDirective(
+export function upsertDeprecatedDirective(
   persistedDirectivesData: PersistedDirectivesData,
   incomingDirectiveNode: ConstDirectiveNode,
 ) {
@@ -299,7 +298,7 @@ function upsertDeprecatedDirective(
   }
 }
 
-function upsertTagDirectives(
+export function upsertTagDirectives(
   persistedDirectivesData: PersistedDirectivesData,
   incomingDirectiveNodes: ConstDirectiveNode[],
 ) {
@@ -310,42 +309,6 @@ function upsertTagDirectives(
   }
 }
 
-export function extractPersistedDirectives(
-  persistedDirectivesData: PersistedDirectivesData,
-  directivesByDirectiveName: Map<DirectiveName, ConstDirectiveNode[]>,
-  persistedDirectiveDefinitionByDirectiveName: Map<DirectiveName, DirectiveDefinitionNode>,
-): PersistedDirectivesData {
-  for (const [directiveName, directiveNodes] of directivesByDirectiveName) {
-    // @authenticated and @requiresScopes are handled differently
-    if (
-      AUTHORIZATION_DIRECTIVES.has(directiveName) ||
-      !persistedDirectiveDefinitionByDirectiveName.has(directiveName)
-    ) {
-      continue;
-    }
-    if (directiveName === DEPRECATED) {
-      persistedDirectivesData.isDeprecated = true;
-      upsertDeprecatedDirective(persistedDirectivesData, directiveNodes[0]);
-      continue;
-    }
-    if (directiveName === TAG) {
-      upsertTagDirectives(persistedDirectivesData, directiveNodes);
-      continue;
-    }
-    const existingDirectives = persistedDirectivesData.directivesByDirectiveName.get(directiveName);
-    if (!existingDirectives) {
-      persistedDirectivesData.directivesByDirectiveName.set(directiveName, [...directiveNodes]);
-      continue;
-    }
-    // Only add one instance of certain directives.
-    if (NON_REPEATABLE_PERSISTED_DIRECTIVES.has(directiveName)) {
-      continue;
-    }
-    existingDirectives.push(...directiveNodes);
-  }
-  return persistedDirectivesData;
-}
-
 export function propagateAuthDirectives(parentData: ParentDefinitionData, authData?: AuthorizationData) {
   if (!authData) {
     return;
@@ -557,7 +520,7 @@ function addValidatedArgumentNodes(
 }
 
 export function addValidPersistedDirectiveDefinitionNodeByData(
-  definitions: MutableTypeDefinitionNode[],
+  definitions: (MutableDefinitionNode | DefinitionNode)[],
   data: PersistedDirectiveDefinitionData,
   persistedDirectiveDefinitionByDirectiveName: Map<DirectiveName, DirectiveDefinitionNode>,
   errors: Error[],
@@ -783,6 +746,10 @@ export function isFieldData(data: ChildData | NodeData | SchemaData): data is Fi
   return data.kind === Kind.FIELD_DEFINITION;
 }
 
+export function isInputObjectDefinitionData(data: ParentDefinitionData): data is InputObjectDefinitionData {
+  return data.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION;
+}
+
 export function isInputNodeKind(kind: Kind): kind is InputNodeKind {
   return INPUT_NODE_KINDS.has(kind);
 }

composition/src/subgraph/types.ts

@@ -24,7 +24,7 @@ export type SubgraphConfig = {
 
 export type InternalSubgraph = {
   conditionalFieldDataByCoordinates: Map<string, ConditionalFieldData>;
-  configurationDataByTypeName: Map<string, ConfigurationData>;
+  configurationDataByTypeName: Map<TypeName, ConfigurationData>;
   definitions: DocumentNode;
   directiveDefinitionByDirectiveName: Map<DirectiveName, DirectiveDefinitionNode>;
   entityInterfaces: Map<string, EntityInterfaceSubgraphData>;

composition/src/utils/utils.ts

@@ -61,6 +61,15 @@ export function addIterableValuesToSet<T>(source: Array<T> | Iterable<T>, target
   }
 }
 
+export function addOptionalIterableValuesToSet<T>(target: Set<T>, source?: Array<T> | Iterable<T>) {
+  if (!source) {
+    return;
+  }
+  for (const value of source) {
+    target.add(value);
+  }
+}
+
 export function addSets<T>(a: Set<T>, b: Set<T>): Set<T> {
   const output = new Set<T>(a);
   for (const item of b) {

composition/src/v1/constants/constants.ts

@@ -0,0 +1,133 @@
+import { DirectiveDefinitionNode } from 'graphql';
+import {
+  AUTHENTICATED,
+  BOOLEAN_SCALAR,
+  COMPOSE_DIRECTIVE,
+  CONFIGURE_CHILD_DESCRIPTIONS,
+  CONFIGURE_DESCRIPTION,
+  DEPRECATED,
+  EDFS_KAFKA_PUBLISH,
+  EDFS_KAFKA_SUBSCRIBE,
+  EDFS_NATS_PUBLISH,
+  EDFS_NATS_REQUEST,
+  EDFS_NATS_SUBSCRIBE,
+  EDFS_REDIS_PUBLISH,
+  EDFS_REDIS_SUBSCRIBE,
+  EXTENDS,
+  EXTERNAL,
+  FIELD_SET_SCALAR,
+  FLOAT_SCALAR,
+  ID_SCALAR,
+  INACCESSIBLE,
+  INT_SCALAR,
+  INTERFACE_OBJECT,
+  KEY,
+  LINK,
+  ONE_OF,
+  OVERRIDE,
+  PROVIDES,
+  REQUIRE_FETCH_REASONS,
+  REQUIRES,
+  REQUIRES_SCOPES,
+  SCOPE_SCALAR,
+  SEMANTIC_NON_NULL,
+  SHAREABLE,
+  SPECIFIED_BY,
+  STRING_SCALAR,
+  SUBSCRIPTION_FILTER,
+  TAG,
+} from '../../utils/string-constants';
+import { DirectiveName } from '../../types/types';
+import {
+  AUTHENTICATED_DEFINITION,
+  COMPOSE_DIRECTIVE_DEFINITION,
+  CONFIGURE_CHILD_DESCRIPTIONS_DEFINITION,
+  CONFIGURE_DESCRIPTION_DEFINITION,
+  DEPRECATED_DEFINITION,
+  EDFS_KAFKA_PUBLISH_DEFINITION,
+  EDFS_KAFKA_SUBSCRIBE_DEFINITION,
+  EDFS_NATS_PUBLISH_DEFINITION,
+  EDFS_NATS_REQUEST_DEFINITION,
+  EDFS_NATS_SUBSCRIBE_DEFINITION,
+  EDFS_REDIS_PUBLISH_DEFINITION,
+  EDFS_REDIS_SUBSCRIBE_DEFINITION,
+  EXTENDS_DEFINITION,
+  EXTERNAL_DEFINITION,
+  INACCESSIBLE_DEFINITION,
+  INTERFACE_OBJECT_DEFINITION,
+  KEY_DEFINITION,
+  LINK_DEFINITION,
+  ONE_OF_DEFINITION,
+  OVERRIDE_DEFINITION,
+  PROVIDES_DEFINITION,
+  REQUIRE_FETCH_REASONS_DEFINITION,
+  REQUIRES_DEFINITION,
+  REQUIRES_SCOPES_DEFINITION,
+  SEMANTIC_NON_NULL_DEFINITION,
+  SHAREABLE_DEFINITION,
+  SPECIFIED_BY_DEFINITION,
+  SUBSCRIPTION_FILTER_DEFINITION,
+  TAG_DEFINITION,
+} from './directive-definitions';
+
+export const DIRECTIVE_DEFINITION_BY_NAME: ReadonlyMap<DirectiveName, DirectiveDefinitionNode> = new Map<
+  DirectiveName,
+  DirectiveDefinitionNode
+>([
+  [AUTHENTICATED, AUTHENTICATED_DEFINITION],
+  [COMPOSE_DIRECTIVE, COMPOSE_DIRECTIVE_DEFINITION],
+  [CONFIGURE_DESCRIPTION, CONFIGURE_DESCRIPTION_DEFINITION],
+  [CONFIGURE_CHILD_DESCRIPTIONS, CONFIGURE_CHILD_DESCRIPTIONS_DEFINITION],
+  [DEPRECATED, DEPRECATED_DEFINITION],
+  [EDFS_KAFKA_PUBLISH, EDFS_KAFKA_PUBLISH_DEFINITION],
+  [EDFS_KAFKA_SUBSCRIBE, EDFS_KAFKA_SUBSCRIBE_DEFINITION],
+  [EDFS_NATS_PUBLISH, EDFS_NATS_PUBLISH_DEFINITION],
+  [EDFS_NATS_REQUEST, EDFS_NATS_REQUEST_DEFINITION],
+  [EDFS_NATS_SUBSCRIBE, EDFS_NATS_SUBSCRIBE_DEFINITION],
+  [EDFS_REDIS_PUBLISH, EDFS_REDIS_PUBLISH_DEFINITION],
+  [EDFS_REDIS_SUBSCRIBE, EDFS_REDIS_SUBSCRIBE_DEFINITION],
+  [EXTENDS, EXTENDS_DEFINITION],
+  [EXTERNAL, EXTERNAL_DEFINITION],
+  [INACCESSIBLE, INACCESSIBLE_DEFINITION],
+  [INTERFACE_OBJECT, INTERFACE_OBJECT_DEFINITION],
+  [KEY, KEY_DEFINITION],
+  [LINK, LINK_DEFINITION],
+  [ONE_OF, ONE_OF_DEFINITION],
+  [OVERRIDE, OVERRIDE_DEFINITION],
+  [PROVIDES, PROVIDES_DEFINITION],
+  [REQUIRE_FETCH_REASONS, REQUIRE_FETCH_REASONS_DEFINITION],
+  [REQUIRES, REQUIRES_DEFINITION],
+  [REQUIRES_SCOPES, REQUIRES_SCOPES_DEFINITION],
+  [SEMANTIC_NON_NULL, SEMANTIC_NON_NULL_DEFINITION],
+  [SHAREABLE, SHAREABLE_DEFINITION],
+  [SPECIFIED_BY, SPECIFIED_BY_DEFINITION],
+  [SUBSCRIPTION_FILTER, SUBSCRIPTION_FILTER_DEFINITION],
+  [TAG, TAG_DEFINITION],
+]);
+
+export const BASE_SCALARS: ReadonlySet<string> = new Set<string>([
+  '_Any',
+  '_Entities',
+  BOOLEAN_SCALAR,
+  FLOAT_SCALAR,
+  ID_SCALAR,
+  INT_SCALAR,
+  FIELD_SET_SCALAR,
+  SCOPE_SCALAR,
+  STRING_SCALAR,
+]);
+
+export const V2_DIRECTIVE_DEFINITION_BY_DIRECTIVE_NAME = new Map<DirectiveName, DirectiveDefinitionNode>([
+  [AUTHENTICATED, AUTHENTICATED_DEFINITION],
+  [COMPOSE_DIRECTIVE, COMPOSE_DIRECTIVE_DEFINITION],
+  [INACCESSIBLE, INACCESSIBLE_DEFINITION],
+  [INTERFACE_OBJECT, INTERFACE_OBJECT_DEFINITION],
+  [LINK, LINK_DEFINITION],
+  [OVERRIDE, OVERRIDE_DEFINITION],
+  [REQUIRES_SCOPES, REQUIRES_SCOPES_DEFINITION],
+  [SHAREABLE, SHAREABLE_DEFINITION],
+]);
+
+export const EDFS_ARGS_REGEXP = /{{\s*args\.([a-zA-Z0-9_]+)\s*}}/g;
+
+export const MAX_OR_SCOPES = 16;