@apollo/federation-internals 2.0.0-alpha.4 → 2.0.0-preview.0

package/dist/federation.js

@@ -1,49 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalTester = exports.addSubgraphToError = exports.addSubgraphToASTNode = exports.Subgraph = exports.Subgraphs = exports.subgraphsFromServiceList = exports.parseFieldSetArgument = exports.buildSubgraph = exports.isEntityType = exports.isFederationDirective = exports.isFederationField = exports.isFederationTypeName = exports.isFederationType = exports.isFederationSubgraphSchema = exports.federationBuiltIns = exports.FederationBuiltIns = exports.FEDERATION_RESERVED_SUBGRAPH_NAME = exports.entitiesFieldName = exports.serviceFieldName = exports.tagDirectiveName = exports.providesDirectiveName = exports.requiresDirectiveName = exports.externalDirectiveName = exports.extendsDirectiveName = exports.keyDirectiveName = exports.fieldSetTypeName = exports.anyTypeName = exports.serviceTypeName = exports.entityTypeName = void 0;
+exports.removeInactiveProvidesAndRequires = exports.addSubgraphToError = exports.addSubgraphToASTNode = exports.Subgraph = exports.FEDERATION_OPERATION_FIELDS = exports.entitiesFieldName = exports.serviceFieldName = exports.FEDERATION_OPERATION_TYPES = exports.entityTypeSpec = exports.serviceTypeSpec = exports.anyTypeSpec = exports.Subgraphs = exports.subgraphsFromServiceList = exports.collectTargetFields = exports.parseFieldSetArgument = exports.newEmptyFederation2Schema = exports.buildSubgraph = exports.isEntityType = exports.isFederationField = exports.isFederationSubgraphSchema = exports.federationMetadata = exports.printSubgraphNames = exports.asFed2SubgraphDocument = exports.setSchemaAsFed2Subgraph = exports.FederationBlueprint = exports.FederationMetadata = exports.collectUsedExternalFieldsCoordinates = exports.FEDERATION_RESERVED_SUBGRAPH_NAME = void 0;
 const definitions_1 = require("./definitions");
 const utils_1 = require("./utils");
 const specifiedRules_1 = require("graphql/validation/specifiedRules");
 const graphql_1 = require("graphql");
-const print_1 = require("./print");
 const KnownTypeNamesInFederationRule_1 = require("./validation/KnownTypeNamesInFederationRule");
 const buildSchema_1 = require("./buildSchema");
 const operations_1 = require("./operations");
 const tagSpec_1 = require("./tagSpec");
 const error_1 = require("./error");
-const _1 = require(".");
-exports.entityTypeName = '_Entity';
-exports.serviceTypeName = '_Service';
-exports.anyTypeName = '_Any';
-exports.fieldSetTypeName = '_FieldSet';
-exports.keyDirectiveName = 'key';
-exports.extendsDirectiveName = 'extends';
-exports.externalDirectiveName = 'external';
-exports.requiresDirectiveName = 'requires';
-exports.providesDirectiveName = 'provides';
-exports.tagDirectiveName = 'tag';
-exports.serviceFieldName = '_service';
-exports.entitiesFieldName = '_entities';
+const sharing_1 = require("./sharing");
+const coreSpec_1 = require("./coreSpec");
+const federationSpec_1 = require("./federationSpec");
+const print_1 = require("./print");
+const directiveAndTypeSpecification_1 = require("./directiveAndTypeSpecification");
+const linkSpec = coreSpec_1.LINK_VERSIONS.latest();
 const tagSpec = tagSpec_1.TAG_VERSIONS.latest();
+const federationSpec = federationSpec_1.FEDERATION_VERSIONS.latest();
 exports.FEDERATION_RESERVED_SUBGRAPH_NAME = '_';
-const FEDERATION_TYPES = [
-    exports.entityTypeName,
-    exports.serviceTypeName,
-    exports.anyTypeName,
-    exports.fieldSetTypeName
-];
-const FEDERATION_DIRECTIVES = [
-    exports.keyDirectiveName,
-    exports.extendsDirectiveName,
-    exports.externalDirectiveName,
-    exports.requiresDirectiveName,
-    exports.providesDirectiveName,
-    exports.tagDirectiveName
-];
-const FEDERATION_ROOT_FIELDS = [
-    exports.serviceFieldName,
-    exports.entitiesFieldName
-];
 const FEDERATION_OMITTED_VALIDATION_RULES = [
     graphql_1.PossibleTypeExtensionsRule,
     graphql_1.KnownTypeNamesRule
@@ -52,33 +27,30 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
     KnownTypeNamesInFederationRule_1.KnownTypeNamesInFederationRule
 ];
 const FEDERATION_VALIDATION_RULES = specifiedRules_1.specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
