@theguild/federation-composition 0.9.0 → 0.10.0

package/cjs/supergraph/validation/validate-supergraph.js

@@ -30,7 +30,7 @@ const validation_context_js_1 = require("./validation-context.js");
 function validateSupergraph(subgraphStates, state, __internal) {
     const context = (0, validation_context_js_1.createSupergraphValidationContext)(subgraphStates);
     for (const subgraphState of subgraphStates.values()) {
-        state.addGraph(subgraphState.graph);
+        state.addSubgraph(subgraphState);
     }
     const preSupergraphRules = [required_query_rule_js_1.RequiredQueryRule, types_of_the_same_kind_rule_js_1.TypesOfTheSameKindRule];
     const rulesToSkip = __internal?.disableValidationRules ?? [];

package/cjs/utils/logger.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LoggerContext = void 0;
+const debug_1 = __importDefault(require("debug"));
+const originalFormatArgs = debug_1.default.formatArgs;
+debug_1.default.formatArgs = function (args) {
+    originalFormatArgs.call(this, args);
+    const line = args[0];
+    const noColorsPrefix = ` ${this.namespace} `;
+    const colorsPrefix = `${this.namespace}`;
+    const noColorsStartsAt = line.indexOf(noColorsPrefix);
+    if (noColorsStartsAt > -1) {
+        args[0] = line.slice(noColorsStartsAt + noColorsPrefix.length);
+    }
+    else {
+        const colorsStartsAt = line.indexOf(colorsPrefix);
+        args[0] = line.slice(colorsStartsAt + colorsPrefix.length);
+    }
+};
+class LoggerContext {
+    indent = {
+        level: 0,
+        str: '',
+        times: [],
+    };
+    maxIdLength = 0;
+    idUpdateFns = [];
+    logger = (0, debug_1.default)('composition');
+    firstLoggerAt = 0;
+    down(time) {
+        this.updateIndent(+1, time);
+    }
+    up(time) {
+        if (this.indent.level > 0) {
+            this.updateIndent(-1, time);
+            return this.indent.times.pop();
+        }
+    }
+    getTime() {
+        if (!this.firstLoggerAt) {
+            this.firstLoggerAt = Date.now();
+            return 0;
+        }
+        return Date.now() - this.firstLoggerAt;
+    }
+    getIndent() {
+        return this.indent;
+    }
+    register(id, idUpdateFn) {
+        idUpdateFn(this.maxIdLength);
+        this.idUpdateFns.push(idUpdateFn);
+        const newMaxIdLength = Math.max(this.maxIdLength, id.length);
+        if (newMaxIdLength > this.maxIdLength) {
+            this.maxIdLength = newMaxIdLength;
+            this.idUpdateFns.forEach(fn => fn(newMaxIdLength));
+        }
+        return this.logger.extend(id);
+    }
+    updateIndent(delta, time) {
+        if (this.indent.level + delta < 0) {
+            return;
+        }
+        if (delta > 0) {
+            this.indent.times.push(time);
+        }
+        this.indent.level += delta;
+        this.indent.str = '│ '.repeat(this.indent.level);
+    }
+}
+exports.LoggerContext = LoggerContext;
+class Logger {
+    id;
+    context;
+    isEnabled;
+    debug;
+    idPrefix;
+    constructor(id, context) {
+        this.id = id;
+        this.context = context;
+        this.id = id;
+        this.context = context;
+        this.idPrefix = `${id}`;
+        this.debug = this.context.register(this.id, this._updateIdPrefix.bind(this));
+        this.isEnabled = this.debug.enabled;
+        this.debug.log = console.log;
+    }
+    log(msg, prefix = '- ') {
+        if (this.isEnabled) {
+            this._log(prefix, msg);
+        }
+    }
+    group(msg) {
+        if (this.isEnabled) {
+            this.log(msg, '┌ ');
+            this.context.down(Date.now());
+        }
+    }
+    groupEnd(msg) {
+        if (this.isEnabled) {
+            const time = this.context.up(Date.now());
+            let message = msg ? (typeof msg === 'string' ? msg : msg()) : '';
+            if (time) {
+                message += ` (${Date.now() - time}ms)`;
+            }
+            this.log(message, '└ ');
+        }
+    }
+    create(id) {
+        return new Logger(id, this.context);
+    }
+    _log(prefix, msg) {
+        const indent = this.context.getIndent().str;
+        const message = typeof msg === 'string' ? msg : msg();
+        if (this.isEnabled) {
+            const sinceStart = this.context.getTime();
+            const text = this.idPrefix + ' ' + indent + prefix + message + ` +${sinceStart}ms`;
+            this.debug(text);
+        }
+    }
+    _updateIdPrefix(maxLength) {
+        this.idPrefix = this.id.padEnd(maxLength, ' ');
+    }
+}
+exports.Logger = Logger;

package/esm/specifications/link.js

@@ -28,10 +28,41 @@ export function printLink(link) {
                 },
                 value: {
                     kind: Kind.LIST,
-                    values: link.imports.map(im => ({
-                        kind: Kind.STRING,
-                        value: im.name,
-                    })),
+                    values: link.imports.map(im => {
+                        if (!im.alias) {
+                            return {
+                                kind: Kind.STRING,
+                                value: im.name,
+                            };
+                        }
+                        return {
+                            kind: Kind.OBJECT,
+                            fields: [
+                                {
+                                    kind: Kind.OBJECT_FIELD,
+                                    name: {
+                                        kind: Kind.NAME,
+                                        value: 'name',
+                                    },
+                                    value: {
+                                        kind: Kind.STRING,
+                                        value: im.name,
+                                    },
+                                },
+                                {
+                                    kind: Kind.OBJECT_FIELD,
+                                    name: {
+                                        kind: Kind.NAME,
+                                        value: 'as',
+                                    },
+                                    value: {
+                                        kind: Kind.STRING,
+                                        value: im.alias,
+                                    },
+                                },
+                            ],
+                        };
+                    }),
                 },
             },
         ],
