@apollo/federation-internals 2.0.2 → 2.0.3

package/src/definitions.ts

@@ -14,7 +14,10 @@ import {
   parse,
   TypeNode,
   VariableDefinitionNode,
-  VariableNode
+  VariableNode,
+  TypeSystemDefinitionNode,
+  SchemaDefinitionNode,
+  TypeDefinitionNode
 } from "graphql";
 import {
   CoreImport,
@@ -27,9 +30,9 @@ import {
   removeAllCoreFeatures,
 } from "./coreSpec";
 import { assert, mapValues, MapWithCachedArrays, setValues } from "./utils";
-import { withDefaultValues, valueEquals, valueToString, valueToAST, variablesInValue, valueFromAST, valueNodeToConstValueNode } from "./values";
+import { withDefaultValues, valueEquals, valueToString, valueToAST, variablesInValue, valueFromAST, valueNodeToConstValueNode, argumentsEquals } from "./values";
 import { removeInaccessibleElements } from "./inaccessibleSpec";
-import { defaultPrintOptions, printSchema } from './print';
+import { printSchema } from './print';
 import { sameType } from './types';
 import { addIntrospectionFields, introspectionFieldNames, isIntrospectionName } from "./introspection";
 import { err } from '@apollo/core-schema';
@@ -273,6 +276,10 @@ export function runtimeTypesIntersects(t1: CompositeType, t2: CompositeType): bo
   return false;
 }
 
