Support directives on enum values and unions (#72)

.changeset/short-oranges-melt.md

@@ -0,0 +1,5 @@
+---
+"@theguild/federation-composition": minor
+---
+
+Support directives on enum values and unions

__tests__/ast.spec.ts

@@ -786,6 +786,20 @@ describe('union type', () => {
  union Media @inaccessible = Movie | Book
  `);
  });
+
+ test('directives', () => {
+ expect(
+ createUnionTypeNode({
+ name: 'Media',
+ members: ['Book', 'Movie'],
+ ast: {
+ directives: [createDirective('custom')],
+ },
+ }),
+ ).toEqualGraphQL(/* GraphQL */ `
+ union Media @custom = Movie | Book
+ `);
+ });
 });
 
 describe('input object type', () => {
@@ -996,6 +1010,9 @@ describe('enum object type', () => {
  values: [
  {
  name: 'BOOK',
+ ast: {
+ directives: [createDirective('any')],
+ },
  },
  {
  name: 'MOVIE',
@@ -1007,7 +1024,7 @@ describe('enum object type', () => {
  }),
  ).toEqualGraphQL(/* GraphQL */ `
  enum Media @custom {
- BOOK
+ BOOK @any
  MOVIE
  }
  `);

__tests__/composition.spec.ts

@@ -2378,6 +2378,114 @@ testImplementations(api => {
  `);
  });
 