@@ -153,7 +184,11 @@ export function mergeLinks(links) {
     return Array.from(groupByIdentity.entries()).map(([identity, link]) => ({
         identity,
         version: link.highestVersion,
-        imports: Array.from(link.imports).map(link => ({ kind: link.kind, name: link.name })),
+        imports: Array.from(link.imports).map(link => ({
+            kind: link.kind,
+            name: link.name,
+            alias: link.alias,
+        })),
         name: link.name,
     }));
 }

package/esm/subgraph/helpers.js

@@ -34,10 +34,10 @@ export function validateDirectiveAgainstOriginal(providedDirectiveNode, directiv
             if (expectedType !== providedType) {
                 const isNonNullableString = providedType === 'String!';
                 const allowedFieldSetTypes = isFederationV2
-                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!']
+                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!', '[String!]!']
                     : ['_FieldSet!', 'String', 'String!'];
                 const fieldSetTypesInSpec = isFederationV2
-                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!']
+                    ? ['FieldSet!', 'federation__FieldSet!', '_FieldSet!', '[String!]!']
                     : ['_FieldSet!', 'FieldSet!', 'String'];
                 const expectsFieldSet = fieldSetTypesInSpec.includes(expectedType);
                 if (!isNonNullableString && expectsFieldSet) {

package/esm/subgraph/state.js

@@ -101,6 +101,9 @@ export function createSubgraphStateBuilder(graph, typeDefs, version, links) {
                         throw new Error(`Expected to find an object type`);
                     }
                     objectTypeBuilder.field.setType(typeDef.name.value, node.name.value, printOutputType(node.type));
+                    if (typeDef.kind === Kind.OBJECT_TYPE_EXTENSION) {
+                        objectTypeBuilder.field.setExtension(typeDef.name.value, node.name.value);
+                    }
                     if (version === 'v1.0' &&
                         (typeDef.kind === Kind.OBJECT_TYPE_DEFINITION ||
                             typeDef.name.value === expectedQueryTypeName ||
@@ -590,6 +593,9 @@ function objectTypeFactory(state, renameObject) {
             setType(typeName, fieldName, fieldType) {
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).type = fieldType;
             },
+            setExtension(typeName, fieldName) {
+                getOrCreateObjectField(state, renameObject, typeName, fieldName).extension = true;
+            },
             setDirective(typeName, fieldName, directive) {
                 getOrCreateObjectField(state, renameObject, typeName, fieldName).ast.directives.push(directive);
             },
@@ -1102,6 +1108,7 @@ function getOrCreateObjectField(state, renameObject, typeName, fieldName) {
         external: false,
         inaccessible: false,
         authenticated: false,
+        extension: false,
         policies: [],
         scopes: [],
         used: false,
@@ -1141,6 +1148,7 @@ function getOrCreateInterfaceField(state, typeName, fieldName) {
         required: false,
         provided: false,
         shareable: false,
+        extension: false,
         tags: new Set(),
         args: new Map(),
         ast: {

package/esm/subgraph/validation/rules/elements/provides.js

@@ -103,12 +103,14 @@ export function ProvidesRules(context) {
                     context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field ${info.typeDefinition.name.value}.${info.fieldName} cannot be included because it has arguments (fields with argument are not allowed in @provides)`, { nodes: directiveNode, extensions: { code: 'PROVIDES_FIELDS_HAS_ARGS' } }));
                 },
                 interceptNonExternalField(info) {
-                    isValid = false;
-                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)`, {
-                        extensions: {
-                            code: 'PROVIDES_FIELDS_MISSING_EXTERNAL',
-                        },
-                    }));
+                    if (context.satisfiesVersionRange('> v1.0')) {
+                        isValid = false;
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @provides(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)`, {
+                            extensions: {
+                                code: 'PROVIDES_FIELDS_MISSING_EXTERNAL',
+                            },
+                        }));
+                    }
                 },
                 interceptExternalField(info) {
                     const keyDirectives = info.typeDefinition.directives?.filter(directive => context.isAvailableFederationDirective('key', directive));

package/esm/subgraph/validation/rules/elements/requires.js

@@ -30,7 +30,7 @@ export function RequiresRules(context) {
                 return;
             }
             const printedFieldsValue = print(fieldsArg.value);
-            if (fieldsArg.value.kind !== Kind.STRING) {
+            if (fieldsArg.value.kind !== Kind.STRING && fieldsArg.value.kind !== Kind.ENUM) {
                 context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): Invalid value for argument "fields": must be a string.`, {
                     nodes: directiveNode,
                     extensions: {
@@ -103,12 +103,14 @@ export function RequiresRules(context) {
                     }
                 },
                 interceptNonExternalField(info) {
-                    isValid = false;
-                    context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @requires since it is already provided by this subgraph (it is not marked @external)`, {
-                        extensions: {
-                            code: 'REQUIRES_FIELDS_MISSING_EXTERNAL',
-                        },
-                    }));
+                    if (context.satisfiesVersionRange('> v1.0')) {
+                        isValid = false;
+                        context.reportError(new GraphQLError(`On field "${fieldCoordinate}", for @requires(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" should not be part of a @requires since it is already provided by this subgraph (it is not marked @external)`, {
+                            extensions: {
+                                code: 'REQUIRES_FIELDS_MISSING_EXTERNAL',
+                            },
+                        }));
+                    }
                 },
             });
             if (isValid) {

package/esm/subgraph/validation/validate-state.js

@@ -3,7 +3,7 @@ import { andList } from '../../utils/format.js';
 import { isList, isNonNull, stripList, stripNonNull, stripTypeModifiers, } from '../../utils/state.js';
 import { TypeKind, } from '../state.js';
 const specifiedScalars = new Set(specifiedScalarTypes.map(t => t.name));
-export function validateSubgraphState(state) {
+export function validateSubgraphState(state, context) {
     const errors = [];
     function reportError(message) {
         errors.push(new GraphQLError(message, {
@@ -13,7 +13,7 @@ export function validateSubgraphState(state) {
         }));
     }
     validateRootTypes(state, reportError);
-    validateDirectives(state, reportError);
+    validateDirectives(state, reportError, context);
     validateTypes(state, reportError);
     return errors;
 }
@@ -54,13 +54,19 @@ function validateRootTypes(state, reportError) {
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
 }
-function validateDirectives(state, reportError) {
+function validateDirectives(state, reportError, context) {
     for (const directive of state.types.values()) {
         if (isDirective(directive)) {
+            if (context.isLinkSpecDirective(directive.name)) {
+                continue;
+            }
             validateName(reportError, directive.name);
             for (const [argName, arg] of directive.args) {
                 validateName(reportError, argName);
                 const argInputTypeName = stripTypeModifiers(arg.type);
+                if (context.isLinkSpecType(argInputTypeName)) {
+                    continue;
+                }
                 if (!isInputType(state, argInputTypeName)) {
                     reportError(`The type of @${directive.name}(${arg.name}:) must be Input Type ` +
                         `but got: ${arg.type}.`);

package/esm/subgraph/validation/validate-subgraph.js

@@ -157,7 +157,7 @@ export function validateSubgraph(subgraph, stateBuilder, federation, __internal)
             : null,
         subgraph.typeDefs,
     ].filter(onlyDocumentNode));
-    const subgraphStateErrors = validateSubgraphState(stateBuilder.state);
+    const subgraphStateErrors = validateSubgraphState(stateBuilder.state, validationContext);
     const simpleValidationContext = createSimpleValidationContext(fullTypeDefs, typeNodeInfo);
     visit(fullTypeDefs, visitInParallel(graphqlRules.map(rule => {
         if (rulesToSkip.includes(rule.name)) {
@@ -316,7 +316,9 @@ function cleanSubgraphTypeDefsFromSubgraphSpec(typeDefs) {
     const queryTypeName = schemaDef?.operationTypes?.find(op => op.operation === OperationTypeNode.QUERY)?.type.name
         .value ?? 'Query';
     typeDefs.definitions = typeDefs.definitions.filter(def => {
-        if (def.kind === Kind.SCALAR_TYPE_DEFINITION && def.name.value === '_Any') {
+        if ((def.kind === Kind.SCALAR_TYPE_DEFINITION ||
+            def.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION) &&
+            def.name.value === '_Any') {
             return false;
         }
         if (def.kind === Kind.UNION_TYPE_DEFINITION && def.name.value === '_Entity') {

package/esm/subgraph/validation/validation-context.js

@@ -1,7 +1,11 @@
-import { Kind, specifiedScalarTypes, } from 'graphql';
+import { isTypeDefinitionNode, Kind, parse, specifiedScalarTypes, } from 'graphql';
 import { createSpecSchema } from '../../specifications/federation.js';
+import { sdl as linkSpecSdl } from '../../specifications/link.js';
 import { stripTypeModifiers } from '../../utils/state.js';
 import { TypeKind } from '../state.js';
+const linkSpec = parse(linkSpecSdl);
+const linkSpecDirectives = linkSpec.definitions.filter((def) => def.kind === Kind.DIRECTIVE_DEFINITION);
+const linkSpecTypes = linkSpec.definitions.filter(isTypeDefinitionNode);
 export function createSimpleValidationContext(typeDefs, typeNodeInfo) {
     let reportedErrors = [];
     const directiveDefinitionMap = new Map();
@@ -151,6 +155,12 @@ export function createSubgraphValidationContext(subgraph, federation, typeNodeIn
     }
     return {
         stateBuilder,
+        isLinkSpecDirective(name) {
+            return linkSpecDirectives.some(d => d.name.value === name);
+        },
+        isLinkSpecType(name) {
+            return linkSpecTypes.some(t => t.name.value === name);
+        },
         isAvailableFederationType(name) {
             const alternativeNames = typeAlternativeNamesMap.get(name);
             if (alternativeNames) {

package/esm/supergraph/composition/directive.js

@@ -28,11 +28,13 @@ export function directiveBuilder() {
                 argState.byGraph.set(graph.id, {
                     type: arg.type,
                     defaultValue: arg.defaultValue,
+                    version: graph.version,
                 });
             }
             directiveState.byGraph.set(graph.id, {
                 locations: directive.locations,
                 repeatable: directive.repeatable,
+                version: graph.version,
             });
         },
         composeSupergraphNode(directive) {
@@ -60,6 +62,7 @@ function getOrCreateDirective(state, directiveName) {
         return existing;
     }
     const def = {
+        kind: 'directive',
         name: directiveName,
         locations: new Set(),
         byGraph: new Map(),

package/esm/supergraph/composition/enum-type.js

@@ -36,6 +36,7 @@ export function enumTypeBuilder() {
             }
             enumTypeState.byGraph.set(graph.id, {
                 inaccessible: type.inaccessible,
+                version: graph.version,
             });
             for (const value of type.values.values()) {
                 const valueState = getOrCreateEnumValue(enumTypeState, value.name);
@@ -51,6 +52,7 @@ export function enumTypeBuilder() {
                 }
                 valueState.byGraph.set(graph.id, {
                     inaccessible: value.inaccessible,
+                    version: graph.version,
                 });
             }
         },
@@ -110,6 +112,7 @@ function getOrCreateEnumType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'enum',
         name: typeName,
         values: new Map(),
         tags: new Set(),

package/esm/supergraph/composition/input-object-type.js

@@ -16,6 +16,7 @@ export function inputObjectTypeBuilder() {
             }
             inputObjectTypeState.byGraph.set(graph.id, {
                 inaccessible: type.inaccessible,
+                version: graph.version,
             });
             for (const field of type.fields.values()) {
                 const fieldState = getOrCreateField(inputObjectTypeState, field.name, field.type);
@@ -39,6 +40,7 @@ export function inputObjectTypeBuilder() {
                     type: field.type,
                     inaccessible: field.inaccessible,
                     defaultValue: field.defaultValue,
+                    version: graph.version,
                 });
             }
         },
@@ -91,6 +93,7 @@ function getOrCreateInputObjectType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'input',
         name: typeName,
         tags: new Set(),
         hasDefinition: false,

package/esm/supergraph/composition/interface-type.js

@@ -33,6 +33,7 @@ export function interfaceTypeBuilder() {
                 keys: type.keys,
                 interfaces: type.interfaces,
                 implementedBy: type.implementedBy,
+                version: graph.version,
             });
             for (const field of type.fields.values()) {
                 const fieldState = getOrCreateInterfaceField(interfaceTypeState, field.name, field.type);
@@ -66,6 +67,7 @@ export function interfaceTypeBuilder() {
                     override: field.override,
                     provides: field.provides,
                     requires: field.requires,
+                    version: graph.version,
                 });
                 for (const arg of field.args.values()) {
                     const argState = getOrCreateArg(fieldState, arg.name, arg.type);
@@ -88,6 +90,7 @@ export function interfaceTypeBuilder() {
                     argState.byGraph.set(graph.id, {
                         type: arg.type,
                         defaultValue: arg.defaultValue,
+                        version: graph.version,
                     });
                 }
             }
@@ -193,6 +196,7 @@ function getOrCreateInterfaceType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'interface',
         name: typeName,
         tags: new Set(),
         inaccessible: false,

package/esm/supergraph/composition/object-type.js

@@ -59,6 +59,7 @@ export function objectTypeBuilder() {
                 inaccessible: type.inaccessible,
                 shareable: type.shareable,
                 interfaces: type.interfaces,
+                version: graph.version,
             });
             const typeInGraph = objectTypeState.byGraph.get(graph.id);
             for (const field of type.fields.values()) {
@@ -116,8 +117,10 @@ export function objectTypeBuilder() {
                     provided: field.provided,
                     required: field.required,
                     shareable: field.shareable,
+                    extension: field.extension,
                     used: field.used,
                     usedAsKey,
+                    version: graph.version,
                 });
                 for (const arg of field.args.values()) {
                     const argState = getOrCreateArg(fieldState, arg.name, arg.type);
@@ -144,6 +147,7 @@ export function objectTypeBuilder() {
                         type: arg.type,
                         inaccessible: arg.inaccessible,
                         defaultValue: arg.defaultValue,
+                        version: graph.version,
                     });
                 }
             }
@@ -153,7 +157,7 @@ export function objectTypeBuilder() {
             const joinTypes = isQuery
                 ?
                     Array.from(graphs.values()).map(graph => ({
-                        graph: graph.id,
+                        graph: graph.graph.id,
                     }))
                 :
                     Array.from(objectType.byGraph.entries())
@@ -216,12 +220,12 @@ export function objectTypeBuilder() {
                 }
                 return true;
             }
-            function createJoinFields(fieldInGraphs, field, { hasDifferentOutputType, overridesMap, }) {
+            function createJoinFields(fieldInGraphs, field, { hasDifferentOutputType, }) {
                 return fieldInGraphs
                     .map(([graphId, meta]) => {
                     const type = hasDifferentOutputType ? meta.type : undefined;
                     const override = meta.override ?? undefined;
-                    const usedOverridden = provideUsedOverriddenValue(field.name, meta, overridesMap, fieldNamesOfImplementedInterfaces, graphId);
+                    const usedOverridden = provideUsedOverriddenValue(field, meta, fieldNamesOfImplementedInterfaces, graphId, graphNameToId);
                     const external = shouldSetExternalOnJoinField(meta, graphId, field);
                     const provides = meta.provides ?? undefined;
                     const requires = meta.requires ?? undefined;
@@ -257,7 +261,6 @@ export function objectTypeBuilder() {
                     const hasDifferentOutputType = fieldInGraphs.some(([_, meta]) => meta.type !== field.type);
                     const isDefinedEverywhere = field.byGraph.size === (isQuery ? graphs.size : objectType.byGraph.size);
                     let joinFields = [];
-                    const overridesMap = {};
                     const differencesBetweenGraphs = {
                         override: false,
                         type: false,
@@ -273,10 +276,6 @@ export function objectTypeBuilder() {
                         }
                         if (meta.override !== null) {
                             differencesBetweenGraphs.override = true;
-                            const originalGraphId = graphNameToId(meta.override);
-                            if (originalGraphId) {
-                                overridesMap[originalGraphId] = graphId;
-                            }
                         }
                         if (meta.provides !== null) {
                             differencesBetweenGraphs.provides = true;
@@ -295,7 +294,7 @@ export function objectTypeBuilder() {
                             !fieldInGraph.usedAsKey &&
                             !fieldInGraph.required &&
                             !fieldInGraph.provided &&
-                            !provideUsedOverriddenValue(field.name, fieldInGraph, overridesMap, fieldNamesOfImplementedInterfaces, graphId) &&
+                            !provideUsedOverriddenValue(field, fieldInGraph, fieldNamesOfImplementedInterfaces, graphId, graphNameToId) &&
                             graphs.get(graphId).version === 'v1.0') {
                             return null;
                         }
@@ -311,7 +310,7 @@ export function objectTypeBuilder() {
                             joinFields = graphsWithOverride.map(([graphId, meta]) => ({
                                 graph: graphId,
                                 override: meta.override ?? undefined,
-                                usedOverridden: provideUsedOverriddenValue(field.name, meta, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
+                                usedOverridden: provideUsedOverriddenValue(field, meta, fieldNamesOfImplementedInterfaces, graphId, graphNameToId),
                                 type: differencesBetweenGraphs.type ? meta.type : undefined,
                                 external: meta.external ?? undefined,
                                 provides: meta.provides ?? undefined,
@@ -339,7 +338,7 @@ export function objectTypeBuilder() {
                             const graphsToEmit = fieldInGraphs.filter(([graphId, f]) => {
                                 const isExternal = f.external === true;
                                 const isOverridden = overriddenGraphs.includes(graphId);
-                                const needsToPrintUsedOverridden = provideUsedOverriddenValue(field.name, f, overridesMap, fieldNamesOfImplementedInterfaces, graphId);
+                                const needsToPrintUsedOverridden = provideUsedOverriddenValue(field, f, fieldNamesOfImplementedInterfaces, graphId, graphNameToId);
                                 const isRequired = f.required === true;
                                 return (isExternal && isRequired) || needsToPrintUsedOverridden || !isOverridden;
                             });
@@ -349,7 +348,7 @@ export function objectTypeBuilder() {
                                 joinFields = graphsToEmit.map(([graphId, meta]) => ({
                                     graph: graphId,
                                     override: meta.override ?? undefined,
-                                    usedOverridden: provideUsedOverriddenValue(field.name, meta, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
+                                    usedOverridden: provideUsedOverriddenValue(field, meta, fieldNamesOfImplementedInterfaces, graphId, graphNameToId),
                                     type: differencesBetweenGraphs.type ? meta.type : undefined,
                                     external: meta.external ?? undefined,
                                     provides: meta.provides ?? undefined,
@@ -360,7 +359,6 @@ export function objectTypeBuilder() {
                         else if (hasDifferencesBetweenGraphs) {
                             joinFields = createJoinFields(fieldInGraphs, field, {
                                 hasDifferentOutputType,
-                                overridesMap,
                             });
                         }
                     }
@@ -372,11 +370,11 @@ export function objectTypeBuilder() {
                             const graphsToPrintJoinField = fieldInGraphs.filter(([graphId, meta]) => meta.override !== null ||
                                 meta.external === true ||
                                 (meta.shareable && !overriddenGraphs.includes(graphId)) ||
-                                provideUsedOverriddenValue(field.name, meta, overridesMap, fieldNamesOfImplementedInterfaces, graphId));
+                                provideUsedOverriddenValue(field, meta, fieldNamesOfImplementedInterfaces, graphId, graphNameToId));
                             joinFields = graphsToPrintJoinField.map(([graphId, meta]) => ({
                                 graph: graphId,
                                 override: meta.override ?? undefined,
-                                usedOverridden: provideUsedOverriddenValue(field.name, meta, overridesMap, fieldNamesOfImplementedInterfaces, graphId),
+                                usedOverridden: provideUsedOverriddenValue(field, meta, fieldNamesOfImplementedInterfaces, graphId, graphNameToId),
                                 type: differencesBetweenGraphs.type ? meta.type : undefined,
                                 external: meta.external ?? undefined,
                                 provides: meta.provides ?? undefined,
@@ -386,7 +384,6 @@ export function objectTypeBuilder() {
                         else {
                             joinFields = createJoinFields(fieldInGraphs, field, {
                                 hasDifferentOutputType,
-                                overridesMap,
                             });
                         }
                     }
@@ -465,12 +462,12 @@ export function objectTypeBuilder() {
         },
     };
 }
-function provideUsedOverriddenValue(fieldName, fieldStateInGraph, overridesMap, fieldNamesOfImplementedInterfaces, graphId) {
-    const inGraphs = fieldNamesOfImplementedInterfaces[fieldName];
+function provideUsedOverriddenValue(field, fieldStateInGraph, fieldNamesOfImplementedInterfaces, graphId, graphNameToId) {
+    const inGraphs = fieldNamesOfImplementedInterfaces[field.name];
     const hasMatchingInterfaceFieldInGraph = inGraphs && inGraphs.has(graphId);
     const isUsedAsNonExternalKey = fieldStateInGraph.usedAsKey && !fieldStateInGraph.external;
-    const hasOverride = typeof overridesMap[graphId] === 'string';
-    if (hasOverride && (isUsedAsNonExternalKey || hasMatchingInterfaceFieldInGraph)) {
+    const isOverridden = field.override && graphNameToId(field.override) === graphId;
+    if (isOverridden && (isUsedAsNonExternalKey || hasMatchingInterfaceFieldInGraph)) {
         return true;
     }
     return false;
@@ -481,6 +478,7 @@ function getOrCreateObjectType(state, typeName) {
         return existing;
     }
     const def = {
+        kind: 'object',
         name: typeName,
         tags: new Set(),
         hasDefinition: false,