+export function isConditionalDirective(directive: Directive<any, any> | DirectiveDefinition<any>): boolean {
+  return ['include', 'skip'].includes(directive.name);
+}
+
 export const executableDirectiveLocations: DirectiveLocation[] = [
   DirectiveLocation.QUERY,
   DirectiveLocation.MUTATION,
@@ -634,6 +641,7 @@ export abstract class NamedSchemaElement<TOwnType extends NamedSchemaElement<TOw
 abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSchemaElement<TOwnType, Schema, TReferencer>> extends NamedSchemaElement<TOwnType, Schema, TReferencer> {
   protected readonly _referencers: Set<TReferencer> = new Set();
   protected readonly _extensions: Set<Extension<TOwnType>> = new Set();
+  public preserveEmptyDefinition: boolean = false;
 
   constructor(name: string, readonly isBuiltIn: boolean = false) {
     super(name);
@@ -699,7 +707,9 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
   }
 
   hasNonExtensionElements(): boolean {
-    return this._appliedDirectives.some(d => d.ofExtension() === undefined) || this.hasNonExtensionInnerElements();
+    return this.preserveEmptyDefinition 
+      || this._appliedDirectives.some(d => d.ofExtension() === undefined)
+      || this.hasNonExtensionInnerElements();
   }
 
   protected abstract hasNonExtensionInnerElements(): boolean;
@@ -1014,8 +1024,8 @@ export class CoreFeatures {
     this.byIdentity.set(feature.url.identity, feature);
   }
 
-  sourceFeature(element: DirectiveDefinition | NamedType): CoreFeature | undefined {
-    const isDirective = element instanceof DirectiveDefinition;
+  sourceFeature(element: DirectiveDefinition | Directive | NamedType): CoreFeature | undefined {
+    const isDirective = element instanceof DirectiveDefinition || element instanceof Directive;
     const splitted = element.name.split('__');
     if (splitted.length > 1) {
       return this.byAlias.get(splitted[0]);
@@ -1167,17 +1177,69 @@ export class Schema {
     return this.apiSchema;
   }
 
-  toGraphQLJSSchema(isSubgraph: boolean = false): GraphQLSchema {
-    // Obviously not super fast, but as long as we don't use this often on a hot path, that's probably ok.
-    if (!isSubgraph) {
-      return buildGraphqlSchemaFromAST(this.toAST());
+  private emptyASTDefinitionsForExtensionsWithoutDefinition(): TypeSystemDefinitionNode[] {
+    const nodes = [];
+    if (this.schemaDefinition.hasExtensionElements() && !this.schemaDefinition.hasNonExtensionElements()) {
+      const node: SchemaDefinitionNode = { kind: Kind.SCHEMA_DEFINITION, operationTypes: [] };
+      nodes.push(node);
+    }
+    for (const type of this.types()) {
+      if (type.hasExtensionElements() && !type.hasNonExtensionElements()) {
+        const node: TypeDefinitionNode = {
+          kind: type.astDefinitionKind,
+          name: { kind: Kind.NAME, value: type.name },
+        };
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+
+  toGraphQLJSSchema(): GraphQLSchema {
+    let ast = this.toAST();
+
+    // Note that AST generated by `this.toAST()` may not be fully graphQL valid because, in federation subgraphs, we accept
+    // extensions that have no corresponding definitions. This won't fly however if we try to build a `GraphQLSchema`, so
+    // we need to "fix" that problem. For that, we add empty definitions for every element that has extensions without
+    // definitions (which is also what `fed1` was effectively doing).
+    const additionalNodes = this.emptyASTDefinitionsForExtensionsWithoutDefinition();
+    if (additionalNodes.length > 0) {
+      ast = {
+        kind: Kind.DOCUMENT,
+        definitions: ast.definitions.concat(additionalNodes),
+      }
     }
 
-    // Some subgraphs, especially federation 1 ones, cannot be properly converted to a GraphQLSchema because they are invalid graphQL.
-    // And the main culprit is type extensions that don't have a corresponding definition. So to avoid that problem, we print
-    // up the AST without extensions.
-    const ast = parse(printSchema(this, { ...defaultPrintOptions, mergeTypesAndExtensions: true }), { noLocation: true });
-    return buildGraphqlSchemaFromAST(ast);
+    const graphQLSchema = buildGraphqlSchemaFromAST(ast);
+    if (additionalNodes.length > 0) {
+      // As mentionned, if we have extensions without definition, we _have_ to add an empty definition to be able to
+      // build a `GraphQLSchema` object. But that also mean that we lose the information doing so, as we cannot
+      // distinguish anymore that we have no definition. A method like `graphQLSchemaToAST` for instance, would
+      // include a definition in particular, and that could a bit surprised (and could lead to an hard-to-find bug
+      // in the worst case if you were expecting it that something like `graphQLSchemaToAST(buildSchema(defs).toGraphQLJSSchema())`
+      // gives you back the original `defs`).
+      // So to avoid this, we manually delete the definition `astNode` post-construction on the created schema if
+      // we had not definition. This should break users of the resulting schema since `astNode` is allowed to be `undefined`,
+      // but it allows `graphQLSchemaToAST` to make the proper distinction in general.
+      for (const node of additionalNodes) {
+        switch (node.kind) {
+          case Kind.SCHEMA_DEFINITION:
+            graphQLSchema.astNode = undefined;
+            break;
+          case Kind.SCALAR_TYPE_DEFINITION:
+          case Kind.OBJECT_TYPE_DEFINITION:
+          case Kind.INTERFACE_TYPE_DEFINITION:
+          case Kind.ENUM_TYPE_DEFINITION:
+          case Kind.UNION_TYPE_DEFINITION:
+          case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            const type = graphQLSchema.getType(node.name.value);
+            if (type) {
+              type.astNode = undefined;
+            }
+        }
+      }
+    }
+    return graphQLSchema;
   }
 
   get schemaDefinition(): SchemaDefinition {
@@ -1525,6 +1587,7 @@ export class SchemaDefinition extends SchemaElement<SchemaDefinition, Schema>  {
   readonly kind = 'SchemaDefinition' as const;
   protected readonly _roots = new MapWithCachedArrays<SchemaRootKind, RootType>();
   protected readonly _extensions = new Set<Extension<SchemaDefinition>>();
+  public preserveEmptyDefinition: boolean = false;
 
   roots(): readonly RootType[] {
     return this._roots.values();
@@ -1616,6 +1679,16 @@ export class SchemaDefinition extends SchemaElement<SchemaDefinition, Schema>  {
     return extension;
   }
 
+  hasExtensionElements(): boolean {
+    return this._extensions.size > 0;
+  }
+
+  hasNonExtensionElements(): boolean {
+    return this.preserveEmptyDefinition 
+      || this._appliedDirectives.some((d) => d.ofExtension() === undefined)
+      || this.roots().some((r) => r.ofExtension() === undefined);
+  }
+
   private removeRootType(rootType: RootType) {
     this._roots.delete(rootType.rootKind);
     removeReferenceToType(this, rootType.type);
@@ -1636,6 +1709,7 @@ export class SchemaDefinition extends SchemaElement<SchemaDefinition, Schema>  {
 
 export class ScalarType extends BaseNamedType<OutputTypeReferencer | InputTypeReferencer, ScalarType> {
   readonly kind = 'ScalarType' as const;
+  readonly astDefinitionKind = Kind.SCALAR_TYPE_DEFINITION;
 
   protected removeTypeReference(type: NamedType) {
     assert(false, `Scalar type ${this} can't reference other types; shouldn't be asked to remove reference to ${type}`);
@@ -1865,6 +1939,7 @@ abstract class FieldBasedType<T extends (ObjectType | InterfaceType) & NamedSche
 
 export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer> {
   readonly kind = 'ObjectType' as const;
+  readonly astDefinitionKind = Kind.OBJECT_TYPE_DEFINITION;
 
   /**
    *  Whether this type is one of the schema root type (will return false if the type is detached).
@@ -1899,6 +1974,7 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
 
 export class InterfaceType extends FieldBasedType<InterfaceType, InterfaceTypeReferencer> {
   readonly kind = 'InterfaceType' as const;
+  readonly astDefinitionKind = Kind.INTERFACE_TYPE_DEFINITION;
 
   allImplementations(): (ObjectType | InterfaceType)[] {
     return setValues(this._referencers).filter(ref => ref.kind === 'ObjectType' || ref.kind === 'InterfaceType') as (ObjectType | InterfaceType)[];
@@ -1935,6 +2011,7 @@ export class UnionMember extends BaseExtensionMember<UnionType> {
 
 export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
   readonly kind = 'UnionType' as const;
+  readonly astDefinitionKind = Kind.UNION_TYPE_DEFINITION;
   protected readonly _members: MapWithCachedArrays<string, UnionMember> = new MapWithCachedArrays();
   private _typenameField?: FieldDefinition<UnionType>;
 
@@ -2057,6 +2134,7 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
 
 export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
   readonly kind = 'EnumType' as const;
+  readonly astDefinitionKind = Kind.ENUM_TYPE_DEFINITION;
   protected readonly _values: EnumValue[] = [];
 
   get values(): readonly EnumValue[] {
@@ -2128,6 +2206,7 @@ export class EnumType extends BaseNamedType<OutputTypeReferencer, EnumType> {
 
 export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObjectType> {
   readonly kind = 'InputObjectType' as const;
+  readonly astDefinitionKind = Kind.INPUT_OBJECT_TYPE_DEFINITION;
   private readonly _fields: Map<string, InputFieldDefinition> = new Map();
   private _cachedFieldsArray?: InputFieldDefinition[];
 
@@ -2984,6 +3063,51 @@ export class Directive<
   }
 }
 
+export function sameDirectiveApplication(application1: Directive<any, any>, application2: Directive<any, any>): boolean {
+  return application1.name === application2.name && argumentsEquals(application1.arguments(), application2.arguments());
+}
+
+/**
+ * Checks whether the 2 provided "set" of directive applications are the same (same applications, regardless or order).
+ */
+export function sameDirectiveApplications(applications1: Directive<any, any>[], applications2: Directive<any, any>[]): boolean {
+  if (applications1.length !== applications2.length) {
+    return false;
+  }
+
+  for (const directive1 of applications1) {
+    if (!applications2.some(directive2 => sameDirectiveApplication(directive1, directive2))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Checks whether a given array of directive applications (`maybeSubset`) is a sub-set of another array of directive applications (`applications`).
+ *
+ * Sub-set here means that all of the applications in `maybeSubset` appears in `applications`. 
+ */
+export function isDirectiveApplicationsSubset(applications: Directive<any, any>[], maybeSubset: Directive<any, any>[]): boolean {
+  if (maybeSubset.length > applications.length) {
+    return false;
+  }
+
+  for (const directive1 of maybeSubset) {
+    if (!applications.some(directive2 => sameDirectiveApplication(directive1, directive2))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Computes the difference between the set of directives applications `baseApplications` and the `toRemove` one.
+ */
+export function directiveApplicationsSubstraction(baseApplications: Directive<any, any>[], toRemove: Directive<any, any>[]): Directive<any, any>[] {
+  return baseApplications.filter((application) => !toRemove.some((other) => sameDirectiveApplication(application, other)));
+}
+
 export class Variable {
   constructor(readonly name: string) {}
 
@@ -3257,6 +3381,7 @@ function copyOfExtension<T extends ExtendableElement>(
 }
 
 function copySchemaDefinitionInner(source: SchemaDefinition, dest: SchemaDefinition) {
+  dest.preserveEmptyDefinition = source.preserveEmptyDefinition;
   const extensionsMap = copyExtensions(source, dest);
   for (const rootType of source.roots()) {
     copyOfExtension(extensionsMap, rootType, dest.setRoot(rootType.rootKind, rootType.type.name));
@@ -3271,6 +3396,7 @@ function copySchemaDefinitionInner(source: SchemaDefinition, dest: SchemaDefinit
 }
 
 function copyNamedTypeInner(source: NamedType, dest: NamedType) {
+  dest.preserveEmptyDefinition = source.preserveEmptyDefinition;
   const extensionsMap = copyExtensions(source, dest);
   // Same as copyAppliedDirectives, but as the directive applies to the type, we need to remember if the application
   // is for the extension or not.

package/src/directiveAndTypeSpecification.ts

@@ -227,7 +227,7 @@ export function createEnumTypeSpecification({
         const actualValueNames = existing.values.map(v => v.name).sort((n1, n2) => n1.localeCompare(n2));
         if (!arrayEquals(expectedValueNames, actualValueNames)) {
           errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
-            message: `Invalid definition of type ${name}: expected values [${expectedValueNames}] but found [${actualValueNames}].`,
+            message: `Invalid definition for type "${name}": expected values [${expectedValueNames.join(', ')}] but found [${actualValueNames.join(', ')}].`,
             nodes: existing.sourceAST
           }));
         }

package/src/federation.ts

@@ -61,6 +61,7 @@ import {
   LinkDirectiveArgs,
   linkDirectiveDefaultName,
   linkIdentity,
+  FeatureUrl,
 } from "./coreSpec";
 import {
   FEDERATION_VERSIONS,
@@ -1406,10 +1407,48 @@ export class Subgraph {
       return false;
     }
 
+    // If the query type only have our federation specific fields, then that (almost surely) means the original subgraph
+    // had no Query type and so we save printing it.
+    if (isObjectType(t) && t.isQueryRootType() && t.fields().filter((f) => !isFederationField(f)).length === 0) {
+      return false;
+    }
+
     const core = this.schema.coreFeatures;
     return !core || core.sourceFeature(t)?.url.identity !== linkIdentity;
   }
 
+  private isPrintedDirectiveApplication(d: Directive): boolean {
+    // We print almost all directive application, but the one we skip is the `@link` to the link spec itself.
+    // The reason is that it is one of the things that usually not provided by users but is instead auto-added
+    // and so this keep the output a tad "cleaner".
+    // Do note that it is only auto-added if it uses the `@link` name. If it is renamed, we need to include
+    // the application (and more generally, if there is more argument set than just the url, we print
+    // the directive to make sure we're not hidding something relevant).
+    if (!this.schema.coreFeatures || d.name !== linkSpec.url.name) {
+      return true;
+    }
+    const args = d.arguments();
+    let urlArg: FeatureUrl | undefined = undefined;
+    if ('url' in args) {
+      try {
+        urlArg = FeatureUrl.parse(args['url']);
+      } catch (e) {
+        // ignored on purpose: if the 'url' arg don't parse properly as a Feature url, then `urlArg` will
+        // be `undefined` which we want.
+      }
+    }
+    const isDefaultLinkToLink = urlArg?.identity === linkIdentity && Object.keys(args).length === 1;
+    return !isDefaultLinkToLink;
+  }
+
+  /**
+   * Returns a representation of the subgraph without any auto-imported directive definitions or "federation private"
+   * types and fiels (`_service` et al.).
+   *
+   * In other words, this will correspond to what a user would usually write.
+   *
+   * Note that if one just want a representation of the full schema, then it can simply call `printSchema(this.schema)`.
+   */
   toString(basePrintOptions: PrintOptions = defaultPrintOptions) {
     return printSchema(
       this.schema,
@@ -1418,6 +1457,7 @@ export class Subgraph {
         directiveDefinitionFilter: (d) => this.isPrintedDirective(d),
         typeFilter: (t) => this.isPrintedType(t),
         fieldFilter: (f) => !isFederationField(f),
+        directiveApplicationFilter: (d) => this.isPrintedDirectiveApplication(d),
       }
     );
   }

package/src/graphQLJSSchemaToAST.ts

@@ -0,0 +1,138 @@
+import {
+  DefinitionNode,
+  DirectiveDefinitionNode,
+  DocumentNode,
+  GraphQLDirective,
+  GraphQLNamedType,
+  GraphQLObjectType,
+  GraphQLSchema,
+  isIntrospectionType,
+  isSpecifiedDirective,
+  isSpecifiedScalarType,
+  Kind,
+  OperationTypeDefinitionNode,
+  OperationTypeNode,
+  parse,
+  printSchema,
+  printType,
+  SchemaDefinitionNode,
+  SchemaExtensionNode,
+  TypeDefinitionNode,
+  TypeExtensionNode
+} from "graphql";
+import { Maybe } from "graphql/jsutils/Maybe";
+import { defaultRootName } from "./definitions";
+
+const allOperationTypeNode = [ OperationTypeNode.QUERY, OperationTypeNode.MUTATION, OperationTypeNode.SUBSCRIPTION];
+
+/**
+ * Converts a graphql-js schema into an equivalent AST document.
+ *
+ * Note importantly that this method is not, in general, equivalent to `parse(printSchema(schema))` in that
+ * the returned AST will contain directive _applications_ when those can be found in AST nodes linked by
+ * the elements of the provided schema.
+ */
+export function graphQLJSSchemaToAST(schema: GraphQLSchema): DocumentNode {
+  const types = Object.values(schema.getTypeMap()).filter((type) => !isIntrospectionType(type) && !isSpecifiedScalarType(type));
+  const directives = schema.getDirectives().filter((directive) => !isSpecifiedDirective(directive));
+
+  const schemaASTs = toNodeArray(graphQLJSSchemaToSchemaDefinitionAST(schema));
+  const typesASTs = types.map((type) => toNodeArray(graphQLJSNamedTypeToAST(type))).flat();
+  const directivesASTs = directives.map((directive) => graphQLJSDirectiveToAST(directive));
+
+  return {
+    kind: Kind.DOCUMENT,
+    definitions: [...schemaASTs, ...typesASTs, ...directivesASTs],
+  }
+}
+
+function toNodeArray<TDef extends DefinitionNode, TExt extends DefinitionNode>({
+  definition,
+  extensions,
+}: {
+  definition?: TDef,
+  extensions: readonly TExt[]}
+): readonly DefinitionNode[] {
+  return definition ? [definition, ...extensions] : extensions;
+}
+
+function maybe<T>(v: Maybe<T>): T | undefined {
+  return v ? v : undefined;
+}
+
+// Not exposing that one for now because it's a bit weirder API-wise (and take a `GraphqQLSchema` but only handle a specific subpart of it) .
+function graphQLJSSchemaToSchemaDefinitionAST(schema: GraphQLSchema): { definition?: SchemaDefinitionNode, extensions: readonly SchemaExtensionNode[] } {
+  if (schema.astNode || schema.extensionASTNodes.length > 0) {
+    return {
+      definition: maybe(schema.astNode),
+      extensions: schema.extensionASTNodes,
+    };
+  } else {
+    let definition: SchemaDefinitionNode | undefined = undefined;
+    if (hasNonDefaultRootNames(schema)) {
+      const operationTypes: OperationTypeDefinitionNode[] = [];
+      for (const operation of allOperationTypeNode) {
+        const type = schema.getRootType(operation);
+        if (type) {
+          operationTypes.push({
+            kind: Kind.OPERATION_TYPE_DEFINITION,
+            operation,
+            type: { kind: Kind.NAMED_TYPE, name: { kind: Kind.NAME, value : type.name } },
+          });
+        }
+      }
+      definition = {
+        kind: Kind.SCHEMA_DEFINITION,
+        description: schema.description ? {
+          kind: Kind.STRING,
+          value: schema.description,
+        } : undefined,
+        operationTypes,
+      }
+    }
+    return {
+      definition,
+      extensions: [],
+    };
+  }
+}
+
+function hasNonDefaultRootNames(schema: GraphQLSchema): boolean {
+  return allOperationTypeNode.some((t) => isNonDefaultRootName(schema.getRootType(t), t));
+}
+
+function isNonDefaultRootName(type: Maybe<GraphQLObjectType>, operation: OperationTypeNode): boolean {
+  return !!type && type.name !== defaultRootName(operation);
+}
+
+export function graphQLJSNamedTypeToAST(type: GraphQLNamedType): { definition?: TypeDefinitionNode, extensions: readonly TypeExtensionNode[] }  {
+  if (type.astNode || type.extensionASTNodes.length > 0) {
+    return {
+      definition: maybe(type.astNode),
+      extensions: type.extensionASTNodes,
+    };
+  } else {
+    // While we could theoretically manually build the AST, it's just simpler to print the type and parse it back.
+    return {
+      definition: parse(printType(type)).definitions[0] as TypeDefinitionNode,
+      extensions: [],
+    };
+  }
+}
+
+export function graphQLJSDirectiveToAST(directive: GraphQLDirective): DirectiveDefinitionNode {
+  if (directive.astNode) {
+    return directive.astNode;
+  } else {
+    // Note that the trick used for type of printing and parsing back is tad less convenient here because graphQL-js does not
+    // expose a direct way to print a directive alone. So we work-around it by built-in a "fake" schema with essentially just
+    // that directive.
+    const fakeSchema = new GraphQLSchema({
+      directives: [directive],
+      assumeValid: true,
+    });
+    const reparsed = parse(printSchema(fakeSchema));
+    return reparsed.definitions.find((def) => def.kind === Kind.DIRECTIVE_DEFINITION) as DirectiveDefinitionNode;
+  }
+}
+

package/src/index.ts

@@ -17,3 +17,4 @@ export * from './extractSubgraphsFromSupergraph';
 export * from './error';
 export * from './schemaUpgrader';
 export * from './suggestions';
+export * from './graphQLJSSchemaToAST';

package/src/operations.ts

@@ -41,6 +41,9 @@ import {
   CompositeType,
   typenameFieldName,
   NamedType,
+  sameDirectiveApplications,
+  isConditionalDirective,
+  isDirectiveApplicationsSubset,
 } from "./definitions";
 import { sameType } from "./types";
 import { assert, mapEntries, MapWithCachedArrays, MultiMap } from "./utils";
@@ -53,16 +56,7 @@ function validate(condition: any, message: () => string, sourceAST?: ASTNode): a
 }
 
 function haveSameDirectives<TElement extends OperationElement>(op1: TElement, op2: TElement): boolean {
-  if (op1.appliedDirectives.length != op2.appliedDirectives.length) {
-    return false;
-  }
-
-  for (const thisDirective of op1.appliedDirectives) {
-    if (!op2.appliedDirectives.some(thatDirective => thisDirective.name === thatDirective.name && argumentsEquals(thisDirective.arguments(), thatDirective.arguments()))) {
-      return false;
-    }
-  }
-  return true;
+  return sameDirectiveApplications(op1.appliedDirectives, op2.appliedDirectives);
 }
 
 abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> extends DirectiveTargetElement<T> {
@@ -306,6 +300,13 @@ export function sameOperationPaths(p1: OperationPath, p2: OperationPath): boolea
   return true;
 }
 
+/**
+ * Returns all the "conditional" directive applications (`@skip` and `@include`) in the provided path.
+ */
+export function conditionalDirectivesInOperationPath(path: OperationPath): Directive<any, any>[] {
+  return path.map((e) => e.appliedDirectives).flat().filter((d) => isConditionalDirective(d));
+}
+
 export function concatOperationPaths(head: OperationPath, tail: OperationPath): OperationPath {
   // While this is mainly a simple array concatenation, we optimize slightly by recognizing if the
   // tail path starts by a fragment selection that is useless given the end of the head path.
@@ -316,14 +317,21 @@ export function concatOperationPaths(head: OperationPath, tail: OperationPath):
     return head;
   }
   const lastOfHead = head[head.length - 1];
-  const firstOfTail = tail[0];
-  if (isUselessFollowupElement(lastOfHead, firstOfTail)) {
+  const conditionals = conditionalDirectivesInOperationPath(head);
+  let firstOfTail = tail[0];
+  // Note that in practice, we may be able to eliminate a few elements at the beginning of the path
+  // due do conditionals ('@skip' and '@include'). Indeed, a (tail) path crossing multiple conditions
+  // may start with: [ ... on X @include(if: $c1), ... on X @ksip(if: $c2), (...)], but if `head`
+  // already ends on type `X` _and_ both the conditions on `$c1` and `$c2` are alredy found on `head`,
+  // then we can remove both fragments in `tail`.
+  while (firstOfTail && isUselessFollowupElement(lastOfHead, firstOfTail, conditionals)) {
     tail = tail.slice(1);
+    firstOfTail = tail[0];
   }
   return head.concat(tail);
 }
 
-function isUselessFollowupElement(first: OperationElement, followup: OperationElement): boolean {
+function isUselessFollowupElement(first: OperationElement, followup: OperationElement, conditionals: Directive<any, any>[]): boolean {
   const typeOfFirst = first.kind === 'Field'
     ? baseType(first.definition.type!)
     : first.typeCondition;
@@ -333,7 +341,7 @@ function isUselessFollowupElement(first: OperationElement, followup: OperationEl
   return !!typeOfFirst
     && followup.kind === 'FragmentElement'
     && !!followup.typeCondition
-    && followup.appliedDirectives.length === 0
+    && (followup.appliedDirectives.length === 0 || isDirectiveApplicationsSubset(conditionals, followup.appliedDirectives))
     && sameType(typeOfFirst, followup.typeCondition);
 }
 
@@ -766,7 +774,7 @@ export class SelectionSet extends Freezable<SelectionSet> {
     this._selections.add(key, toAdd);
     ++this._selectionCount;
     this._cachedSelections = undefined;
-    return selection;
+    return toAdd;
   }
 
   addPath(path: OperationPath) {
@@ -1128,9 +1136,27 @@ export class FieldSelection extends Freezable<FieldSelection> {
 
   updateForAddingTo(selectionSet: SelectionSet): FieldSelection {
     const updatedField = this.field.updateForAddingTo(selectionSet);
-    return this.field === updatedField
-      ? this.cloneIfFrozen()
-      : new FieldSelection(updatedField, this.selectionSet?.cloneIfFrozen());
+    if (this.field === updatedField) {
+      return this.cloneIfFrozen();
+    }
+
+    // We create a new selection that not only uses the updated field, but also ensures
+    // the underlying selection set uses the updated field type as parent type.
+    const updatedBaseType = baseType(updatedField.definition.type!);
+    let updatedSelectionSet : SelectionSet | undefined;
+    if (this.selectionSet && this.selectionSet.parentType !== updatedBaseType) {
+      assert(isCompositeType(updatedBaseType), `Expected ${updatedBaseType.coordinate} to be composite but ${updatedBaseType.kind}`);
+      updatedSelectionSet = new SelectionSet(updatedBaseType);
+      // Note that re-adding every selection ensures that anything frozen will be cloned as needed, on top of handling any knock-down
+      // effect of the type change.
+      for (const selection of this.selectionSet.selections()) {
+        updatedSelectionSet.add(selection);
+      }
+    } else {
+      updatedSelectionSet = this.selectionSet?.cloneIfFrozen();
+    }
+
+    return new FieldSelection(updatedField, updatedSelectionSet);
   }
 
   toSelectionNode(): FieldNode {