+ test('preserve directive on enum values if included in @composeDirective', () => {
+ const result = composeServices([
+ {
+ name: 'a',
+ typeDefs: parse(/* GraphQL */ `
+ extend schema
+ @link(
+ url: "https://specs.apollo.dev/federation/${version}"
+ import: ["@key", "@composeDirective"]
+ )
+ @link(url: "https://myspecs.dev/whatever/v1.0", import: ["@whatever"])
+ @composeDirective(name: "@whatever")
+
+ directive @whatever on ENUM_VALUE
+
+ enum UserType {
+ ADMIN @whatever
+ REGULAR
+ }
+
+ type User @key(fields: "id") {
+ id: ID!
+ name: String!
+ type: UserType!
+ }
+
+ type Query {
+ users: [User]
+ }
+ `),
+ },
+ ]);
+
+ if (version === 'v2.0') {
+ assertCompositionFailure(result);
+ return;
+ }
+
+ assertCompositionSuccess(result);
+
+ expect(result.supergraphSdl).toContainGraphQL(/* GraphQL */ `
+ directive @whatever on ENUM_VALUE
+ `);
+
+ expect(result.supergraphSdl).toContainGraphQL(/* GraphQL */ `
+ enum UserType @join__type(graph: A) {
+ ADMIN @join__enumValue(graph: A) @whatever
+ REGULAR @join__enumValue(graph: A)
+ }
+ `);
+ });
+
+ test('preserve directive on union types if included in @composeDirective', () => {
+ const result = composeServices([
+ {
+ name: 'a',
+ typeDefs: parse(/* GraphQL */ `
+ extend schema
+ @link(
+ url: "https://specs.apollo.dev/federation/${version}"
+ import: ["@key", "@composeDirective"]
+ )
+ @link(url: "https://myspecs.dev/whatever/v1.0", import: ["@whatever"])
+ @composeDirective(name: "@whatever")
+
+ directive @whatever on UNION
+
+ type User @key(fields: "id") {
+ id: ID!
+ name: String!
+ }
+
+ type Admin @key(fields: "id") {
+ id: ID!
+ name: String!
+ }
+
+ union Whoever @whatever = User | Admin
+
+ type Query {
+ whoever: [Whoever]
+ }
+ `),
+ },
+ ]);
+
+ if (version === 'v2.0') {
+ assertCompositionFailure(result);
+ return;
+ }
+
+ assertCompositionSuccess(result);
+
+ expect(result.supergraphSdl).toContainGraphQL(/* GraphQL */ `
+ directive @whatever on UNION
+ `);
+
+ expect(result.supergraphSdl).toContainGraphQL(/* GraphQL */ `
+ union Whoever
+ @join__type(graph: A)
+ @join__unionMember(graph: A, member: "Admin")
+ @join__unionMember(graph: A, member: "User")
+ @whatever =
+ | Admin
+ | User
+ `);
+ });
+
  test('preserve directive on interface its field and argument if included in @composeDirective', () => {
  const result = composeServices([
  {

src/subgraph/state.ts

@@ -142,6 +142,9 @@ export interface UnionType {
  inaccessible: boolean;
  isDefinition: boolean;
  description?: Description;
+ ast: {
+ directives: DirectiveNode[];
+ };
 }
 
 export interface EnumType {
@@ -211,6 +214,9 @@ export interface EnumValue {
  tags: Set<string>;
  description?: Description;
  deprecated?: Deprecated;
+ ast: {
+ directives: DirectiveNode[];
+ };
 }
 
 export interface Argument {
@@ -724,6 +730,7 @@ export function createSubgraphStateBuilder(
  if (composedDirectives.has(node.name.value)) {
  const typeDef = typeNodeInfo.getTypeDef();
  const fieldDef = typeNodeInfo.getFieldDef();
+ const enumValueDef = typeNodeInfo.getValueDef();
  const argDef = typeNodeInfo.getArgumentDef();
 
  if (!typeDef) {
@@ -795,12 +802,27 @@ export function createSubgraphStateBuilder(
  }
  case Kind.ENUM_TYPE_DEFINITION:
  case Kind.ENUM_TYPE_EXTENSION: {
- enumTypeBuilder.setDirective(typeDef.name.value, node);
+ if (enumValueDef) {
+ enumTypeBuilder.value.setDirective(
+ typeDef.name.value,
+ enumValueDef.name.value,
+ node,
+ );
+ } else {
+ enumTypeBuilder.setDirective(typeDef.name.value, node);
+ }
+ break;
+ }
+ case Kind.UNION_TYPE_DEFINITION:
+ case Kind.UNION_TYPE_EXTENSION: {
+ unionTypeBuilder.setDirective(typeDef.name.value, node);
  break;
  }
+
  default:
- // TODO: T07 support directives on other locations than OBJECT, FIELD_DEFINITION, ARGUMENT_DEFINITION
- throw new Error(`Directives on "${typeDef.kind}" types are not supported yet`);
+ throw new Error(
+ `Directives on "${typeof typeDef === 'object' && typeDef !== null && 'kind' in typeDef ? (typeDef as any).kind : typeDef}" types are not supported yet`,
+ );
  }
  } else if (node.name.value === 'specifiedBy') {
  const typeDef = typeNodeInfo.getTypeDef();
@@ -1786,6 +1808,9 @@ function unionTypeFactory(state: SubgraphState) {
  setMember(typeName: string, member: string) {
  getOrCreateUnionType(state, typeName).members.add(member);
  },
+ setDirective(typeName: string, directive: DirectiveNode) {
+ getOrCreateUnionType(state, typeName).ast.directives.push(directive);
+ },
  };
 }
 
@@ -1830,6 +1855,9 @@ function enumTypeFactory(state: SubgraphState) {
  setDescription(typeName: string, valueName: string, description: Description) {
  getOrCreateEnumValue(state, typeName, valueName).description = description;
  },
+ setDirective(typeName: string, valueName: string, directive: DirectiveNode) {
+ getOrCreateEnumValue(state, typeName, valueName).ast.directives.push(directive);
+ },
  setInaccessible(typeName: string, valueName: string) {
  getOrCreateEnumValue(state, typeName, valueName).inaccessible = true;
  },
@@ -2089,6 +2117,9 @@ function getOrCreateUnionType(state: SubgraphState, typeName: string): UnionType
  inaccessible: false,
  tags: new Set(),
  isDefinition: false,
+ ast: {
+ directives: [],
+ },
  };
 
  state.types.set(typeName, unionType);
@@ -2230,6 +2261,9 @@ function getOrCreateEnumValue(
  name: enumValueName,
  inaccessible: false,
  tags: new Set(),
+ ast: {
+ directives: [],
+ },
  };
 
  enumType.values.set(enumValueName, enumValue);

src/supergraph/composition/enum-type.ts

@@ -80,6 +80,10 @@ export function enumTypeBuilder(): TypeBuilder<EnumType, EnumTypeState> {
  valueState.description = value.description;
  }
 
+ value.ast.directives.forEach(directive => {
+ valueState.ast.directives.push(directive);
+ });
+
  valueState.byGraph.set(graph.id, {
  inaccessible: value.inaccessible,
  version: graph.version,
@@ -114,6 +118,9 @@ export function enumTypeBuilder(): TypeBuilder<EnumType, EnumTypeState> {
  inaccessible: value.inaccessible,
  description: value.description,
  deprecated: value.deprecated,
+ ast: {
+ directives: convertToConst(value.ast.directives),
+ },
  })),
  tags: Array.from(enumType.tags),
  inaccessible: enumType.inaccessible,
@@ -185,6 +192,9 @@ type EnumValueState = {
  inaccessible: boolean;
  deprecated?: Deprecated;
  description?: Description;
+ ast: {
+ directives: DirectiveNode[];
+ };
  byGraph: MapByGraph<EnumValueStateInGraph>;
 };
 
@@ -242,6 +252,9 @@ function getOrCreateEnumValue(enumTypeState: EnumTypeState, enumValueName: strin
  tags: new Set(),
  inaccessible: false,
  byGraph: new Map(),
+ ast: {
+ directives: [],
+ },
  };
 
  enumTypeState.values.set(enumValueName, def);

src/supergraph/composition/union-type.ts

@@ -1,7 +1,8 @@
+import type { DirectiveNode } from 'graphql';
 import { FederationVersion } from '../../specifications/federation.js';
 import { Description, UnionType } from '../../subgraph/state.js';
 import { createUnionTypeNode } from './ast.js';
-import type { MapByGraph, TypeBuilder } from './common.js';
+import { convertToConst, type MapByGraph, type TypeBuilder } from './common.js';
 
 export function unionTypeBuilder(): TypeBuilder<UnionType, UnionTypeState> {
  return {
@@ -23,6 +24,10 @@ export function unionTypeBuilder(): TypeBuilder<UnionType, UnionTypeState> {
  unionTypeState.description = type.description;
  }
 
+ type.ast.directives.forEach(directive => {
+ unionTypeState.ast.directives.push(directive);
+ });
+
  unionTypeState.byGraph.set(graph.id, {
  members: type.members,
  version: graph.version,
@@ -50,6 +55,9 @@ export function unionTypeBuilder(): TypeBuilder<UnionType, UnionTypeState> {
  })
  .flat(1),
  },
+ ast: {
+ directives: convertToConst(unionType.ast.directives),
+ },
  });
  },
  };
@@ -64,6 +72,9 @@ export type UnionTypeState = {
  inaccessible: boolean;
  byGraph: MapByGraph<UnionTypeInGraph>;
  members: Set<string>;
+ ast: {
+ directives: DirectiveNode[];
+ };
 };
 
 type UnionTypeInGraph = {
@@ -86,6 +97,9 @@ function getOrCreateUnionType(state: Map<string, UnionTypeState>, typeName: stri
  inaccessible: false,
  hasDefinition: false,
  byGraph: new Map(),
+ ast: {
+ directives: [],
+ },
  };
 
  state.set(typeName, def);