@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/esm/graphql/helpers.js

@@ -0,0 +1,27 @@
+import { Kind, visit } from 'graphql';
+export function isDirectiveDefinition(node) {
+    return node.kind === Kind.DIRECTIVE_DEFINITION;
+}
+export function stripFederationFromSupergraph(supergraph) {
+    function remove() {
+        return null;
+    }
+    return visit(supergraph, {
+        DirectiveDefinition: remove,
+        Directive: remove,
+        SchemaDefinition: remove,
+        SchemaExtension: remove,
+        EnumTypeDefinition: node => {
+            if (node.name.value === 'core__Purpose' || node.name.value === 'join__Graph') {
+                return null;
+            }
+            return node;
+        },
+        ScalarTypeDefinition: node => {
+            if (node.name.value === '_FieldSet') {
+                return null;
+            }
+            return node;
+        },
+    });
+}

package/esm/graphql/printer.js

@@ -0,0 +1,244 @@
+function printString(string) {
+    return JSON.stringify(string);
+}
+function printBlockString(string) {
+    return '"""\n' + string.replace(/"""/g, '\\"""') + '\n"""';
+}
+const nodes = {
+    Document(node) {
+        return node.definitions?.length > 0 ? node.definitions.map(print).join('\n\n') : '';
+    },
+    OperationDefinition(node) {
+        if (node.operation === 'query' &&
+            !node.name &&
+            !node.variableDefinitions?.length &&
+            !node.directives?.length) {
+            return print(node.selectionSet);
+        }
+        return (join([
+            node.operation,
+            print(node.name) + wrap('(', join(node.variableDefinitions?.map(print), ', '), ')'),
+            join(node.directives?.map(print), ' '),
+        ], ' ') + print(node.selectionSet));
+    },
+    VariableDefinition(node) {
+        return [
+            print(node.variable),
+            ':',
+            print(node.type),
+            wrap(' = ', print(node.defaultValue)),
+            join(node.directives?.map(print), ' '),
+        ].join(' ');
+    },
+    Field(node) {
+        return (join([
+            (node.alias ? node.alias.value + ': ' : '') + node.name.value + printArgs(node.arguments),
+            join(node.directives?.map(print), ' '),
+        ], ' ') + print(node.selectionSet));
+    },
+    StringValue(node) {
+        return node.block ? printBlockString(node.value) : printString(node.value);
+    },
+    BooleanValue(node) {
+        return '' + node.value;
+    },
+    NullValue(_node) {
+        return 'null';
+    },
+    IntValue(node) {
+        return node.value;
+    },
+    FloatValue(node) {
+        return node.value;
+    },
+    EnumValue(node) {
+        return node.value;
+    },
+    Name(node) {
+        return node.value;
+    },
+    Variable(node) {
+        return '$' + node.name.value;
+    },
+    ListValue(node) {
+        return '[' + node.values.map(print).join(', ') + ']';
+    },
+    ObjectValue(node) {
+        return '{' + node.fields.map(print).join(', ') + '}';
+    },
+    ObjectField(node) {
+        return node.name.value + ': ' + print(node.value);
+    },
+    SelectionSet(node) {
+        return block(node.selections.map(print));
+    },
+    Argument(node) {
+        return node.name.value + ': ' + print(node.value);
+    },
+    FragmentSpread(node) {
+        return join(['...', print(node.name), join(node.directives?.map(print), ' ')], ' ');
+    },
+    InlineFragment(node) {
+        return join([
+            '...',
+            node.typeCondition ? 'on ' + node.typeCondition.name.value : '',
+            join(node.directives?.map(print), ' '),
+            print(node.selectionSet),
+        ], ' ');
+    },
+    FragmentDefinition(node) {
+        return join([
+            'fragment',
+            print(node.name),
+            'on',
+            node.typeCondition.name.value,
+            join(node.directives?.map(print), ' '),
+            print(node.selectionSet),
+        ]);
+    },
+    Directive(node) {
+        return '@' + node.name.value + printArgs(node.arguments);
+    },
+    NamedType(node) {
+        return node.name.value;
+    },
+    ListType(node) {
+        return '[' + print(node.type) + ']';
+    },
+    NonNullType(node) {
+        return print(node.type) + '!';
+    },
+    SchemaDefinition(node) {
+        return join(['schema', join(node.directives?.map(print), ' '), block(node.operationTypes?.map(print))], ' ');
+    },
+    OperationTypeDefinition(node) {
+        return node.operation + ': ' + print(node.type);
+    },
+    ScalarTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join(['scalar', print(node.name), join(node.directives?.map(print), ' ')], ' '));
+    },
+    ObjectTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'type',
+                print(node.name),
+                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    InterfaceTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'interface',
+                print(node.name),
+                wrap('implements ', join(node.interfaces?.map(print), ' & ')),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    InputObjectTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'input',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                block(node.fields?.map(print)),
+            ], ' '));
+    },
+    UnionTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'union',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                wrap('= ', join(node.types?.map(print), ' | ')),
+            ], ' '));
+    },
+    EnumTypeDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                'enum',
+                print(node.name),
+                join(node.directives?.map(print), ' '),
+                block(node.values?.map(print)),
+            ], ' '));
+    },
+    EnumValueDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([print(node.name), join(node.directives?.map(print), ' ')], ' '));
+    },
+    FieldDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            print(node.name) +
+            printArgs(node.arguments) +
+            ': ' +
+            print(node.type) +
+            wrap(' ', join(node.directives?.map(print), ' ')));
+    },
+    InputValueDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            join([
+                print(node.name) + ': ' + print(node.type),
+                wrap('= ', print(node.defaultValue)),
+                join(node.directives?.map(print), ' '),
+            ], ' '));
+    },
+    DirectiveDefinition(node) {
+        return (wrap('', print(node.description), '\n') +
+            'directive @' +
+            print(node.name) +
+            printArgs(node.arguments) +
+            (node.repeatable ? ' repeatable' : '') +
+            ' on ' +
+            join(node.locations?.map(print), ' | '));
+    },
+    SchemaExtension() {
+        return '';
+    },
+    ScalarTypeExtension() {
+        return '';
+    },
+    ObjectTypeExtension() {
+        return '';
+    },
+    InterfaceTypeExtension() {
+        return '';
+    },
+    UnionTypeExtension() {
+        return '';
+    },
+    EnumTypeExtension() {
+        return '';
+    },
+    InputObjectTypeExtension() {
+        return '';
+    },
+};
+export function print(node) {
+    if (!node) {
+        return '';
+    }
+    return nodes[node.kind] ? nodes[node.kind](node) : '';
+}
+function printArgs(nodes) {
+    if (!nodes || nodes.length === 0) {
+        return '';
+    }
+    const args = nodes.map(print);
+    const argsLine = '(' + args.join(', ') + ') ';
+    return argsLine.length > 80 ? '(\n  ' + args.join('\n').replace(/\n/g, '\n  ') + '\n)' : argsLine;
+}
+function block(array) {
+    return wrap('{\n', indent(join(array, '\n')), '\n}');
+}
+function indent(str) {
+    return wrap('  ', str.replaceAll('\n', '\n  '));
+}
+function wrap(start, maybeString, end = '') {
+    return maybeString != null && maybeString !== '' ? start + maybeString + end : '';
+}
+function join(maybeArray, separator = '') {
+    return maybeArray?.filter(x => x).join(separator) ?? '';
+}

package/esm/graphql/type-node-info.js

@@ -0,0 +1,137 @@
+import { Kind, } from 'graphql';
+function getEnterLeaveForKind(visitor, kind) {
+    const kindVisitor = visitor[kind];
+    if (typeof kindVisitor === 'object') {
+        return kindVisitor;
+    }
+    if (typeof kindVisitor === 'function') {
+        return { enter: kindVisitor, leave: undefined };
+    }
+    return { enter: visitor.enter, leave: visitor.leave };
+}
+function isNode(maybeNode) {
+    const maybeKind = maybeNode?.kind;
+    return typeof maybeKind === 'string';
+}
+export class TypeNodeInfo {
+    _type;
+    _field;
+    _arg;
+    _value;
+    constructor() {
+        this._type = undefined;
+        this._field = undefined;
+        this._arg = undefined;
+        this._value = undefined;
+    }
+    get [Symbol.toStringTag]() {
+        return 'TypeNodeInfo';
+    }
+    getTypeDef() {
+        return this._type;
+    }
+    getFieldDef() {
+        return this._field;
+    }
+    getArgumentDef() {
+        return this._arg;
+    }
+    getValueDef() {
+        return this._value;
+    }
+    enter(node) {
+        switch (node.kind) {
+            case Kind.OBJECT_TYPE_DEFINITION:
+            case Kind.OBJECT_TYPE_EXTENSION:
+            case Kind.INTERFACE_TYPE_DEFINITION:
+            case Kind.INTERFACE_TYPE_EXTENSION:
+            case Kind.UNION_TYPE_DEFINITION:
+            case Kind.UNION_TYPE_EXTENSION:
+            case Kind.ENUM_TYPE_DEFINITION:
+            case Kind.ENUM_TYPE_EXTENSION:
+            case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case Kind.SCALAR_TYPE_DEFINITION:
+            case Kind.SCALAR_TYPE_EXTENSION:
+            case Kind.DIRECTIVE_DEFINITION:
+                this._type = node;
+                break;
+            case Kind.ENUM_VALUE_DEFINITION:
+                this._value = node;
+                break;
+            case Kind.FIELD_DEFINITION:
+                this._field = node;
+                break;
+            case Kind.INPUT_VALUE_DEFINITION:
+                if (this._field) {
+                    this._arg = node;
+                }
+                else {
+                    this._field = node;
+                }
+                break;
+            default:
+        }
+    }
+    leave(node) {
+        switch (node.kind) {
+            case Kind.OBJECT_TYPE_DEFINITION:
+            case Kind.OBJECT_TYPE_EXTENSION:
+            case Kind.INTERFACE_TYPE_DEFINITION:
+            case Kind.INTERFACE_TYPE_EXTENSION:
+            case Kind.UNION_TYPE_DEFINITION:
+            case Kind.UNION_TYPE_EXTENSION:
+            case Kind.ENUM_TYPE_DEFINITION:
+            case Kind.ENUM_TYPE_EXTENSION:
+            case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case Kind.SCALAR_TYPE_DEFINITION:
+            case Kind.SCALAR_TYPE_EXTENSION:
+            case Kind.DIRECTIVE_DEFINITION:
+                this._type = undefined;
+                break;
+            case Kind.FIELD_DEFINITION:
+                this._field = undefined;
+                break;
+            case Kind.ENUM_VALUE_DEFINITION:
+                this._value = undefined;
+                break;
+            case Kind.INPUT_VALUE_DEFINITION:
+                if (this._arg) {
+                    this._arg = undefined;
+                }
+                else {
+                    this._field = undefined;
+                }
+                break;
+            default:
+        }
+    }
+}
+export function visitWithTypeNodeInfo(typeInfo, visitor) {
+    return {
+        enter(node, key, parent, path, ancestors) {
+            typeInfo.enter(node);
+            const fn = getEnterLeaveForKind(visitor, node.kind).enter;
+            if (fn) {
+                const result = fn.call(visitor, node, key, parent, path, ancestors);
+                if (result !== undefined) {
+                    typeInfo.leave(node);
+                    if (isNode(result)) {
+                        typeInfo.enter(result);
+                    }
+                }
+                return result;
+            }
+        },
+        leave(node, key, parent, path, ancestors) {
+            const fn = getEnterLeaveForKind(visitor, node.kind).leave;
+            let result;
+            if (fn) {
+                result = fn.call(visitor, node, key, parent, path, ancestors);
+            }
+            typeInfo.leave(node);
+            return result;
+        },
+    };
+}

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './compose.js';
+export * from './types.js';
+export * from './validate.js';
+export { stripFederationFromSupergraph } from './graphql/helpers.js';

package/esm/specifications/federation.js

@@ -0,0 +1,204 @@
+import { GraphQLError, Kind, parse, specifiedDirectives, specifiedScalarTypes, } from 'graphql';
+import { print } from '../graphql/printer.js';
+import { directive as inaccessibleDirective } from './inaccessible.js';
+import { parseLink } from './link.js';
+import { directive as tagDirective } from './tag.js';
+export function isFederationVersion(version) {
+    return version in federationSpecFactory;
+}
+export function createSpecSchema(version, imports) {
+    if (!isFederationVersion(version)) {
+        throw new GraphQLError(`Invalid version ${version} for the federation feature in @link direction on schema`, {
+            extensions: {
+                code: 'UNKNOWN_FEDERATION_LINK_VERSION',
+            },
+        });
+    }
+    if (version !== 'v1.0') {
+        const spec = federationSpecFactory[version]('', imports);
+        const namespacedSpec = federationSpecFactory[version]('federation__');
+        return {
+            directives: spec.directives.concat(namespacedSpec.directives),
+            types: spec.types.concat(namespacedSpec.types),
+        };
+    }
+    const spec = federationSpecFactory[version]('');
+    return {
+        directives: spec.directives.concat([tagDirective, inaccessibleDirective]),
+        types: spec.types,
+    };
+}
+const federationSpecFactory = {
+    'v1.0': (prefix) => createTypeDefinitions(`
+        directive @key(
+          fields: _FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+        directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @extends on OBJECT | INTERFACE
+        # @override is not supported in v1 but somehow it's supported by Apollo Composition
+        directive @override(from: String!) on FIELD_DEFINITION
+        scalar _FieldSet
+      `, prefix),
+    'v2.0': (prefix, imports) => createTypeDefinitions(`
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @shareable on FIELD_DEFINITION | OBJECT
+        directive @extends on OBJECT | INTERFACE
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.1': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.2': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable repeatable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+    'v2.3': (prefix, imports) => createTypeDefinitions(`
+        directive @composeDirective(name: String!) repeatable on SCHEMA
+        directive @extends on OBJECT | INTERFACE
+        directive @external on OBJECT | FIELD_DEFINITION
+        directive @key(
+          fields: FieldSet!
+          resolvable: Boolean = true
+        ) repeatable on OBJECT | INTERFACE
+        directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+        directive @interfaceObject on OBJECT
+        directive @override(from: String!) on FIELD_DEFINITION
+        directive @provides(fields: FieldSet!) on FIELD_DEFINITION
+        directive @requires(fields: FieldSet!) on FIELD_DEFINITION
+        directive @shareable repeatable on FIELD_DEFINITION | OBJECT
+        directive @tag(
+          name: String!
+        ) repeatable on FIELD_DEFINITION | INTERFACE | OBJECT | UNION | ARGUMENT_DEFINITION | SCALAR | ENUM | ENUM_VALUE | INPUT_OBJECT | INPUT_FIELD_DEFINITION
+        scalar FieldSet
+      `, prefix, imports),
+};
+function createTypeDefinitions(doc, prefix, imports) {
+    const shouldFilter = !!imports;
+    const toInclude = new Set(imports?.map(i => i.name.replace(/^@/, '')));
+    const docAST = parse(doc, {
+        noLocation: true,
+    });
+    if (!imports?.length ||
+        toInclude.has('key') ||
+        toInclude.has('requires') ||
+        toInclude.has('provides')) {
+        toInclude.add('FieldSet');
+        toInclude.add('federation__FieldSet');
+    }
+    const directives = [];
+    const types = [];
+    for (const node of docAST.definitions) {
+        if (isDirectiveDefinitionNode(node)) {
+            directives.push(applyPrefix(node, prefix));
+        }
+        else {
+            types.push(applyPrefix(node, prefix));
+        }
+    }
+    return {
+        directives: directives.filter(d => !specifiedDirectives.some(sd => sd.name === d.name.value) &&
+            (!shouldFilter || toInclude.has(d.name.value))),
+        types: types.filter(t => toInclude.has(t.name.value)),
+    };
+}
+function isDirectiveDefinitionNode(node) {
+    return node.kind === Kind.DIRECTIVE_DEFINITION;
+}
+function applyPrefix(node, prefix) {
+    if (prefix.length === 0) {
+        return node;
+    }
+    node.name.value = `${prefix}${node.name.value}`;
+    if (isDirectiveDefinitionNode(node)) {
+        node.arguments?.forEach(arg => {
+            const nameNode = resolveNamedType(arg.type);
+            if (!specifiedScalarTypes.some(t => t.name === nameNode.value)) {
+                nameNode.value = `${prefix}${nameNode.value}`;
+            }
+        });
+    }
+    return node;
+}
+function resolveNamedType(node) {
+    if (node.kind === Kind.LIST_TYPE) {
+        return resolveNamedType(node.type);
+    }
+    if (node.kind === Kind.NON_NULL_TYPE) {
+        return resolveNamedType(node.type);
+    }
+    return node.name;
+}
+export function isFederationLink(link) {
+    return link.identity === 'https://specs.apollo.dev/federation';
+}
+export function detectFederationVersion(typeDefs) {
+    for (const definition of typeDefs.definitions) {
+        if (definition.kind === Kind.SCHEMA_EXTENSION || definition.kind === Kind.SCHEMA_DEFINITION) {
+            const links = definition.directives?.filter(directive => directive.name.value === 'link');
+            if (links?.length) {
+                const parsedLinks = links.map(l => {
+                    const url = l.arguments?.find(a => a.name.value === 'url');
+                    const importArg = l.arguments?.find(a => a.name.value === 'import');
+                    if (!url) {
+                        throw new Error('Invalid @link directive');
+                    }
+                    return parseLink(url.value.value, importArg ? print(importArg.value) : '[]');
+                });
+                const fedLink = parsedLinks.find(l => l.identity === 'https://specs.apollo.dev/federation');
+                if (fedLink?.version) {
+                    if (!isFederationVersion(fedLink.version)) {
+                        throw new Error(`Unsupported federation version: ${fedLink.version}`);
+                    }
+                    return {
+                        version: fedLink.version,
+                        imports: fedLink.imports,
+                    };
+                }
+            }
+        }
+    }
+    return { version: 'v1.0', imports: [] };
+}

package/esm/specifications/inaccessible.js

@@ -0,0 +1,7 @@
+import { parse } from 'graphql';
+import { isDirectiveDefinition } from '../graphql/helpers.js';
+export const sdl = `
+  directive @inaccessible on FIELD_DEFINITION | OBJECT | INTERFACE | UNION | ENUM | ENUM_VALUE | SCALAR | INPUT_OBJECT | INPUT_FIELD_DEFINITION | ARGUMENT_DEFINITION
+`;
+export const typeDefs = parse(sdl);
+export const directive = typeDefs.definitions.filter(isDirectiveDefinition)[0];

package/esm/specifications/join.js

@@ -0,0 +1,32 @@
+export const sdl = `
+  directive @join__enumValue(graph: join__Graph!) repeatable on ENUM_VALUE
+
+  directive @join__field(
+    graph: join__Graph
+    requires: join__FieldSet
+    provides: join__FieldSet
+    type: String
+    external: Boolean
+    override: String
+    usedOverridden: Boolean
+  ) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
+
+  directive @join__graph(name: String!, url: String!) on ENUM_VALUE
+
+  directive @join__implements(
+    graph: join__Graph!
+    interface: String!
+  ) repeatable on OBJECT | INTERFACE
+
+  directive @join__type(
+    graph: join__Graph!
+    key: join__FieldSet
+    extension: Boolean! = false
+    resolvable: Boolean! = true
+    isInterfaceObject: Boolean! = false
+  ) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR
+
+  directive @join__unionMember(graph: join__Graph!, member: String!) repeatable on UNION
+
+  scalar join__FieldSet
+`;