@apollo/federation-internals 2.4.11 → 2.5.1

package/dist/extractSubgraphsFromSupergraph.js

@@ -130,286 +130,47 @@ function typesUsedInFederationDirective(fieldSet, parentType) {
     });
     return usedTypes;
 }
-function extractSubgraphsFromSupergraph(supergraph) {
+function extractSubgraphsFromSupergraph(supergraph, validateExtractedSubgraphs = true) {
     const [coreFeatures, joinSpec] = (0, supergraphs_1.validateSupergraph)(supergraph);
     const isFed1 = joinSpec.version.equals(new coreSpec_1.FeatureVersion(0, 1));
     try {
         const [subgraphs, graphEnumNameToSubgraphName] = collectEmptySubgraphs(supergraph, joinSpec);
-        const typeDirective = joinSpec.typeDirective(supergraph);
-        const implementsDirective = joinSpec.implementsDirective(supergraph);
-        const ownerDirective = joinSpec.ownerDirective(supergraph);
-        const fieldDirective = joinSpec.fieldDirective(supergraph);
-        const unionMemberDirective = joinSpec.unionMemberDirective(supergraph);
-        const enumValueDirective = joinSpec.enumValueDirective(supergraph);
         const getSubgraph = (application) => {
             const graph = application.arguments().graph;
-            return graph ? graphEnumNameToSubgraphName.get(graph) : undefined;
+            if (!graph) {
+                return undefined;
+            }
+            const subgraphName = graphEnumNameToSubgraphName.get(graph);
+            (0, utils_1.assert)(subgraphName, () => `Invalid graph name ${graph} found in ${application} on ${application.parent}: does not match a graph defined in the @join__Graph enum`);
+            const subgraph = subgraphs.get(subgraphName);
+            (0, utils_1.assert)(subgraph, 'All subgraphs should have been created by `collectEmptySubgraphs`');
+            return subgraph;
+        };
+        const types = filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition);
+        const args = {
+            supergraph,
+            subgraphs,
+            joinSpec,
+            filteredTypes: types,
+            getSubgraph,
         };
-        let includeTypeInSubgraph = () => true;
         if (isFed1) {
-            const reachableTypesBySubgraph = collectFieldReachableTypesForAllSubgraphs(supergraph, subgraphs.names(), (f, name) => {
-                const fieldApplications = f.appliedDirectivesOf(fieldDirective);
-                if (fieldApplications.length) {
-                    const application = fieldApplications.find((application) => getSubgraph(application) === name);
-                    if (application) {
-                        const args = application.arguments();
-                        const typesInFederationDirectives = typesUsedInFederationDirective(args.provides, (0, definitions_1.baseType)(f.type))
-                            .concat(typesUsedInFederationDirective(args.requires, f.parent));
-                        return { isInSubgraph: true, typesInFederationDirectives };
-                    }
-                    else {
-                        return { isInSubgraph: false, typesInFederationDirectives: [] };
-                    }
-                }
-                else {
-                    const ownerApplications = ownerDirective ? f.parent.appliedDirectivesOf(ownerDirective) : [];
-                    return { isInSubgraph: !ownerApplications.length || getSubgraph(ownerApplications[0]) == name, typesInFederationDirectives: [] };
-                }
-            }, (t, name) => {
-                const typeApplications = t.appliedDirectivesOf(typeDirective);
-                const application = typeApplications.find((application) => (application.arguments().key && (getSubgraph(application) === name)));
-                if (application) {
-                    const typesInFederationDirectives = typesUsedInFederationDirective(application.arguments().key, t);
-                    return { isEntityWithKeyInSubgraph: true, typesInFederationDirectives };
-                }
-                else {
-                    return { isEntityWithKeyInSubgraph: false, typesInFederationDirectives: [] };
-                }
-            });
-            includeTypeInSubgraph = (t, name) => { var _a, _b; return (_b = (_a = reachableTypesBySubgraph.get(name)) === null || _a === void 0 ? void 0 : _a.has(t.name)) !== null && _b !== void 0 ? _b : false; };
-        }
-        for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
-            const typeApplications = type.appliedDirectivesOf(typeDirective);
-            if (!typeApplications.length) {
-                subgraphs
-                    .values()
-                    .filter((sg) => includeTypeInSubgraph(type, sg.name))
-                    .map(sg => sg.schema).forEach(schema => schema.addType((0, definitions_1.newNamedType)(type.kind, type.name)));
-            }
-            else {
-                for (const application of typeApplications) {
-                    const args = application.arguments();
-                    const subgraphName = getSubgraph(application);
-                    const schema = subgraphs.get(subgraphName).schema;
-                    let subgraphType = schema.type(type.name);
-                    if (!subgraphType) {
-                        const kind = args.isInterfaceObject ? 'ObjectType' : type.kind;
-                        subgraphType = schema.addType((0, definitions_1.newNamedType)(kind, type.name));
-                        if (args.isInterfaceObject) {
-                            subgraphType.applyDirective('interfaceObject');
-                        }
-                    }
-                    if (args.key) {
-                        const { resolvable } = args;
-                        const directive = subgraphType.applyDirective('key', { 'fields': args.key, resolvable });
-                        if (args.extension) {
-                            directive.setOfExtension(subgraphType.newExtension());
-                        }
-                    }
-                }
-            }
+            extractSubgraphsFromFed1Supergraph(args);
         }
-        for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
-            switch (type.kind) {
-                case 'ObjectType':
-                case 'InterfaceType':
-                    const addedInterfaces = [];
-                    const implementsApplications = implementsDirective ? type.appliedDirectivesOf(implementsDirective) : [];
-                    for (const application of implementsApplications) {
-                        const args = application.arguments();
-                        const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph));
-                        const schema = subgraph.schema;
-                        schema.type(type.name).addImplementedInterface(args.interface);
-                        addedInterfaces.push(args.interface);
-                    }
-                    for (const implementations of type.interfaceImplementations()) {
-                        const name = implementations.interface.name;
-                        if (!addedInterfaces.includes(name)) {
-                            for (const subgraph of subgraphs) {
-                                const subgraphType = subgraph.schema.type(type.name);
-                                const subgraphItf = subgraph.schema.type(name);
-                                if (subgraphType && subgraphItf) {
-                                    subgraphType.addImplementedInterface(name);
-                                }
-                            }
-                        }
-                    }
-                case 'InputObjectType':
-                    const typeApplications = type.appliedDirectivesOf(typeDirective);
-                    const subgraphsDefiningType = [];
-                    for (const app of typeApplications) {
-                        const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(app.arguments().graph));
-                        if (!subgraphsDefiningType.includes(subgraph)) {
-                            subgraphsDefiningType.push(subgraph);
-                        }
-                    }
-                    for (const field of type.fields()) {
-                        const fieldApplications = field.appliedDirectivesOf(fieldDirective);
-                        if (!fieldApplications.length) {
-                            const ownerApplications = ownerDirective ? type.appliedDirectivesOf(ownerDirective) : [];
-                            if (ownerApplications.length > 0) {
-                                (0, utils_1.assert)(ownerApplications.length == 1, () => `Found multiple join__owner directives on type ${type}`);
-                                const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(ownerApplications[0].arguments().graph));
-                                const subgraphField = addSubgraphField(field, subgraph);
-                                (0, utils_1.assert)(subgraphField, () => `Found join__owner directive on ${type} but no corresponding join__type`);
-                                continue;
-                            }
-                            if (subgraphsDefiningType.length > 0) {
-                                const isShareable = (0, definitions_1.isObjectType)(type) && subgraphsDefiningType.length > 1;
-                                for (const subgraph of subgraphsDefiningType) {
-                                    const subgraphField = addSubgraphField(field, subgraph);
-                                    if (subgraphField && isShareable) {
-                                        subgraphField.applyDirective(subgraph.metadata().shareableDirective());
-                                    }
-                                }
-                            }
-                            else {
-                                const fieldBaseType = (0, definitions_1.baseType)(field.type);
-                                const isShareable = (0, definitions_1.isObjectType)(type) && subgraphs.values().filter((s) => s.schema.type(type.name)).length > 1;
-                                for (const subgraph of subgraphs) {
-                                    if (subgraph.schema.type(fieldBaseType.name)) {
-                                        const subgraphField = addSubgraphField(field, subgraph);
-                                        if (subgraphField && isShareable) {
-                                            subgraphField.applyDirective(subgraph.metadata().shareableDirective());
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        else {
-                            const isShareable = (0, definitions_1.isObjectType)(type)
-                                && fieldApplications.filter((application) => {
-                                    const args = application.arguments();
-                                    return !args.external && !args.usedOverridden;
-                                }).length > 1;
-                            for (const application of fieldApplications) {
-                                const args = application.arguments();
-                                if (!args.graph) {
-                                    continue;
-                                }
-                                const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph));
-                                const subgraphField = addSubgraphField(field, subgraph, args.type);
-                                if (!subgraphField) {
-                                    (0, utils_1.assert)(!includeTypeInSubgraph(type, subgraph.name), () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
-                                    continue;
-                                }
-                                if (args.requires) {
-                                    subgraphField.applyDirective(subgraph.metadata().requiresDirective(), { 'fields': args.requires });
-                                }
-                                if (args.provides) {
-                                    subgraphField.applyDirective(subgraph.metadata().providesDirective(), { 'fields': args.provides });
-                                }
-                                if (args.external) {
-                                    subgraphField.applyDirective(subgraph.metadata().externalDirective());
-                                }
-                                if (args.usedOverridden) {
-                                    subgraphField.applyDirective(subgraph.metadata().externalDirective(), { 'reason': '[overridden]' });
-                                }
-                                if (args.override) {
-                                    subgraphField.applyDirective(subgraph.metadata().overrideDirective(), { 'from': args.override });
-                                }
-                                if (isShareable && !args.external && !args.usedOverridden) {
-                                    subgraphField.applyDirective(subgraph.metadata().shareableDirective());
-                                }
-                            }
-                        }
-                    }
-                    break;
-                case 'EnumType':
-                    for (const subgraph of subgraphs) {
-                        const subgraphEnum = subgraph.schema.type(type.name);
-                        if (!subgraphEnum) {
-                            continue;
-                        }
-                        (0, utils_1.assert)((0, definitions_1.isEnumType)(subgraphEnum), () => `${subgraphEnum} should be an enum but found a ${subgraphEnum.kind}`);
-                        for (const value of type.values) {
-                            const addValue = !enumValueDirective
-                                || value.appliedDirectivesOf(enumValueDirective).some((d) => graphEnumNameToSubgraphName.get(d.arguments().graph) === subgraph.name);
-                            if (addValue) {
-                                subgraphEnum.addValue(value.name);
-                            }
-                        }
-                    }
-                    break;
-                case 'UnionType':
-                    for (const subgraph of subgraphs) {
-                        const subgraphUnion = subgraph.schema.type(type.name);
-                        if (!subgraphUnion) {
-                            continue;
-                        }
-                        (0, utils_1.assert)((0, definitions_1.isUnionType)(subgraphUnion), () => `${subgraphUnion} should be an enum but found a ${subgraphUnion.kind}`);
-                        let membersInSubgraph;
-                        if (unionMemberDirective) {
-                            membersInSubgraph = type
-                                .appliedDirectivesOf(unionMemberDirective)
-                                .filter((d) => graphEnumNameToSubgraphName.get(d.arguments().graph) === subgraph.name)
-                                .map((d) => d.arguments().member);
-                        }
-                        else {
-                            membersInSubgraph = type.types().map((t) => t.name);
-                        }
-                        for (const memberTypeName of membersInSubgraph) {
-                            const subgraphType = subgraph.schema.type(memberTypeName);
-                            if (subgraphType) {
-                                subgraphUnion.addType(subgraphType);
-                            }
-                        }
-                    }
-                    break;
-            }
+        else {
+            extractSubgraphsFromFed2Supergraph(args);
         }
-        const allExecutableDirectives = supergraph.directives().filter((def) => def.hasExecutableLocations());
         for (const subgraph of subgraphs) {
-            if (isFed1) {
-                addExternalFields(subgraph, supergraph, isFed1);
-            }
-            (0, federation_1.removeInactiveProvidesAndRequires)(subgraph.schema);
-            for (const type of subgraph.schema.types()) {
-                switch (type.kind) {
-                    case 'ObjectType':
-                    case 'InterfaceType':
-                    case 'InputObjectType':
-                        if (!type.hasFields()) {
-                            type.removeRecursive();
-                        }
-                        break;
-                    case 'UnionType':
-                        if (type.membersCount() === 0) {
-                            type.removeRecursive();
-                        }
-                        break;
+            if (validateExtractedSubgraphs) {
+                try {
+                    subgraph.validate();
                 }
-            }
-            for (const definition of allExecutableDirectives) {
-                (0, definitions_1.copyDirectiveDefinitionToSchema)({
-                    definition,
-                    schema: subgraph.schema,
-                    copyDirectiveApplicationsInArguments: false,
-                    locationFilter: (loc) => (0, definitions_1.isExecutableDirectiveLocation)(loc),
-                });
-            }
-        }
-        if (isFed1) {
-            for (const subgraph of subgraphs) {
-                for (const itf of subgraph.schema.interfaceTypes()) {
-                    const implementations = itf.possibleRuntimeTypes();
-                    for (const field of itf.fields()) {
-                        if (!implementations.every(implem => implem.field(field.name))) {
-                            field.remove();
-                        }
-                    }
-                    if (!itf.hasFields()) {
-                        itf.remove();
-                    }
+                catch (e) {
+                    throw new SubgraphExtractionError(e, subgraph);
                 }
             }
-        }
-        for (const subgraph of subgraphs) {
-            try {
-                subgraph.validate();
-            }
-            catch (e) {
-                throw new SubgraphExtractionError(e, subgraph);
+            else {
+                subgraph.assumeValid();
             }
         }
         return subgraphs;
@@ -435,6 +196,193 @@ function extractSubgraphsFromSupergraph(supergraph) {
     }
 }
 exports.extractSubgraphsFromSupergraph = extractSubgraphsFromSupergraph;
+function addAllEmptySubgraphTypes({ supergraph, joinSpec, filteredTypes, getSubgraph, }) {
+    const typeDirective = joinSpec.typeDirective(supergraph);
+    const objOrItfTypes = [];
+    const inputObjTypes = [];
+    const enumTypes = [];
+    const unionTypes = [];
+    for (const type of filteredTypes) {
+        const typeApplications = type.appliedDirectivesOf(typeDirective);
+        switch (type.kind) {
+            case 'InterfaceType':
+            case 'ObjectType':
+                objOrItfTypes.push({ type, subgraphsInfo: addEmptyType(type, type.appliedDirectivesOf(typeDirective), getSubgraph) });
+                break;
+            case 'InputObjectType':
+                inputObjTypes.push({ type, subgraphsInfo: addEmptyType(type, type.appliedDirectivesOf(typeDirective), getSubgraph) });
+                break;
+            case 'EnumType':
+                enumTypes.push({ type, subgraphsInfo: addEmptyType(type, type.appliedDirectivesOf(typeDirective), getSubgraph) });
+                break;
+            case 'UnionType':
+                unionTypes.push({ type, subgraphsInfo: addEmptyType(type, type.appliedDirectivesOf(typeDirective), getSubgraph) });
+                break;
+            case 'ScalarType':
+                for (const application of typeApplications) {
+                    const subgraph = getSubgraph(application);
+                    (0, utils_1.assert)(subgraph, () => `Should have found the subgraph for ${application}`);
+                    subgraph.schema.addType((0, definitions_1.newNamedType)(type.kind, type.name));
+                }
+                break;
+        }
+    }
+    return {
+        objOrItfTypes,
+        inputObjTypes,
+        enumTypes,
+        unionTypes,
+    };
+}
+function addEmptyType(type, typeApplications, getSubgraph) {
+    (0, utils_1.assert)(typeApplications.length > 0, `Missing @join__type on ${type}`);
+    const subgraphsInfo = new Map();
+    for (const application of typeApplications) {
+        const { graph, key, extension, resolvable, isInterfaceObject } = application.arguments();
+        let subgraphInfo = subgraphsInfo.get(graph);
+        if (!subgraphInfo) {
+            const subgraph = getSubgraph(application);
+            (0, utils_1.assert)(subgraph, () => `Should have found the subgraph for ${application}`);
+            const kind = isInterfaceObject ? 'ObjectType' : type.kind;
+            const subgraphType = subgraph.schema.addType((0, definitions_1.newNamedType)(kind, type.name));
+            if (isInterfaceObject) {
+                subgraphType.applyDirective('interfaceObject');
+            }
+            subgraphInfo = { type: subgraphType, subgraph };
+            subgraphsInfo.set(graph, subgraphInfo);
+        }
+        if (key) {
+            const directive = subgraphInfo.type.applyDirective('key', { 'fields': key, resolvable });
+            if (extension) {
+                directive.setOfExtension(subgraphInfo.type.newExtension());
+            }
+        }
+    }
+    return subgraphsInfo;
+}
+function extractObjOrItfContent(args, info) {
+    const fieldDirective = args.joinSpec.fieldDirective(args.supergraph);
+    const implementsDirective = args.joinSpec.implementsDirective(args.supergraph);
+    (0, utils_1.assert)(implementsDirective, '@join__implements should existing for a fed2 supergraph');
+    for (const { type, subgraphsInfo } of info) {
+        const implementsApplications = type.appliedDirectivesOf(implementsDirective);
+        for (const application of implementsApplications) {
+            const args = application.arguments();
+            const subgraphInfo = subgraphsInfo.get(args.graph);
+            subgraphInfo.type.addImplementedInterface(args.interface);
+        }
+        for (const field of type.fields()) {
+            const fieldApplications = field.appliedDirectivesOf(fieldDirective);
+            if (fieldApplications.length === 0) {
+                const isShareable = (0, definitions_1.isObjectType)(type) && subgraphsInfo.size > 1;
+                for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
+                    addSubgraphField({ field, type: subgraphType, subgraph, isShareable });
+                }
+            }
+            else {
+                const isShareable = (0, definitions_1.isObjectType)(type)
+                    && fieldApplications.filter((application) => {
+                        const args = application.arguments();
+                        return !args.external && !args.usedOverridden;
+                    }).length > 1;
+                for (const application of fieldApplications) {
+                    const args = application.arguments();
+                    if (!args.graph) {
+                        continue;
+                    }
+                    const { type: subgraphType, subgraph } = subgraphsInfo.get(args.graph);
+                    addSubgraphField({ field, type: subgraphType, subgraph, isShareable, joinFieldArgs: args });
+                }
+            }
+        }
+    }
+}
+function extractInputObjContent(args, info) {
+    const fieldDirective = args.joinSpec.fieldDirective(args.supergraph);
+    for (const { type, subgraphsInfo } of info) {
+        for (const field of type.fields()) {
+            const fieldApplications = field.appliedDirectivesOf(fieldDirective);
+            if (fieldApplications.length === 0) {
+                for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
+                    addSubgraphInputField({ field, type: subgraphType, subgraph });
+                }
+            }
+            else {
+                for (const application of fieldApplications) {
+                    const args = application.arguments();
+                    if (!args.graph) {
+                        continue;
+                    }
+                    const { type: subgraphType, subgraph } = subgraphsInfo.get(args.graph);
+                    addSubgraphInputField({ field, type: subgraphType, subgraph, joinFieldArgs: args });
+                }
+            }
+        }
+    }
+}
+function extractEnumTypeContent(args, info) {
+    const enumValueDirective = args.joinSpec.enumValueDirective(args.supergraph);
+    for (const { type, subgraphsInfo } of info) {
+        for (const value of type.values) {
+            const enumValueApplications = enumValueDirective ? value.appliedDirectivesOf(enumValueDirective) : [];
+            if (enumValueApplications.length === 0) {
+                for (const { type: subgraphType } of subgraphsInfo.values()) {
+                    subgraphType.addValue(value.name);
+                }
+            }
+            else {
+                for (const application of enumValueApplications) {
+                    const args = application.arguments();
+                    const { type: subgraphType } = subgraphsInfo.get(args.graph);
+                    subgraphType.addValue(value.name);
+                }
+            }
+        }
+    }
+}
+function extractUnionTypeContent(args, info) {
+    const unionMemberDirective = args.joinSpec.unionMemberDirective(args.supergraph);
+    for (const { type, subgraphsInfo } of info) {
+        const unionMemberApplications = unionMemberDirective ? type.appliedDirectivesOf(unionMemberDirective) : [];
+        if (unionMemberApplications.length === 0) {
+            for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
+                for (const member of type.types()) {
+                    const subgraphMember = subgraph.schema.type(member.name);
+                    if (subgraphMember) {
+                        subgraphType.addType(subgraphMember);
+                    }
+                }
+            }
+        }
+        else {
+            for (const application of unionMemberApplications) {
+                const args = application.arguments();
+                const { type: subgraphType, subgraph } = subgraphsInfo.get(args.graph);
+                subgraphType.addType(subgraph.schema.type(args.member));
+            }
+        }
+    }
+}
+function extractSubgraphsFromFed2Supergraph(args) {
+    const { objOrItfTypes, inputObjTypes, enumTypes, unionTypes, } = addAllEmptySubgraphTypes(args);
+    extractObjOrItfContent(args, objOrItfTypes);
+    extractInputObjContent(args, inputObjTypes);
+    extractEnumTypeContent(args, enumTypes);
+    extractUnionTypeContent(args, unionTypes);
+    const allExecutableDirectives = args.supergraph.directives().filter((def) => def.hasExecutableLocations());
+    for (const subgraph of args.subgraphs) {
+        (0, federation_1.removeInactiveProvidesAndRequires)(subgraph.schema);
+        removeUnusedTypesFromSubgraph(subgraph.schema);
+        for (const definition of allExecutableDirectives) {
+            (0, definitions_1.copyDirectiveDefinitionToSchema)({
+                definition,
+                schema: subgraph.schema,
+                copyDirectiveApplicationsInArguments: false,
+                locationFilter: (loc) => (0, definitions_1.isExecutableDirectiveLocation)(loc),
+            });
+        }
+    }
+}
 const DEBUG_SUBGRAPHS_ENV_VARIABLE_NAME = 'APOLLO_FEDERATION_DEBUG_SUBGRAPHS';
 function maybeDumpSubgraphSchema(subgraph) {
     const shouldDump = !!(0, utils_2.validateStringContainsBoolean)(process.env[DEBUG_SUBGRAPHS_ENV_VARIABLE_NAME]);
@@ -458,42 +406,226 @@ function errorToString(e) {
     const causes = (0, _1.errorCauses)(e);
     return causes ? (0, _1.printErrors)(causes) : String(e);
 }
-function addSubgraphField(supergraphField, subgraph, encodedType) {
-    if (supergraphField instanceof definitions_1.FieldDefinition) {
-        return addSubgraphObjectOrInterfaceField(supergraphField, subgraph, encodedType);
+function addSubgraphField({ field, type, subgraph, isShareable, joinFieldArgs, }) {
+    const copiedFieldType = (joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.type)
+        ? decodeType(joinFieldArgs.type, subgraph.schema, subgraph.name)
+        : copyType(field.type, subgraph.schema, subgraph.name);
+    const subgraphField = type.addField(field.name, copiedFieldType);
+    for (const arg of field.arguments()) {
+        subgraphField.addArgument(arg.name, copyType(arg.type, subgraph.schema, subgraph.name), arg.defaultValue);
     }
-    else {
-        return addSubgraphInputField(supergraphField, subgraph, encodedType);
+    if (joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.requires) {
+        subgraphField.applyDirective(subgraph.metadata().requiresDirective(), { 'fields': joinFieldArgs.requires });
+    }
+    if (joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.provides) {
+        subgraphField.applyDirective(subgraph.metadata().providesDirective(), { 'fields': joinFieldArgs.provides });
     }
+    const external = !!(joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.external);
+    if (external) {
+        subgraphField.applyDirective(subgraph.metadata().externalDirective());
+    }
+    const usedOverridden = !!(joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.usedOverridden);
+    if (usedOverridden) {
+        subgraphField.applyDirective(subgraph.metadata().externalDirective(), { 'reason': '[overridden]' });
+    }
+    if (joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.override) {
+        subgraphField.applyDirective(subgraph.metadata().overrideDirective(), { 'from': joinFieldArgs.override });
+    }
+    if (isShareable && !external && !usedOverridden) {
+        subgraphField.applyDirective(subgraph.metadata().shareableDirective());
+    }
+    return subgraphField;
 }
-function addSubgraphObjectOrInterfaceField(supergraphField, subgraph, encodedType) {
-    const subgraphType = subgraph.schema.type(supergraphField.parent.name);
-    if (subgraphType) {
-        const copiedType = encodedType
-            ? decodeType(encodedType, subgraph.schema, subgraph.name)
-            : copyType(supergraphField.type, subgraph.schema, subgraph.name);
-        const field = subgraphType.addField(supergraphField.name, copiedType);
-        for (const arg of supergraphField.arguments()) {
-            field.addArgument(arg.name, copyType(arg.type, subgraph.schema, subgraph.name), arg.defaultValue);
-        }
-        return field;
+function addSubgraphInputField({ field, type, subgraph, joinFieldArgs, }) {
+    const copiedType = (joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.type)
+        ? decodeType(joinFieldArgs === null || joinFieldArgs === void 0 ? void 0 : joinFieldArgs.type, subgraph.schema, subgraph.name)
+        : copyType(field.type, subgraph.schema, subgraph.name);
+    const inputField = type.addField(field.name, copiedType);
+    inputField.defaultValue = field.defaultValue;
+    return inputField;
+}
+function extractSubgraphsFromFed1Supergraph({ supergraph, subgraphs, joinSpec, filteredTypes, getSubgraph, }) {
+    const typeDirective = joinSpec.typeDirective(supergraph);
+    const ownerDirective = joinSpec.ownerDirective(supergraph);
+    const fieldDirective = joinSpec.fieldDirective(supergraph);
+    const reachableTypesBySubgraph = collectFieldReachableTypesForAllSubgraphs(supergraph, subgraphs.names(), (f, name) => {
+        var _a;
+        const fieldApplications = f.appliedDirectivesOf(fieldDirective);
+        if (fieldApplications.length) {
+            const application = fieldApplications.find((application) => { var _a; return ((_a = getSubgraph(application)) === null || _a === void 0 ? void 0 : _a.name) === name; });
+            if (application) {
+                const args = application.arguments();
+                const typesInFederationDirectives = typesUsedInFederationDirective(args.provides, (0, definitions_1.baseType)(f.type))
+                    .concat(typesUsedInFederationDirective(args.requires, f.parent));
+                return { isInSubgraph: true, typesInFederationDirectives };
+            }
+            else {
+                return { isInSubgraph: false, typesInFederationDirectives: [] };
+            }
+        }
+        else {
+            const ownerApplications = ownerDirective ? f.parent.appliedDirectivesOf(ownerDirective) : [];
+            return { isInSubgraph: !ownerApplications.length || ((_a = getSubgraph(ownerApplications[0])) === null || _a === void 0 ? void 0 : _a.name) == name, typesInFederationDirectives: [] };
+        }
+    }, (t, name) => {
+        const typeApplications = t.appliedDirectivesOf(typeDirective);
+        const application = typeApplications.find((application) => { var _a; return (application.arguments().key && (((_a = getSubgraph(application)) === null || _a === void 0 ? void 0 : _a.name) === name)); });
+        if (application) {
+            const typesInFederationDirectives = typesUsedInFederationDirective(application.arguments().key, t);
+            return { isEntityWithKeyInSubgraph: true, typesInFederationDirectives };
+        }
+        else {
+            return { isEntityWithKeyInSubgraph: false, typesInFederationDirectives: [] };
+        }
+    });
+    const includeTypeInSubgraph = (t, name) => { var _a, _b; return (_b = (_a = reachableTypesBySubgraph.get(name)) === null || _a === void 0 ? void 0 : _a.has(t.name)) !== null && _b !== void 0 ? _b : false; };
+    for (const type of filteredTypes) {
+        const typeApplications = type.appliedDirectivesOf(typeDirective);
+        if (!typeApplications.length) {
+            for (const subgraph of subgraphs) {
+                if (includeTypeInSubgraph(type, subgraph.name)) {
+                    subgraph.schema.addType((0, definitions_1.newNamedType)(type.kind, type.name));
+                }
+            }
+        }
+        else {
+            for (const application of typeApplications) {
+                const args = application.arguments();
+                const subgraph = getSubgraph(application);
+                (0, utils_1.assert)(subgraph, () => `Should have found the subgraph for ${application}`);
+                const schema = subgraph.schema;
+                let subgraphType = schema.type(type.name);
+                if (!subgraphType) {
+                    const kind = args.isInterfaceObject ? 'ObjectType' : type.kind;
+                    subgraphType = schema.addType((0, definitions_1.newNamedType)(kind, type.name));
+                    if (args.isInterfaceObject) {
+                        subgraphType.applyDirective('interfaceObject');
+                    }
+                }
+                if (args.key) {
+                    const { resolvable } = args;
+                    const directive = subgraphType.applyDirective('key', { 'fields': args.key, resolvable });
+                    if (args.extension) {
+                        directive.setOfExtension(subgraphType.newExtension());
+                    }
+                }
+            }
+        }
     }
-    else {
-        return undefined;
+    for (const type of filteredTypes) {
+        switch (type.kind) {
+            case 'ObjectType':
+            case 'InterfaceType':
+                for (const implementations of type.interfaceImplementations()) {
+                    const name = implementations.interface.name;
+                    for (const subgraph of subgraphs) {
+                        const subgraphType = subgraph.schema.type(type.name);
+                        const subgraphItf = subgraph.schema.type(name);
+                        if (subgraphType && subgraphItf) {
+                            subgraphType.addImplementedInterface(name);
+                        }
+                    }
+                }
+            case 'InputObjectType':
+                for (const field of type.fields()) {
+                    const fieldApplications = field.appliedDirectivesOf(fieldDirective);
+                    if (!fieldApplications.length) {
+                        const ownerApplications = ownerDirective ? type.appliedDirectivesOf(ownerDirective) : [];
+                        if (ownerApplications.length > 0) {
+                            (0, utils_1.assert)(ownerApplications.length == 1, () => `Found multiple join__owner directives on type ${type}`);
+                            const subgraph = getSubgraph(ownerApplications[0]);
+                            (0, utils_1.assert)(subgraph, () => `Should have found the subgraph for ${ownerApplications[0]}`);
+                            addSubgraphFieldForFed1(field, subgraph, false);
+                        }
+                        else {
+                            const fieldBaseType = (0, definitions_1.baseType)(field.type);
+                            const isShareable = (0, definitions_1.isObjectType)(type) && subgraphs.values().filter((s) => s.schema.type(type.name)).length > 1;
+                            for (const subgraph of subgraphs) {
+                                if (subgraph.schema.type(fieldBaseType.name)) {
+                                    addSubgraphFieldForFed1(field, subgraph, isShareable);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        const isShareable = (0, definitions_1.isObjectType)(type) && fieldApplications.length > 1;
+                        for (const application of fieldApplications) {
+                            const subgraph = getSubgraph(application);
+                            if (!subgraph) {
+                                continue;
+                            }
+                            const args = application.arguments();
+                            addSubgraphFieldForFed1(field, subgraph, isShareable, args);
+                        }
+                    }
+                }
+                break;
+            case 'EnumType':
+                for (const subgraph of subgraphs) {
+                    const subgraphEnum = subgraph.schema.type(type.name);
+                    if (!subgraphEnum) {
+                        continue;
+                    }
+                    (0, utils_1.assert)((0, definitions_1.isEnumType)(subgraphEnum), () => `${subgraphEnum} should be an enum but found a ${subgraphEnum.kind}`);
+                    for (const value of type.values) {
+                        subgraphEnum.addValue(value.name);
+                    }
+                }
+                break;
+            case 'UnionType':
+                for (const subgraph of subgraphs) {
+                    const subgraphUnion = subgraph.schema.type(type.name);
+                    if (!subgraphUnion) {
+                        continue;
+                    }
+                    (0, utils_1.assert)((0, definitions_1.isUnionType)(subgraphUnion), () => `${subgraphUnion} should be an enum but found a ${subgraphUnion.kind}`);
+                    for (const memberTypeName of type.types().map((t) => t.name)) {
+                        const subgraphType = subgraph.schema.type(memberTypeName);
+                        if (subgraphType) {
+                            subgraphUnion.addType(subgraphType);
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    const allExecutableDirectives = supergraph.directives().filter((def) => def.hasExecutableLocations());
+    for (const subgraph of subgraphs) {
+        addExternalFields(subgraph, supergraph, true);
+        (0, federation_1.removeInactiveProvidesAndRequires)(subgraph.schema);
+        removeUnusedTypesFromSubgraph(subgraph.schema);
+        for (const definition of allExecutableDirectives) {
+            (0, definitions_1.copyDirectiveDefinitionToSchema)({
+                definition,
+                schema: subgraph.schema,
+                copyDirectiveApplicationsInArguments: false,
+                locationFilter: (loc) => (0, definitions_1.isExecutableDirectiveLocation)(loc),
+            });
+        }
     }
+    return subgraphs;
 }
-function addSubgraphInputField(supergraphField, subgraph, encodedType) {
-    const subgraphType = subgraph.schema.type(supergraphField.parent.name);
-    if (subgraphType) {
-        const copiedType = encodedType
-            ? decodeType(encodedType, subgraph.schema, subgraph.name)
-            : copyType(supergraphField.type, subgraph.schema, subgraph.name);
-        const field = subgraphType.addField(supergraphField.name, copiedType);
-        field.defaultValue = supergraphField.defaultValue;
-        return field;
+function addSubgraphFieldForFed1(field, subgraph, isShareable, joinFieldArgs) {
+    const subgraphType = subgraph.schema.type(field.parent.name);
+    if (!subgraphType) {
+        return;
+    }
+    if (field instanceof definitions_1.FieldDefinition) {
+        addSubgraphField({
+            field,
+            subgraph,
+            type: subgraphType,
+            isShareable,
+            joinFieldArgs,
+        });
     }
     else {
-        return undefined;
+        addSubgraphInputField({
+            field,
+            subgraph,
+            type: subgraphType,
+            joinFieldArgs,
+        });
     }
 }
 function decodeType(encodedType, subgraph, subgraphName) {
@@ -553,7 +685,12 @@ function addExternalFieldsFromDirectiveFieldSet(subgraph, parentType, directive,
         const supergraphType = supergraph.type(type.name);
         const supergraphField = supergraphType.field(fieldName);
         (0, utils_1.assert)(supergraphField, () => `No field named ${fieldName} found on type ${type.name} in the supergraph`);
-        const created = addSubgraphObjectOrInterfaceField(supergraphField, subgraph);
+        const created = addSubgraphField({
+            field: supergraphField,
+            subgraph,
+            type,
+            isShareable: false,
+        });
         if (!forceNonExternal) {
             created.applyDirective(external);
         }
@@ -591,4 +728,22 @@ function maybeUpdateFieldForInterface(toModify, itfField) {
         toModify.type = itfField.type;
     }
 }
+function removeUnusedTypesFromSubgraph(schema) {
+    for (const type of schema.types()) {
+        switch (type.kind) {
+            case 'ObjectType':
+            case 'InterfaceType':
+            case 'InputObjectType':
+                if (!type.hasFields()) {
+                    type.removeRecursive();
+                }
+                break;
+            case 'UnionType':
+                if (type.membersCount() === 0) {
+                    type.removeRecursive();
+                }
+                break;
+        }
+    }
+}
 //# sourceMappingURL=extractSubgraphsFromSupergraph.js.map