-function validateFieldSetSelections(directiveName, selectionSet, hasExternalInParents, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields) {
+function validateFieldSetSelections(directiveName, selectionSet, hasExternalInParents, federationMetadata, allowOnNonExternalLeafFields) {
     for (const selection of selectionSet.selections()) {
         if (selection.kind === 'FieldSelection') {
             const field = selection.element().definition;
-            const isExternal = externalTester.isExternal(field);
-            if (isExternal) {
-                externalFieldCoordinatesCollector.push(field.coordinate);
-            }
+            const isExternal = federationMetadata.isFieldExternal(field);
             if (field.hasArguments()) {
-                throw _1.ERROR_CATEGORIES.FIELDS_HAS_ARGS.get(directiveName).err({
+                throw error_1.ERROR_CATEGORIES.FIELDS_HAS_ARGS.get(directiveName).err({
                     message: `field ${field.coordinate} cannot be included because it has arguments (fields with argument are not allowed in @${directiveName})`,
                     nodes: field.sourceAST
                 });
             }
             const mustBeExternal = !selection.selectionSet && !allowOnNonExternalLeafFields && !hasExternalInParents;
             if (!isExternal && mustBeExternal) {
-                const errorCode = _1.ERROR_CATEGORIES.DIRECTIVE_FIELDS_MISSING_EXTERNAL.get(directiveName);
-                if (externalTester.isFakeExternal(field)) {
+                const errorCode = error_1.ERROR_CATEGORIES.DIRECTIVE_FIELDS_MISSING_EXTERNAL.get(directiveName);
+                if (federationMetadata.isFieldFakeExternal(field)) {
                     throw errorCode.err({
                         message: `field "${field.coordinate}" should not be part of a @${directiveName} since it is already "effectively" provided by this subgraph `
-                            + `(while it is marked @${exports.externalDirectiveName}, it is a @${exports.keyDirectiveName} field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`,
+                            + `(while it is marked @${federationSpec_1.externalDirectiveSpec.name}, it is a @${federationSpec_1.keyDirectiveSpec.name} field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`,
                         nodes: field.sourceAST
                     });
                 }
                 else {
                     throw errorCode.err({
-                        message: `field "${field.coordinate}" should not be part of a @${directiveName} since it is already provided by this subgraph (it is not marked @${exports.externalDirectiveName})`,
+                        message: `field "${field.coordinate}" should not be part of a @${directiveName} since it is already provided by this subgraph (it is not marked @${federationSpec_1.externalDirectiveSpec.name})`,
                         nodes: field.sourceAST
                     });
                 }
@@ -89,24 +61,24 @@ function validateFieldSetSelections(directiveName, selectionSet, hasExternalInPa
                 if (!newHasExternalInParents && (0, definitions_1.isInterfaceType)(parentType)) {
                     for (const implem of parentType.possibleRuntimeTypes()) {
                         const fieldInImplem = implem.field(field.name);
-                        if (fieldInImplem && externalTester.isExternal(fieldInImplem)) {
+                        if (fieldInImplem && federationMetadata.isFieldExternal(fieldInImplem)) {
                             newHasExternalInParents = true;
                             break;
                         }
                     }
                 }
-                validateFieldSetSelections(directiveName, selection.selectionSet, newHasExternalInParents, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields);
+                validateFieldSetSelections(directiveName, selection.selectionSet, newHasExternalInParents, federationMetadata, allowOnNonExternalLeafFields);
             }
         }
         else {
-            validateFieldSetSelections(directiveName, selection.selectionSet, hasExternalInParents, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields);
+            validateFieldSetSelections(directiveName, selection.selectionSet, hasExternalInParents, federationMetadata, allowOnNonExternalLeafFields);
         }
     }
 }
-function validateFieldSet(type, directive, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields, onFields) {
+function validateFieldSet(type, directive, federationMetadata, allowOnNonExternalLeafFields, onFields) {
     var _a;
     try {
-        const fieldAcessor = onFields
+        const fieldAccessor = onFields
             ? (type, fieldName) => {
                 const field = type.field(fieldName);
                 if (field) {
@@ -115,9 +87,9 @@ function validateFieldSet(type, directive, externalTester, externalFieldCoordina
                 return field;
             }
             : undefined;
-        const selectionSet = parseFieldSetArgument(type, directive, fieldAcessor);
+        const selectionSet = parseFieldSetArgument({ parentType: type, directive, fieldAccessor });
         try {
-            validateFieldSetSelections(directive.name, selectionSet, false, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields);
+            validateFieldSetSelections(directive.name, selectionSet, false, federationMetadata, allowOnNonExternalLeafFields);
             return undefined;
         }
         catch (e) {
@@ -128,7 +100,7 @@ function validateFieldSet(type, directive, externalTester, externalFieldCoordina
             if (e.nodes) {
                 nodes.push(...e.nodes);
             }
-            const codeDef = (_a = (0, error_1.errorCodeDef)(e)) !== null && _a !== void 0 ? _a : _1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS.get(directive.name);
+            const codeDef = (_a = (0, error_1.errorCodeDef)(e)) !== null && _a !== void 0 ? _a : error_1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS.get(directive.name);
             return codeDef.err({
                 message: `${fieldSetErrorDescriptor(directive)}: ${e.message.trim()}`,
                 nodes,
@@ -156,13 +128,13 @@ function fieldSetTargetDescription(directive) {
     const targetKind = directive.parent instanceof definitions_1.FieldDefinition ? "field" : "type";
     return `${targetKind} "${(_a = directive.parent) === null || _a === void 0 ? void 0 : _a.coordinate}"`;
 }
-function validateAllFieldSet(definition, targetTypeExtractor, errorCollector, externalTester, externalFieldCoordinatesCollector, isOnParentType, allowOnNonExternalLeafFields, onFields) {
+function validateAllFieldSet(definition, targetTypeExtractor, errorCollector, federationMetadata, isOnParentType, allowOnNonExternalLeafFields, onFields) {
     for (const application of definition.applications()) {
         const elt = application.parent;
         const type = targetTypeExtractor(elt);
         const parentType = isOnParentType ? type : elt.parent;
         if ((0, definitions_1.isInterfaceType)(parentType)) {
-            const code = _1.ERROR_CATEGORIES.DIRECTIVE_UNSUPPORTED_ON_INTERFACE.get(definition.name);
+            const code = error_1.ERROR_CATEGORIES.DIRECTIVE_UNSUPPORTED_ON_INTERFACE.get(definition.name);
             errorCollector.push(code.err({
                 message: isOnParentType
                     ? `Cannot use ${definition.coordinate} on interface "${parentType.coordinate}": ${definition.coordinate} is not yet supported on interfaces`
@@ -170,19 +142,57 @@ function validateAllFieldSet(definition, targetTypeExtractor, errorCollector, ex
                 nodes: (0, definitions_1.sourceASTs)(application).concat(isOnParentType ? [] : (0, definitions_1.sourceASTs)(type)),
             }));
         }
-        const error = validateFieldSet(type, application, externalTester, externalFieldCoordinatesCollector, allowOnNonExternalLeafFields, onFields);
+        const error = validateFieldSet(type, application, federationMetadata, allowOnNonExternalLeafFields, onFields);
         if (error) {
             errorCollector.push(error);
         }
     }
 }
-function validateAllExternalFieldsUsed(schema, externalTester, allExternalFieldsUsedInFederationDirectivesCoordinates, errorCollector) {
-    for (const type of schema.types()) {
+function collectUsedExternalFieldsCoordinates(metadata) {
+    const usedExternalCoordinates = new Set();
+    collectUsedExternaFieldsForDirective(metadata, metadata.keyDirective(), type => type, usedExternalCoordinates);
+    collectUsedExternaFieldsForDirective(metadata, metadata.requiresDirective(), field => field.parent, usedExternalCoordinates);
+    collectUsedExternaFieldsForDirective(metadata, metadata.providesDirective(), field => {
+        const type = (0, definitions_1.baseType)(field.type);
+        return (0, definitions_1.isCompositeType)(type) ? type : undefined;
+    }, usedExternalCoordinates);
+    for (const itfType of metadata.schema.types('InterfaceType')) {
+        const runtimeTypes = itfType.possibleRuntimeTypes();
+        for (const field of itfType.fields()) {
+            for (const runtimeType of runtimeTypes) {
+                const implemField = runtimeType.field(field.name);
+                if (implemField && metadata.isFieldExternal(implemField)) {
+                    usedExternalCoordinates.add(implemField.coordinate);
+                }
+            }
+        }
+    }
+    return usedExternalCoordinates;
+}
+exports.collectUsedExternalFieldsCoordinates = collectUsedExternalFieldsCoordinates;
+function collectUsedExternaFieldsForDirective(metadata, definition, targetTypeExtractor, usedExternalCoordinates) {
+    for (const application of definition.applications()) {
+        const type = targetTypeExtractor(application.parent);
+        if (!type) {
+            continue;
+        }
+        collectTargetFields({
+            parentType: type,
+            directive: application,
+            includeInterfaceFieldsImplementations: true,
+            validate: false,
+        }).filter((field) => metadata.isFieldExternal(field))
+            .forEach((field) => usedExternalCoordinates.add(field.coordinate));
+    }
+}
+function validateAllExternalFieldsUsed(metadata, errorCollector) {
+    const allUsedExternals = collectUsedExternalFieldsCoordinates(metadata);
+    for (const type of metadata.schema.types()) {
         if (!(0, definitions_1.isObjectType)(type) && !(0, definitions_1.isInterfaceType)(type)) {
             continue;
         }
         for (const field of type.fields()) {
-            if (!externalTester.isExternal(field) || allExternalFieldsUsedInFederationDirectivesCoordinates.includes(field.coordinate)) {
+            if (!metadata.isFieldExternal(field) || allUsedExternals.has(field.coordinate)) {
                 continue;
             }
             if (!isFieldSatisfyingInterface(field)) {
@@ -195,87 +205,250 @@ function validateAllExternalFieldsUsed(schema, externalTester, allExternalFields
         }
     }
 }
+function validateNoExternalOnInterfaceFields(metadata, errorCollector) {
+    for (const itf of metadata.schema.types('InterfaceType')) {
+        for (const field of itf.fields()) {
+            if (metadata.isFieldExternal(field)) {
+                errorCollector.push(error_1.ERRORS.EXTERNAL_ON_INTERFACE.err({
+                    message: `Interface type field "${field.coordinate}" is marked @external but @external is not allowed on interface fields (it is nonsensical).`,
+                    nodes: field.sourceAST,
+                }));
+            }
+        }
+    }
+}
 function isFieldSatisfyingInterface(field) {
     return field.parent.interfaces().some(itf => itf.field(field.name));
 }
-class FederationBuiltIns extends definitions_1.BuiltIns {
-    addBuiltInTypes(schema) {
-        super.addBuiltInTypes(schema);
-        this.addBuiltInUnion(schema, exports.entityTypeName);
-        this.addBuiltInObject(schema, exports.serviceTypeName).addField('sdl', schema.stringType());
-        this.addBuiltInScalar(schema, exports.anyTypeName);
-        this.addBuiltInScalar(schema, exports.fieldSetTypeName);
-    }
-    addBuiltInDirectives(schema) {
-        super.addBuiltInDirectives(schema);
-        const fieldSetType = new definitions_1.NonNullType(schema.type(exports.fieldSetTypeName));
-        const keyDirective = this.addBuiltInDirective(schema, exports.keyDirectiveName)
-            .addLocations(graphql_1.DirectiveLocation.OBJECT, graphql_1.DirectiveLocation.INTERFACE);
-        keyDirective.repeatable = true;
-        keyDirective.addArgument('fields', fieldSetType);
-        this.addBuiltInDirective(schema, exports.extendsDirectiveName)
-            .addLocations(graphql_1.DirectiveLocation.OBJECT, graphql_1.DirectiveLocation.INTERFACE);
-        this.addBuiltInDirective(schema, exports.externalDirectiveName)
-            .addLocations(graphql_1.DirectiveLocation.OBJECT, graphql_1.DirectiveLocation.FIELD_DEFINITION);
-        for (const name of [exports.requiresDirectiveName, exports.providesDirectiveName]) {
-            this.addBuiltInDirective(schema, name)
-                .addLocations(graphql_1.DirectiveLocation.FIELD_DEFINITION)
-                .addArgument('fields', fieldSetType);
-        }
-        const directive = this.addBuiltInDirective(schema, 'tag').addLocations(...tagSpec_1.tagLocations);
-        directive.addArgument("name", new definitions_1.NonNullType(schema.stringType()));
-    }
-    prepareValidation(schema) {
-        super.prepareValidation(schema);
-        let entityType = schema.type(exports.entityTypeName);
-        if (!entityType.isBuiltIn) {
-            if (entityType.membersCount() === 0) {
-                entityType.remove();
-            }
-            entityType = schema.builtInTypes('UnionType', true).find(u => u.name === exports.entityTypeName);
-        }
-        entityType.clearTypes();
-        for (const objectType of schema.types("ObjectType")) {
-            if (isEntityType(objectType)) {
-                entityType.addType(objectType);
-            }
-        }
-        const hasEntities = entityType.membersCount() > 0;
-        if (!hasEntities) {
-            entityType.remove();
-        }
-        const queryRoot = schema.schemaDefinition.root("query");
-        const queryType = queryRoot ? queryRoot.type : schema.addType(new definitions_1.ObjectType("Query"));
-        const entityField = queryType.field(exports.entitiesFieldName);
-        if (hasEntities) {
-            const anyType = schema.type(exports.anyTypeName);
-            (0, utils_1.assert)(anyType, `The schema should have the _Any type`);
-            const entityFieldType = new definitions_1.NonNullType(new definitions_1.ListType(entityType));
-            if (!entityField) {
-                this.addBuiltInField(queryType, exports.entitiesFieldName, entityFieldType)
-                    .addArgument('representations', new definitions_1.NonNullType(new definitions_1.ListType(new definitions_1.NonNullType(anyType))));
+function validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errorCollector) {
+    var _a;
+    const requiresDirective = (_a = federationMetadata(itf.schema())) === null || _a === void 0 ? void 0 : _a.requiresDirective();
+    (0, utils_1.assert)(requiresDirective, 'Schema should be a federation subgraph, but @requires directive not found');
+    const runtimeTypes = itf.possibleRuntimeTypes();
+    for (const field of itf.fields()) {
+        const withExternalOrRequires = [];
+        const typeToImplems = new utils_1.MultiMap();
+        const nodes = [];
+        for (const type of runtimeTypes) {
+            const implemField = type.field(field.name);
+            if (!implemField)
+                continue;
+            if (implemField.sourceAST) {
+                nodes.push(implemField.sourceAST);
             }
-            else if (!entityField.type) {
-                entityField.type = entityType;
+            if (metadata.isFieldExternal(implemField) || implemField.hasAppliedDirective(requiresDirective)) {
+                withExternalOrRequires.push(implemField);
             }
+            const returnType = implemField.type;
+            typeToImplems.add(returnType.toString(), implemField);
         }
-        else if (entityField) {
-            entityField.remove();
+        if (withExternalOrRequires.length > 0 && typeToImplems.size > 1) {
+            const typeToImplemsArray = [...typeToImplems.entries()];
+            errorCollector.push(error_1.ERRORS.INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH.err({
+                message: `Some of the runtime implementations of interface field "${field.coordinate}" are marked @external or have a @require (${withExternalOrRequires.map(printFieldCoordinate)}) so all the implementations should use the same type (a current limitation of federation; see https://github.com/apollographql/federation/issues/1257), but ${formatFieldsToReturnType(typeToImplemsArray[0])} while ${(0, utils_1.joinStrings)(typeToImplemsArray.slice(1).map(formatFieldsToReturnType), ' and ')}.`,
+                nodes
+            }));
         }
-        if (!queryType.field(exports.serviceFieldName)) {
-            this.addBuiltInField(queryType, exports.serviceFieldName, schema.type(exports.serviceTypeName));
+    }
+}
+const printFieldCoordinate = (f) => `"${f.coordinate}"`;
+function formatFieldsToReturnType([type, implems]) {
+    return `${(0, utils_1.joinStrings)(implems.map(printFieldCoordinate))} ${implems.length == 1 ? 'has' : 'have'} type "${type}"`;
+}
+function checkIfFed2Schema(schema) {
+    const core = schema.coreFeatures;
+    if (!core) {
+        return false;
+    }
+    const federationFeature = core.getByIdentity(federationSpec.identity);
+    return !!federationFeature && federationFeature.url.version.satisfies(new coreSpec_1.FeatureVersion(2, 0));
+}
+class FederationMetadata {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    onInvalidate() {
+        this._externalTester = undefined;
+        this._sharingPredicate = undefined;
+        this._isFed2Schema = undefined;
+    }
+    isFed2Schema() {
+        if (!this._isFed2Schema) {
+            this._isFed2Schema = checkIfFed2Schema(this.schema);
+        }
+        return this._isFed2Schema;
+    }
+    externalTester() {
+        if (!this._externalTester) {
+            this._externalTester = new ExternalTester(this.schema);
         }
+        return this._externalTester;
+    }
+    sharingPredicate() {
+        if (!this._sharingPredicate) {
+            this._sharingPredicate = (0, sharing_1.computeShareables)(this.schema);
+        }
+        return this._sharingPredicate;
+    }
+    isFieldExternal(field) {
+        return this.externalTester().isExternal(field);
+    }
+    isFieldPartiallyExternal(field) {
+        return this.externalTester().isPartiallyExternal(field);
+    }
+    isFieldFullyExternal(field) {
+        return this.externalTester().isFullyExternal(field);
+    }
+    isFieldFakeExternal(field) {
+        return this.externalTester().isFakeExternal(field);
+    }
+    selectionSelectsAnyExternalField(selectionSet) {
+        return this.externalTester().selectsAnyExternalField(selectionSet);
+    }
+    isFieldShareable(field) {
+        return this.sharingPredicate()(field);
+    }
+    federationDirectiveNameInSchema(name) {
+        if (this.isFed2Schema()) {
+            const coreFeatures = this.schema.coreFeatures;
+            (0, utils_1.assert)(coreFeatures, 'Schema should be a core schema');
+            const federationFeature = coreFeatures.getByIdentity(federationSpec.identity);
+            (0, utils_1.assert)(federationFeature, 'Schema should have the federation feature');
+            return federationFeature.directiveNameInSchema(name);
+        }
+        else {
+            return name;
+        }
+    }
+    federationTypeNameInSchema(name) {
+        if (name.charAt(0) === '_') {
+            return name;
+        }
+        if (this.isFed2Schema()) {
+            const coreFeatures = this.schema.coreFeatures;
+            (0, utils_1.assert)(coreFeatures, 'Schema should be a core schema');
+            const federationFeature = coreFeatures.getByIdentity(federationSpec.identity);
+            (0, utils_1.assert)(federationFeature, 'Schema should have the federation feature');
+            return federationFeature.typeNameInSchema(name);
+        }
+        else {
+            return '_' + name;
+        }
+    }
+    getFederationDirective(name) {
+        const directive = this.schema.directive(this.federationDirectiveNameInSchema(name));
+        (0, utils_1.assert)(directive, `The provided schema does not have federation directive @${name}`);
+        return directive;
+    }
+    keyDirective() {
+        return this.getFederationDirective(federationSpec_1.keyDirectiveSpec.name);
+    }
+    extendsDirective() {
+        return this.getFederationDirective(federationSpec_1.extendsDirectiveSpec.name);
+    }
+    externalDirective() {
+        return this.getFederationDirective(federationSpec_1.externalDirectiveSpec.name);
+    }
+    requiresDirective() {
+        return this.getFederationDirective(federationSpec_1.requiresDirectiveSpec.name);
+    }
+    providesDirective() {
+        return this.getFederationDirective(federationSpec_1.providesDirectiveSpec.name);
+    }
+    shareableDirective() {
+        return this.getFederationDirective(federationSpec_1.shareableDirectiveSpec.name);
+    }
+    tagDirective() {
+        return this.getFederationDirective(federationSpec_1.tagDirectiveSpec.name);
+    }
+    allFederationDirectives() {
+        const baseDirectives = [
+            this.keyDirective(),
+            this.externalDirective(),
+            this.requiresDirective(),
+            this.providesDirective(),
+            this.tagDirective(),
+            this.extendsDirective(),
+        ];
+        return this.isFed2Schema()
+            ? baseDirectives.concat(this.shareableDirective())
+            : baseDirectives;
+    }
+    entityType() {
+        return this.schema.type(this.federationTypeNameInSchema(exports.entityTypeSpec.name));
+    }
+    anyType() {
+        return this.schema.type(this.federationTypeNameInSchema(exports.anyTypeSpec.name));
+    }
+    serviceType() {
+        return this.schema.type(this.federationTypeNameInSchema(exports.serviceTypeSpec.name));
+    }
+    fieldSetType() {
+        return this.schema.type(this.federationTypeNameInSchema(federationSpec_1.fieldSetTypeSpec.name));
+    }
+    allFederationTypes() {
+        const baseTypes = [
+            this.anyType(),
+            this.serviceType(),
+            this.fieldSetType(),
+        ];
+        const entityType = this.entityType();
+        if (entityType) {
+            baseTypes.push(entityType);
+        }
+        return baseTypes;
+    }
+}
+exports.FederationMetadata = FederationMetadata;
+class FederationBlueprint extends definitions_1.SchemaBlueprint {
+    onAddedCoreFeature(schema, feature) {
+        super.onAddedCoreFeature(schema, feature);
+        if (feature.url.identity === federationSpec_1.federationIdentity) {
+            const spec = federationSpec_1.FEDERATION_VERSIONS.find(feature.url.version);
+            if (spec) {
+                spec.addElementsToSchema(schema);
+            }
+        }
+    }
+    onMissingDirectiveDefinition(schema, name) {
+        if (name === coreSpec_1.linkDirectiveDefaultName) {
+            linkSpec.addToSchema(schema);
+            return schema.directive(name);
+        }
+        return super.onMissingDirectiveDefinition(schema, name);
+    }
+    ignoreParsedField(type, fieldName) {
+        if (!exports.FEDERATION_OPERATION_FIELDS.includes(fieldName)) {
+            return false;
+        }
+        const metadata = federationMetadata(type.schema());
+        return !!metadata && !metadata.isFed2Schema();
+    }
+    onConstructed(schema) {
+        const existing = federationMetadata(schema);
+        if (!existing) {
+            schema['_federationMetadata'] = new FederationMetadata(schema);
+        }
+    }
+    onDirectiveDefinitionAndSchemaParsed(schema) {
+        completeSubgraphSchema(schema);
+    }
+    onInvalidation(schema) {
+        super.onInvalidation(schema);
+        const metadata = federationMetadata(schema);
+        (0, utils_1.assert)(metadata, 'Federation schema should have had its metadata set on construction');
+        FederationMetadata.prototype['onInvalidate'].call(metadata);
     }
     onValidation(schema) {
         var _a;
-        const errors = super.onValidation(schema, [exports.tagDirectiveName]);
+        const errors = super.onValidation(schema);
         for (const k of definitions_1.allSchemaRootKinds) {
             const type = (_a = schema.schemaDefinition.root(k)) === null || _a === void 0 ? void 0 : _a.type;
             const defaultName = (0, definitions_1.defaultRootName)(k);
             if (type && type.name !== defaultName) {
                 const existing = schema.type(defaultName);
                 if (existing) {
-                    errors.push(_1.ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
+                    errors.push(error_1.ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
                         message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
                             + 'this is not supported by federation. '
                             + 'If a root type does not use its default name, there should be no other type with that default name.',
@@ -285,21 +458,25 @@ class FederationBuiltIns extends definitions_1.BuiltIns {
                 type.rename(defaultName);
             }
         }
-        const externalTester = new ExternalTester(schema);
-        const externalFieldsInFedDirectivesCoordinates = [];
-        const keyDirective = this.keyDirective(schema);
-        validateAllFieldSet(keyDirective, type => type, errors, externalTester, externalFieldsInFedDirectivesCoordinates, true, true, field => {
-            if ((0, definitions_1.isListType)(field.type) || (0, definitions_1.isUnionType)(field.type) || (0, definitions_1.isInterfaceType)(field.type)) {
-                let kind = field.type.kind;
+        const metadata = federationMetadata(schema);
+        (0, utils_1.assert)(metadata, 'Federation schema should have had its metadata set on construction');
+        if (!metadata.isFed2Schema()) {
+            return errors;
+        }
+        const keyDirective = metadata.keyDirective();
+        validateAllFieldSet(keyDirective, type => type, errors, metadata, true, true, field => {
+            const type = (0, definitions_1.baseType)(field.type);
+            if ((0, definitions_1.isUnionType)(type) || (0, definitions_1.isInterfaceType)(type)) {
+                let kind = type.kind;
                 kind = kind.slice(0, kind.length - 'Type'.length);
                 throw error_1.ERRORS.KEY_FIELDS_SELECT_INVALID_TYPE.err({
                     message: `field "${field.coordinate}" is a ${kind} type which is not allowed in @key`
                 });
             }
         });
-        validateAllFieldSet(this.requiresDirective(schema), field => field.parent, errors, externalTester, externalFieldsInFedDirectivesCoordinates, false, false);
-        validateAllFieldSet(this.providesDirective(schema), field => {
-            if (externalTester.isExternal(field)) {
+        validateAllFieldSet(metadata.requiresDirective(), field => field.parent, errors, metadata, false, false);
+        validateAllFieldSet(metadata.providesDirective(), field => {
+            if (metadata.isFieldExternal(field)) {
                 throw new graphql_1.GraphQLError(`Cannot have both @provides and @external on field "${field.coordinate}"`, field.sourceAST);
             }
             const type = (0, definitions_1.baseType)(field.type);
@@ -310,90 +487,129 @@ class FederationBuiltIns extends definitions_1.BuiltIns {
                 });
             }
             return type;
-        }, errors, externalTester, externalFieldsInFedDirectivesCoordinates, false, false);
-        validateAllExternalFieldsUsed(schema, externalTester, externalFieldsInFedDirectivesCoordinates, errors);
-        const tagDirective = this.tagDirective(schema);
-        if (!tagDirective.isBuiltIn) {
+        }, errors, metadata, false, false);
+        validateNoExternalOnInterfaceFields(metadata, errors);
+        validateAllExternalFieldsUsed(metadata, errors);
+        const tagDirective = metadata.tagDirective();
+        if (tagDirective) {
             const error = tagSpec.checkCompatibleDirective(tagDirective);
             if (error) {
                 errors.push(error);
             }
         }
+        for (const itf of schema.types('InterfaceType')) {
+            validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errors);
+        }
         return errors;
     }
     validationRules() {
         return FEDERATION_VALIDATION_RULES;
     }
-    keyDirective(schema) {
-        return this.getTypedDirective(schema, exports.keyDirectiveName);
-    }
-    extendsDirective(schema) {
-        return this.getTypedDirective(schema, exports.extendsDirectiveName);
-    }
-    externalDirective(schema) {
-        return this.getTypedDirective(schema, exports.externalDirectiveName);
-    }
-    requiresDirective(schema) {
-        return this.getTypedDirective(schema, exports.requiresDirectiveName);
+}
+exports.FederationBlueprint = FederationBlueprint;
+const federationBlueprint = new FederationBlueprint();
+function findUnusedNamedForLinkDirective(schema) {
+    if (!schema.directive(linkSpec.url.name)) {
+        return undefined;
     }
-    providesDirective(schema) {
-        return this.getTypedDirective(schema, exports.providesDirectiveName);
+    const baseName = linkSpec.url.name;
+    let n = 1;
+    for (;;) {
+        const candidate = baseName + n;
+        if (!schema.directive(candidate)) {
+            return candidate;
+        }
     }
-    tagDirective(schema) {
-        return this.getTypedDirective(schema, exports.tagDirectiveName);
+}
+function setSchemaAsFed2Subgraph(schema) {
+    let core = schema.coreFeatures;
+    let spec;
+    if (core) {
+        spec = core.coreDefinition;
+        (0, utils_1.assert)(spec.url.version.satisfies(linkSpec.version), `Fed2 schema must use @link with version >= 1.0, but schema uses ${spec.url}`);
     }
-    maybeUpdateSubgraphDocument(schema, document) {
-        document = super.maybeUpdateSubgraphDocument(schema, document);
-        const definitions = document.definitions.concat();
-        for (const directiveName of FEDERATION_DIRECTIVES) {
-            const directive = schema.directive(directiveName);
-            (0, utils_1.assert)(directive, 'This method should only have been called on a schema with federation built-ins');
-            if (directive.isBuiltIn) {
-                definitions.push((0, graphql_1.parse)((0, print_1.printDirectiveDefinition)(directive, print_1.defaultPrintOptions)).definitions[0]);
-            }
-        }
-        return {
-            kind: graphql_1.Kind.DOCUMENT,
-            loc: document.loc,
-            definitions
-        };
+    else {
+        const alias = findUnusedNamedForLinkDirective(schema);
+        linkSpec.addToSchema(schema, alias);
+        spec = linkSpec;
+        core = schema.coreFeatures;
+        (0, utils_1.assert)(core, 'Schema should now be a core schema');
     }
+    (0, utils_1.assert)(!core.getByIdentity(federationSpec.identity), 'Schema already set as a federation subgraph');
+    schema.schemaDefinition.applyDirective(core.coreItself.nameInSchema, {
+        url: federationSpec.url.toString(),
+        import: federationSpec_1.FEDERATION2_SPEC_DIRECTIVES.map((spec) => `@${spec.name}`),
+    });
+    completeSubgraphSchema(schema);
 }
-exports.FederationBuiltIns = FederationBuiltIns;
-exports.federationBuiltIns = new FederationBuiltIns();
-function isFederationSubgraphSchema(schema) {
-    return schema.builtIns instanceof FederationBuiltIns;
+exports.setSchemaAsFed2Subgraph = setSchemaAsFed2Subgraph;
+function asFed2SubgraphDocument(document) {
+    const fed2LinkExtension = {
+        kind: graphql_1.Kind.SCHEMA_EXTENSION,
+        directives: [{
+                kind: graphql_1.Kind.DIRECTIVE,
+                name: { kind: graphql_1.Kind.NAME, value: coreSpec_1.linkDirectiveDefaultName },
+                arguments: [{
+                        kind: graphql_1.Kind.ARGUMENT,
+                        name: { kind: graphql_1.Kind.NAME, value: 'url' },
+                        value: { kind: graphql_1.Kind.STRING, value: federationSpec.url.toString() }
+                    },
+                    {
+                        kind: graphql_1.Kind.ARGUMENT,
+                        name: { kind: graphql_1.Kind.NAME, value: 'import' },
+                        value: { kind: graphql_1.Kind.LIST, values: federationSpec_1.FEDERATION2_SPEC_DIRECTIVES.map((spec) => ({ kind: graphql_1.Kind.STRING, value: `@${spec.name}` })) }
+                    }]
+            }]
+    };
+    return {
+        kind: graphql_1.Kind.DOCUMENT,
+        loc: document.loc,
+        definitions: document.definitions.concat(fed2LinkExtension)
+    };
 }
-exports.isFederationSubgraphSchema = isFederationSubgraphSchema;
-function isFederationType(type) {
-    return isFederationTypeName(type.name);
+exports.asFed2SubgraphDocument = asFed2SubgraphDocument;
+function printSubgraphNames(names) {
+    return (0, utils_1.printHumanReadableList)(names.map(n => `"${n}"`), {
+        prefix: 'subgraph',
+        prefixPlural: 'subgraphs',
+    });
 }
-exports.isFederationType = isFederationType;
-function isFederationTypeName(typeName) {
-    return FEDERATION_TYPES.includes(typeName);
+exports.printSubgraphNames = printSubgraphNames;
+function federationMetadata(schema) {
+    return schema['_federationMetadata'];
 }
-exports.isFederationTypeName = isFederationTypeName;
+exports.federationMetadata = federationMetadata;
+function isFederationSubgraphSchema(schema) {
+    return !!federationMetadata(schema);
+}
+exports.isFederationSubgraphSchema = isFederationSubgraphSchema;
 function isFederationField(field) {
     var _a;
     if (field.parent === ((_a = field.schema().schemaDefinition.root("query")) === null || _a === void 0 ? void 0 : _a.type)) {
-        return FEDERATION_ROOT_FIELDS.includes(field.name);
+        return exports.FEDERATION_OPERATION_FIELDS.includes(field.name);
     }
     return false;
 }
 exports.isFederationField = isFederationField;
-function isFederationDirective(directive) {
-    return FEDERATION_DIRECTIVES.includes(directive.name);
-}
-exports.isFederationDirective = isFederationDirective;
 function isEntityType(type) {
-    return type.kind == "ObjectType" && type.hasAppliedDirective(exports.keyDirectiveName);
+    if (type.kind !== "ObjectType") {
+        return false;
+    }
+    const metadata = federationMetadata(type.schema());
+    return !!metadata && type.hasAppliedDirective(metadata.keyDirective());
 }
 exports.isEntityType = isEntityType;
-function buildSubgraph(name, source) {
+function buildSubgraph(name, url, source) {
+    const buildOptions = {
+        blueprint: federationBlueprint,
+        validate: false,
+    };
+    let subgraph;
     try {
-        return typeof source === 'string'
-            ? (0, buildSchema_1.buildSchema)(new graphql_1.Source(source, name), exports.federationBuiltIns)
-            : (0, buildSchema_1.buildSchemaFromAST)(source, exports.federationBuiltIns);
+        const schema = typeof source === 'string'
+            ? (0, buildSchema_1.buildSchema)(new graphql_1.Source(source, name), buildOptions)
+            : (0, buildSchema_1.buildSchemaFromAST)(source, buildOptions);
+        subgraph = new Subgraph(name, url, schema);
     }
     catch (e) {
         if (e instanceof graphql_1.GraphQLError) {
@@ -403,14 +619,73 @@ function buildSubgraph(name, source) {
             throw e;
         }
     }
+    return subgraph.validate();
 }
 exports.buildSubgraph = buildSubgraph;
-function parseFieldSetArgument(parentType, directive, fieldAccessor = (type, name) => type.field(name)) {
+function newEmptyFederation2Schema() {
+    const schema = new definitions_1.Schema(federationBlueprint);
+    setSchemaAsFed2Subgraph(schema);
+    return schema;
+}
+exports.newEmptyFederation2Schema = newEmptyFederation2Schema;
+function completeSubgraphSchema(schema) {
+    const coreFeatures = schema.coreFeatures;
+    if (coreFeatures) {
+        const fedFeature = coreFeatures.getByIdentity(federationSpec_1.federationIdentity);
+        if (fedFeature) {
+            completeFed2SubgraphSchema(schema);
+        }
+        else {
+            completeFed1SubgraphSchema(schema);
+        }
+    }
+    else {
+        const fedLink = schema.schemaDefinition.appliedDirectivesOf(coreSpec_1.linkDirectiveDefaultName).find(isFedSpecLinkDirective);
+        if (fedLink) {
+            linkSpec.addToSchema(schema);
+            completeFed2SubgraphSchema(schema);
+        }
+        else {
+            completeFed1SubgraphSchema(schema);
+        }
+    }
+}
+function isFedSpecLinkDirective(directive) {
+    const args = directive.arguments();
+    return directive.name === coreSpec_1.linkDirectiveDefaultName && args['url'] && args['url'].startsWith(federationSpec_1.federationIdentity);
+}
+function completeFed1SubgraphSchema(schema) {
+    federationSpec_1.fieldSetTypeSpec.checkOrAdd(schema, '_' + federationSpec_1.fieldSetTypeSpec.name);
+    federationSpec_1.keyDirectiveSpec.checkOrAdd(schema);
+    federationSpec_1.requiresDirectiveSpec.checkOrAdd(schema);
+    federationSpec_1.providesDirectiveSpec.checkOrAdd(schema);
+    federationSpec_1.extendsDirectiveSpec.checkOrAdd(schema);
+    federationSpec_1.externalDirectiveSpec.checkOrAdd(schema);
+    federationSpec_1.tagDirectiveSpec.checkOrAdd(schema);
+}
+function completeFed2SubgraphSchema(schema) {
+    const coreFeatures = schema.coreFeatures;
+    (0, utils_1.assert)(coreFeatures, 'This method should not have been called on a non-core schema');
+    const fedFeature = coreFeatures.getByIdentity(federationSpec_1.federationIdentity);
+    (0, utils_1.assert)(fedFeature, 'This method should not have been called on a schema with no @link for federation');
+    const spec = federationSpec_1.FEDERATION_VERSIONS.find(fedFeature.url.version);
+    if (!spec) {
+        throw error_1.ERRORS.UNKNOWN_FEDERATION_LINK_VERSION.err({
+            message: `Invalid version ${fedFeature.url.version} for the federation feature in @link direction on schema`,
+            nodes: fedFeature.directive.sourceAST
+        });
+    }
+    spec.addElementsToSchema(schema);
+}
+function parseFieldSetArgument({ parentType, directive, fieldAccessor, validate, }) {
     var _a;
     try {
-        const selectionSet = (0, operations_1.parseSelectionSet)(parentType, validateFieldSetValue(directive), new definitions_1.VariableDefinitions(), undefined, fieldAccessor);
-        selectionSet.validate();
-        return selectionSet;
+        return (0, operations_1.parseSelectionSet)({
+            parentType,
+            source: validateFieldSetValue(directive),
+            fieldAccessor,
+            validate,
+        });
     }
     catch (e) {
         if (!(e instanceof graphql_1.GraphQLError)) {
@@ -425,14 +700,14 @@ function parseFieldSetArgument(parentType, directive, fieldAccessor = (type, nam
             if (msg.endsWith('.')) {
                 msg = msg.slice(0, msg.length - 1);
             }
-            if (directive.name === exports.keyDirectiveName) {
+            if (directive.name === federationSpec_1.keyDirectiveSpec.name) {
                 msg = msg + ' (the field should be either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).';
             }
             else {
                 msg = msg + ' (if the field is defined in another subgraph, you need to add it to this subgraph with @external).';
             }
         }
-        const codeDef = (_a = (0, error_1.errorCodeDef)(e)) !== null && _a !== void 0 ? _a : _1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS.get(directive.name);
+        const codeDef = (_a = (0, error_1.errorCodeDef)(e)) !== null && _a !== void 0 ? _a : error_1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS.get(directive.name);
         throw codeDef.err({
             message: `${fieldSetErrorDescriptor(directive)}: ${msg}`,
             nodes,
@@ -441,12 +716,45 @@ function parseFieldSetArgument(parentType, directive, fieldAccessor = (type, nam
     }
 }
 exports.parseFieldSetArgument = parseFieldSetArgument;
+function collectTargetFields({ parentType, directive, includeInterfaceFieldsImplementations, validate = true, }) {
+    const fields = [];
+    try {
+        parseFieldSetArgument({
+            parentType,
+            directive,
+            fieldAccessor: (t, f) => {
+                const field = t.field(f);
+                if (field) {
+                    fields.push(field);
+                    if (includeInterfaceFieldsImplementations && (0, definitions_1.isInterfaceType)(t)) {
+                        for (const implType of t.possibleRuntimeTypes()) {
+                            const implField = implType.field(f);
+                            if (implField) {
+                                fields.push(implField);
+                            }
+                        }
+                    }
+                }
+                return field;
+            },
+            validate,
+        });
+    }
+    catch (e) {
+        const isGraphQLError = (0, definitions_1.errorCauses)(e) !== undefined;
+        if (!isGraphQLError || validate) {
+            throw e;
+        }
+    }
+    return fields;
+}
+exports.collectTargetFields = collectTargetFields;
 function validateFieldSetValue(directive) {
     var _a;
     const fields = directive.arguments().fields;
     const nodes = directive.sourceAST;
     if (typeof fields !== 'string') {
-        throw _1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS_TYPE.get(directive.name).err({
+        throw error_1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS_TYPE.get(directive.name).err({
             message: `Invalid value for argument "${directive.definition.argument('fields').name}": must be a string.`,
             nodes,
         });
@@ -455,7 +763,7 @@ function validateFieldSetValue(directive) {
         for (const argNode of (_a = nodes.arguments) !== null && _a !== void 0 ? _a : []) {
             if (argNode.name.value === 'fields') {
                 if (argNode.value.kind !== 'StringValue') {
-                    throw _1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS_TYPE.get(directive.name).err({
+                    throw error_1.ERROR_CATEGORIES.DIRECTIVE_INVALID_FIELDS_TYPE.get(directive.name).err({
                         message: `Invalid value for argument "${directive.definition.argument('fields').name}": must be a string.`,
                         nodes,
                     });
@@ -472,7 +780,7 @@ function subgraphsFromServiceList(serviceList) {
     const subgraphs = new Subgraphs();
     for (const service of serviceList) {
         try {
-            subgraphs.add(service.name, (_a = service.url) !== null && _a !== void 0 ? _a : '', service.typeDefs);
+            subgraphs.add(buildSubgraph(service.name, (_a = service.url) !== null && _a !== void 0 ? _a : '', service.typeDefs));
         }
         catch (e) {
             const causes = (0, definitions_1.errorCauses)(e);
@@ -491,18 +799,12 @@ class Subgraphs {
     constructor() {
         this.subgraphs = new utils_1.OrderedMap();
     }
-    add(subgraphOrName, url, schema) {
-        const toAdd = typeof subgraphOrName === 'string'
-            ? new Subgraph(subgraphOrName, url, schema instanceof definitions_1.Schema ? schema : buildSubgraph(subgraphOrName, schema))
-            : subgraphOrName;
-        if (toAdd.name === exports.FEDERATION_RESERVED_SUBGRAPH_NAME) {
-            throw error_1.ERRORS.INVALID_SUBGRAPH_NAME.err({ message: `Invalid name ${exports.FEDERATION_RESERVED_SUBGRAPH_NAME} for a subgraph: this name is reserved` });
-        }
-        if (this.subgraphs.has(toAdd.name)) {
-            throw new Error(`A subgraph named ${toAdd.name} already exists` + (toAdd.url ? ` (with url '${toAdd.url}')` : ''));
+    add(subgraph) {
+        if (this.subgraphs.has(subgraph.name)) {
+            throw new Error(`A subgraph named ${subgraph.name} already exists` + (subgraph.url ? ` (with url '${subgraph.url}')` : ''));
         }
-        this.subgraphs.add(toAdd.name, toAdd);
-        return toAdd;
+        this.subgraphs.add(subgraph.name, subgraph);
+        return subgraph;
     }
     get(name) {
         return this.subgraphs.get(name);
@@ -521,22 +823,123 @@ class Subgraphs {
             yield subgraph;
         }
     }
+    validate() {
+        let errors = [];
+        for (const subgraph of this.values()) {
+            try {
+                subgraph.validate();
+            }
+            catch (e) {
+                const causes = (0, definitions_1.errorCauses)(e);
+                if (!causes) {
+                    throw e;
+                }
+                errors = errors.concat(causes);
+            }
+        }
+        return errors.length === 0 ? undefined : errors;
+    }
     toString() {
         return '[' + this.subgraphs.keys().join(', ') + ']';
     }
 }
 exports.Subgraphs = Subgraphs;
+exports.anyTypeSpec = (0, directiveAndTypeSpecification_1.createScalarTypeSpecification)({ name: '_Any' });
+exports.serviceTypeSpec = (0, directiveAndTypeSpecification_1.createObjectTypeSpecification)({
+    name: '_Service',
+    fieldsFct: (schema) => [{ name: 'sdl', type: schema.stringType() }],
+});
+exports.entityTypeSpec = (0, directiveAndTypeSpecification_1.createUnionTypeSpecification)({
+    name: '_Entity',
+    membersFct: (schema) => {
+        return schema.types("ObjectType").filter(isEntityType).map((t) => t.name);
+    },
+});
+exports.FEDERATION_OPERATION_TYPES = [exports.anyTypeSpec, exports.serviceTypeSpec, exports.entityTypeSpec];
+exports.serviceFieldName = '_service';
+exports.entitiesFieldName = '_entities';
+exports.FEDERATION_OPERATION_FIELDS = [exports.serviceFieldName, exports.entitiesFieldName];
 class Subgraph {
-    constructor(name, url, schema, validateSchema = true) {
+    constructor(name, url, schema) {
         this.name = name;
         this.url = url;
         this.schema = schema;
-        if (validateSchema) {
-            schema.validate();
+        if (name === exports.FEDERATION_RESERVED_SUBGRAPH_NAME) {
+            throw error_1.ERRORS.INVALID_SUBGRAPH_NAME.err({ message: `Invalid name ${exports.FEDERATION_RESERVED_SUBGRAPH_NAME} for a subgraph: this name is reserved` });
         }
     }
-    toString() {
-        return `${this.name} (${this.url})`;
+    metadata() {
+        const metadata = federationMetadata(this.schema);
+        (0, utils_1.assert)(metadata, 'The subgraph schema should have built with the federation built-ins.');
+        return metadata;
+    }
+    isFed2Subgraph() {
+        return this.metadata().isFed2Schema();
+    }
+    addFederationOperations() {
+        const metadata = this.metadata();
+        for (const type of exports.FEDERATION_OPERATION_TYPES) {
+            type.checkOrAdd(this.schema);
+        }
+        const queryRoot = this.schema.schemaDefinition.root("query");
+        const queryType = queryRoot ? queryRoot.type : this.schema.addType(new definitions_1.ObjectType("Query"));
+        const entityField = queryType.field(exports.entitiesFieldName);
+        const entityType = metadata.entityType();
+        if (entityType) {
+            const entityFieldType = new definitions_1.NonNullType(new definitions_1.ListType(entityType));
+            if (!entityField) {
+                queryType.addField(exports.entitiesFieldName, entityFieldType)
+                    .addArgument('representations', new definitions_1.NonNullType(new definitions_1.ListType(new definitions_1.NonNullType(metadata.anyType()))));
+            }
+            else if (!entityField.type) {
+                entityField.type = entityType;
+            }
+        }
+        else if (entityField) {
+            entityField.remove();
+        }
+        if (!queryType.field(exports.serviceFieldName)) {
+            queryType.addField(exports.serviceFieldName, metadata.serviceType());
+        }
+    }
+    validate() {
+        try {
+            this.addFederationOperations();
+            this.schema.validate();
+            return this;
+        }
+        catch (e) {
+            if (e instanceof graphql_1.GraphQLError) {
+                throw addSubgraphToError(e, this.name, error_1.ERRORS.INVALID_GRAPHQL);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    isPrintedDirective(d) {
+        var _a;
+        if (this.metadata().allFederationDirectives().includes(d)) {
+            return false;
+        }
+        const core = this.schema.coreFeatures;
+        return !core || ((_a = core.sourceFeature(d)) === null || _a === void 0 ? void 0 : _a.url.identity) !== coreSpec_1.linkIdentity;
+    }
+    isPrintedType(t) {
+        var _a;
+        if (this.metadata().allFederationTypes().includes(t)) {
+            return false;
+        }
+        const core = this.schema.coreFeatures;
+        return !core || ((_a = core.sourceFeature(t)) === null || _a === void 0 ? void 0 : _a.url.identity) !== coreSpec_1.linkIdentity;
+    }
+    toString(basePrintOptions = print_1.defaultPrintOptions) {
+        return (0, print_1.printSchema)(this.schema, {
+            ...basePrintOptions,
+            directiveDefinitionFilter: (d) => this.isPrintedDirective(d),
+            typeFilter: (t) => this.isPrintedType(t),
+            fieldFilter: (f) => !isFederationField(f),
+        });
     }
 }
 exports.Subgraph = Subgraph;
@@ -562,48 +965,61 @@ function addSubgraphToError(e, subgraphName, errorCode) {
                 source: cause.source,
                 positions: cause.positions,
                 path: cause.path,
-                originalError: cause.originalError,
+                originalError: cause,
                 extensions: cause.extensions,
             });
         }
         else {
-            return new graphql_1.GraphQLError(message, nodes, cause.source, cause.positions, cause.path, cause.originalError, cause.extensions);
+            return new graphql_1.GraphQLError(message, nodes, cause.source, cause.positions, cause.path, cause, cause.extensions);
         }
     });
-    return (0, definitions_1.ErrGraphQLValidationFailed)(updatedCauses);
+    return updatedCauses.length === 1 ? updatedCauses[0] : (0, definitions_1.ErrGraphQLValidationFailed)(updatedCauses);
 }
 exports.addSubgraphToError = addSubgraphToError;
 class ExternalTester {
     constructor(schema) {
         this.schema = schema;
         this.fakeExternalFields = new Set();
+        this.providedFields = new Set();
+        this.externalDirective = this.metadata().externalDirective();
         this.collectFakeExternals();
+        this.collectProvidedFields();
+    }
+    metadata() {
+        const metadata = federationMetadata(this.schema);
+        (0, utils_1.assert)(metadata, 'Schema should be a subgraphs schema');
+        return metadata;
     }
     collectFakeExternals() {
-        const keyDirective = exports.federationBuiltIns.keyDirective(this.schema);
-        if (!keyDirective) {
-            return;
-        }
-        for (const key of keyDirective.applications()) {
-            const parent = key.parent;
-            if (!(key.ofExtension() || parent.hasAppliedDirective(exports.extendsDirectiveName))) {
+        const metadata = this.metadata();
+        const extendsDirective = metadata.extendsDirective();
+        for (const key of metadata.keyDirective().applications()) {
+            const parentType = key.parent;
+            if (!(key.ofExtension() || parentType.hasAppliedDirective(extendsDirective))) {
                 continue;
             }
-            try {
-                parseFieldSetArgument(parent, key, (parentType, fieldName) => {
-                    const field = parentType.field(fieldName);
-                    if (field && field.hasAppliedDirective(exports.externalDirectiveName)) {
-                        this.fakeExternalFields.add(field.coordinate);
-                    }
-                    return field;
-                });
-            }
-            catch (e) {
-            }
+            collectTargetFields({
+                parentType,
+                directive: key,
+                includeInterfaceFieldsImplementations: false,
+                validate: false,
+            }).filter((field) => field.hasAppliedDirective(this.externalDirective))
+                .forEach((field) => this.fakeExternalFields.add(field.coordinate));
+        }
+    }
+    collectProvidedFields() {
+        for (const provides of this.metadata().providesDirective().applications()) {
+            const parent = provides.parent;
+            collectTargetFields({
+                parentType: (0, definitions_1.baseType)(parent.type),
+                directive: provides,
+                includeInterfaceFieldsImplementations: true,
+                validate: false,
+            }).forEach((f) => this.providedFields.add(f.coordinate));
         }
     }
     isExternal(field) {
-        return field.hasAppliedDirective(exports.externalDirectiveName) && !this.isFakeExternal(field);
+        return field.hasAppliedDirective(this.externalDirective) && !this.isFakeExternal(field);
     }
     isFakeExternal(field) {
         return this.fakeExternalFields.has(field.coordinate);
@@ -621,6 +1037,102 @@ class ExternalTester {
         }
         return false;
     }
+    isPartiallyExternal(field) {
+        return this.isExternal(field) && this.providedFields.has(field.coordinate);
+    }
+    isFullyExternal(field) {
+        return this.isExternal(field) && !this.providedFields.has(field.coordinate);
+    }
+}
+function removeInactiveProvidesAndRequires(schema, onModified = () => { }) {
+    const metadata = federationMetadata(schema);
+    if (!metadata) {
+        return;
+    }
+    const providesDirective = metadata.providesDirective();
+    const requiresDirective = metadata.requiresDirective();
+    for (const type of schema.types()) {
+        if (!(0, definitions_1.isObjectType)(type) && !(0, definitions_1.isInterfaceType)(type)) {
+            continue;
+        }
+        for (const field of type.fields()) {
+            const fieldBaseType = (0, definitions_1.baseType)(field.type);
+            removeInactiveApplications(providesDirective, field, fieldBaseType, onModified);
+            removeInactiveApplications(requiresDirective, field, type, onModified);
+        }
+    }
+}
+exports.removeInactiveProvidesAndRequires = removeInactiveProvidesAndRequires;
+function removeInactiveApplications(directiveDefinition, field, parentType, onModified) {
+    for (const application of field.appliedDirectivesOf(directiveDefinition)) {
+        let selection;
+        try {
+            selection = parseFieldSetArgument({ parentType, directive: application });
+        }
+        catch (e) {
+            continue;
+        }
+        if (selectsNonExternalLeafField(selection)) {
+            application.remove();
+            const updated = withoutNonExternalLeafFields(selection);
+            if (!updated.isEmpty()) {
+                const updatedDirective = field.applyDirective(directiveDefinition, { fields: updated.toString(true, false) });
+                onModified(field, application, updatedDirective);
+            }
+            else {
+                onModified(field, application);
+            }
+        }
+    }
+}
+function isExternalOrHasExternalImplementations(field) {
+    const metadata = federationMetadata(field.schema());
+    if (!metadata) {
+        return false;
+    }
+    if (field.hasAppliedDirective(metadata.externalDirective())) {
+        return true;
+    }
+    const parentType = field.parent;
+    if ((0, definitions_1.isInterfaceType)(parentType)) {
+        for (const implem of parentType.possibleRuntimeTypes()) {
+            const fieldInImplem = implem.field(field.name);
+            if (fieldInImplem && fieldInImplem.hasAppliedDirective(metadata.externalDirective())) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function selectsNonExternalLeafField(selection) {
+    return selection.selections().some(s => {
+        if (s.kind === 'FieldSelection') {
+            if (isExternalOrHasExternalImplementations(s.field.definition)) {
+                return false;
+            }
+            return !s.selectionSet || selectsNonExternalLeafField(s.selectionSet);
+        }
+        else {
+            return selectsNonExternalLeafField(s.selectionSet);
+        }
+    });
+}
+function withoutNonExternalLeafFields(selectionSet) {
+    const newSelectionSet = new operations_1.SelectionSet(selectionSet.parentType);
+    for (const selection of selectionSet.selections()) {
+        if (selection.kind === 'FieldSelection') {
+            if (isExternalOrHasExternalImplementations(selection.field.definition)) {
+                newSelectionSet.add(selection);
+                continue;
+            }
+        }
+        if (selection.selectionSet) {
+            const updated = withoutNonExternalLeafFields(selection.selectionSet);
+            if (!updated.isEmpty()) {
+                newSelectionSet.add((0, operations_1.selectionOfElement)(selection.element(), updated));
+            }
+        }
+    }
+    return newSelectionSet;
 }
-exports.ExternalTester = ExternalTester;
 //# sourceMappingURL=federation.js.map