@apollo/federation-internals 2.4.1 → 2.4.3

package/src/operations.ts

@@ -49,7 +49,7 @@ import {
 } from "./definitions";
 import { isInterfaceObjectType } from "./federation";
 import { ERRORS } from "./error";
-import { sameType } from "./types";
+import { isSubtype, sameType } from "./types";
 import { assert, isDefined, mapEntries, mapValues, MapWithCachedArrays, MultiMap, SetMultiMap } from "./utils";
 import { argumentsEquals, argumentsFromAST, isValidValue, valueToAST, valueToString } from "./values";
 import { v1 as uuidv1 } from 'uuid';
@@ -678,12 +678,12 @@ function isUselessFollowupElement(first: OperationElement, followup: OperationEl
     : first.typeCondition;
 
   // The followup is useless if it's a fragment (with no directives we would want to preserve) whose type
-  // is already that of the first element.
+  // is already that of the first element (or a supertype).
   return !!typeOfFirst
     && followup.kind === 'FragmentElement'
     && !!followup.typeCondition
     && (followup.appliedDirectives.length === 0 || isDirectiveApplicationsSubset(conditionals, followup.appliedDirectives))
-    && sameType(typeOfFirst, followup.typeCondition);
+    && isSubtype(followup.typeCondition, typeOfFirst);
 }
 
 export type RootOperationPath = {
@@ -732,8 +732,13 @@ export class Operation {
     // probably not noticeable in practice so ...).
     const toDeoptimize = mapEntries(usages).filter(([_, count]) => count < minUsagesToOptimize).map(([name]) => name);
 
-    const newFragments = optimizedSelection.fragments?.without(toDeoptimize);
-    optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
+    if (toDeoptimize.length > 0) {
+      const newFragments = optimizedSelection.fragments?.without(toDeoptimize);
+      optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
+      // Expanding fragments could create some "inefficiencies" that we wouldn't have if we hadn't re-optimized
+      // the fragments to de-optimize it later, so we do a final "trim" pass to remove those.
+      optimizedSelection = optimizedSelection.trimUnsatisfiableBranches(optimizedSelection.parentType);
+    }
 
     return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, this.name);
   }
@@ -841,6 +846,8 @@ export class Operation {
 export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmentDefinition> {
   private _selectionSet: SelectionSet | undefined;
 
+  private readonly selectionSetsAtTypesCache = new Map<string, SelectionSet>();
+
   constructor(
     schema: Schema,
     readonly name: string,
@@ -852,6 +859,9 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
 
   setSelectionSet(selectionSet: SelectionSet): NamedFragmentDefinition {
     assert(!this._selectionSet, 'Attempting to set the selection set of a fragment definition already built')
+    // We set the selection set post-construction to simplify the handling of fragments that use other fragments,
+    // but let's make sure we've properly used the fragment type condition as parent type of the selection set, as we should.
+    assert(selectionSet.parentType === this.typeCondition, `Fragment selection set parent is ${selectionSet.parentType} differs from the fragment condition type ${this.typeCondition}`);
     this._selectionSet = selectionSet;
     return this;
   }
@@ -894,32 +904,53 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
    * @param type - the type at which we're looking at applying the fragment
    */
   canApplyAtType(type: CompositeType): boolean {
-    const applyAtType = sameType(type, this.typeCondition) || runtimeTypesIntersects(type, this.typeCondition);
-    return applyAtType
-      && this.validForSchema(type.schema());
+    return sameType(type, this.typeCondition) || runtimeTypesIntersects(type, this.typeCondition);
   }
 
-  // Checks whether this named fragment can be applied to the provided schema, which might be different
-  // from the one the named fragment originate from.
-  private validForSchema(schema: Schema): boolean {
-    if (schema === this.schema()) {
-      return true;
+  /**
+   * This methods *assumes* that `this.canApplyAtType(type)` is `true` (and may crash if this is not true), and returns
+   * a version fo this named fragment selection set that corresponds to the "expansion" of this named fragment at `type`
+   *
+   * The overall idea here is that if we have an interface I with 2 implementations T1 and T2, and we have a fragment like:
+   * ```graphql
+   *  fragment X on I {
+   *    ... on T1 {
+   *      <stuff>
+   *    }
+   *    ... on T2 {
+   *      <stuff>
+   *    }
+   *  }
+   * ```
+   * then if the current type is `T1`, then all we care about matching for this fragment is the `... on T1` part, and this method gives
+   * us that part.
+   */
+  selectionSetAtType(type: CompositeType): SelectionSet {
+    // First, if the candidate condition is an object or is the type passed, then there isn't any additional restriction to do.
+    if (sameType(type, this.typeCondition) || isObjectType(this.typeCondition)) {
+      return this.selectionSet;
     }
 
-    const typeInSchema = schema.type(this.typeCondition.name);
-    if (!typeInSchema || !isCompositeType(typeInSchema)) {
-      return false;
+    // We should not call `trimUnsatisfiableBranches` where `type` is an abstract type (`interface` or `union`) as it currently could
+    // create an invalid selection set (and throw down the line). In theory, when `type` is an abstract type, we could look at the
+    // intersection of its runtime types with those of `this.typeCondition`, call `trimUnsatisfiableBranches` for each of the resulting
+    // object types, and merge all those selection sets, and this "may" result in a smaller selection at times. This is a bit complex
+    // and costly to do however, so we just return the selection unchanged for now, which is always valid but simply may not be absolutely
+    // optimal.
+    // Concretely, this means that there may be corner cases where a named fragment could be reused but isn't, but waiting on finding
+    // concrete examples where this matter to decide if it's worth the complexity.
+    if (!isObjectType(type)) {
+      return this.selectionSet;
     }
 
-    // We try "rebasing" the selection into the provided schema and checks if that succeed.
-    try {
-      this.selectionSet.rebaseOn(typeInSchema);
-      // If this succeed, it means the fragment could be applied to that schema and be valid.
-      return true;
-    } catch (e) {
-      // We don't really care what kind of error was triggered; only that it doesn't work.
-      return false;
+    let selectionSet = this.selectionSetsAtTypesCache.get(type.name);
+    if (!selectionSet) {
+      // Note that all we want is removing any top-level branches that don't apply due to the current type. There is no point
+      // in going recursive however: any simplification due to `type` stops as soon as we traverse a field. And so we don't bother. 
+      selectionSet = this.selectionSet.trimUnsatisfiableBranches(type, { recursive: false });
+      this.selectionSetsAtTypesCache.set(type.name, selectionSet);
     }
+    return selectionSet;
   }
 
   toString(indent?: string): string {
@@ -995,6 +1026,72 @@ export class NamedFragments {
     return mapped;
   }
 
+  /**
+   * This method:
+   * - expands all nested fragments,
+   * - applies the provided mapper to the selection set of the fragments,
+   * - and finally re-fragments the nested fragments.
+   */
+  mapToExpandedSelectionSets(
+    mapper: (selectionSet: SelectionSet) => SelectionSet | undefined,
+    recreateFct: (frag: NamedFragmentDefinition, newSelectionSet: SelectionSet) => NamedFragmentDefinition = (f, s) => f.withUpdatedSelectionSet(s),
+  ): NamedFragments | undefined {
+    type FragmentInfo = {
+      original: NamedFragmentDefinition,
+      mappedSelectionSet: SelectionSet,
+      dependsOn: string[],
+    };
+    const fragmentsMap = new Map<string, FragmentInfo>();
+
+    const removedFragments = new Set<string>();
+    for (const fragment of this.definitions()) {
+      const mappedSelectionSet = mapper(fragment.selectionSet.expandAllFragments().trimUnsatisfiableBranches(fragment.typeCondition));
+      if (!mappedSelectionSet) {
+        removedFragments.add(fragment.name);
+        continue;
+      }
+
+      const otherFragmentsUsages = new Map<string, number>();
+      fragment.collectUsedFragmentNames(otherFragmentsUsages);
+      fragmentsMap.set(fragment.name, {
+        original: fragment,
+        mappedSelectionSet,
+        dependsOn: Array.from(otherFragmentsUsages.keys()),
+      });
+    }
+
+    const mappedFragments = new NamedFragments();
+    while (fragmentsMap.size > 0) {
+      for (const [name, info] of fragmentsMap) {
+        // Note that graphQL specifies that named fragments cannot have cycles (https://spec.graphql.org/draft/#sec-Fragment-spreads-must-not-form-cycles)
+        // and so we're guaranteed that on every iteration, at least one element of the map is removed (so the `while` loop will terminate).
+        if (info.dependsOn.every((n) => mappedFragments.has(n) || removedFragments.has(n))) {
+          const reoptimizedSelectionSet = info.mappedSelectionSet.optimize(mappedFragments);
+          mappedFragments.add(recreateFct(info.original, reoptimizedSelectionSet));
+          fragmentsMap.delete(name);
+        }
+      }
+    }
+
+    return mappedFragments.isEmpty() ? undefined : mappedFragments;
+  }
+
+  rebaseOn(schema: Schema): NamedFragments | undefined {
+    return this.mapToExpandedSelectionSets(
+      (s) => {
+        const rebasedType = schema.type(s.parentType.name);
+        try {
+          return rebasedType && isCompositeType(rebasedType) ? s.rebaseOn(rebasedType) : undefined;
+        } catch (e) {
+          // This means we cannot rebase this selection on the schema and thus cannot reuse that fragment on that
+          // particular schema.
+          return undefined;
+        }
+      },
+      (orig, newSelection) => new NamedFragmentDefinition(schema, orig.name, newSelection.parentType).setSelectionSet(newSelection),
+    );
+  }
+
   validate(variableDefinitions: VariableDefinitions) {
     for (const fragment of this.fragments.values()) {
       fragment.selectionSet.validate(variableDefinitions);
@@ -1142,6 +1239,36 @@ export class SelectionSet {
       return this;
     }
 
+    // Calling optimizeSelections() will not match a fragment that would have expanded at top-level.
+    // That is, say we have the selection set `{ x y }` for a top-level `Query`, and we have a fragment
+    // ```
+    // fragment F on Query {
+    //   x
+    //   y
+    // }
+    // ```
+    // then calling `this.optimizeSelections(fragments)` would only apply check if F apply to `x` and
+    // then `y`.
+    //
+    // To ensure the fragment match in this case, we "wrap" the selection into a trivial fragment of
+    // the selection parent, so in the example above, we create selection `... on Query { x y}`.
+    // With that, `optimizeSelections` will correctly match on the `on Query` fragment; after which
+    // we can unpack the final result.
+    const wrapped = new InlineFragmentSelection(new FragmentElement(this.parentType, this.parentType), this);
+    const optimized = wrapped.optimize(fragments);
+
+    // Now, it's possible we matched a full fragment, in which case `optimized` will be just the named fragment,
+    // and in that case we return a singleton selection with just that. Otherwise, it's our wrapping inline fragment
+    // with the sub-selections optimized, and we just return that subselection.
+    return optimized instanceof FragmentSpreadSelection
+      ? selectionSetOf(this.parentType, optimized, fragments)
+      : optimized.selectionSet;
+  }
+
+  // Tries to match fragments inside each selections of this selection set, and this recursively. However, note that this
+  // may not match fragments that would apply at top-level, so you should usually use `optimize` instead (this exists mostly
+  // for the recursion).
+  optimizeSelections(fragments: NamedFragments): SelectionSet {
     // Handling the case where the selection may alreayd have some fragments adds complexity,
     // not only because we need to deal with merging new and existing fragments, but also because
     // things get weird if some fragment names are in common to both. Since we currently only care
@@ -1164,8 +1291,8 @@ export class SelectionSet {
     return this.lazyMap((selection) => selection.expandFragments(names, updatedFragments), { fragments: updatedFragments ?? null });
   }
 
-  trimUnsatisfiableBranches(parentType: CompositeType): SelectionSet {
-    return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType), { parentType });
+  trimUnsatisfiableBranches(parentType: CompositeType, options?: { recursive? : boolean }): SelectionSet {
+    return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType, options), { parentType });
   }
 
   /**
@@ -1325,12 +1452,22 @@ export class SelectionSet {
     return true;
   }
 
-  diffIfContains(that: SelectionSet): { contains: boolean, diff?: SelectionSet } {
+  // Please note that this method assumes that `candidate.canApplyAtType(parentType) === true` but it is left to the caller to
+  // validate this (`canApplyAtType` is not free, and we want to avoid repeating it multiple times).
+  diffWithNamedFragmentIfContained(candidate: NamedFragmentDefinition, parentType: CompositeType): { contains: boolean, diff?: SelectionSet } {
+    const that = candidate.selectionSetAtType(parentType);
     if (this.contains(that)) {
-      const diff = this.minus(that);
+      // One subtlety here is that at "this" sub-selections may already have been optimized with some fragments. It's
+      // usually ok because `candidate` will also use those fragments, but one fragments that `candidate` can never be
+      // using is itself (the `contains` check is fine with this, but it's harder to deal in `minus`). So we expand
+      // the candidate we're currently looking at in "this" to avoid some issues.
+      let updatedThis = this.expandFragments([candidate.name], this.fragments);
+      if (updatedThis !== this) {
+        updatedThis = updatedThis.trimUnsatisfiableBranches(parentType);
+      }
+      const diff = updatedThis.minus(that);
       return { contains: true, diff: diff.isEmpty() ? undefined : diff };
     }
-
     return { contains: false };
   }
 
@@ -1598,9 +1735,19 @@ function addOneToKeyedUpdates(keyedUpdates: MultiMap<string, SelectionUpdate>, s
   }
 }
 
+function maybeRebaseOnSchema(toRebase: CompositeType, schema: Schema): CompositeType {
+  if (toRebase.schema() === schema) {
+    return toRebase;
+  }
+
+  const rebased = schema.type(toRebase.name);
+  assert(rebased && isCompositeType(rebased), () => `Expected ${toRebase} to exists and be composite in the rebased schema, but got ${rebased?.kind}`);
+  return rebased;
+}
+
 function isUnecessaryFragment(parentType: CompositeType, fragment: FragmentSelection): boolean {
   return fragment.element.appliedDirectives.length === 0
-    && (!fragment.element.typeCondition || sameType(parentType, fragment.element.typeCondition));
+    && (!fragment.element.typeCondition || isSubtype(maybeRebaseOnSchema(fragment.element.typeCondition, parentType.schema()), parentType));
 }
 
 function withUnecessaryFragmentsRemoved(
@@ -1881,7 +2028,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   abstract expandFragments(names: string[], updatedFragments: NamedFragments | undefined): TOwnType | readonly Selection[];
 
-  abstract trimUnsatisfiableBranches(parentType: CompositeType): TOwnType | SelectionSet | undefined;
+  abstract trimUnsatisfiableBranches(parentType: CompositeType, options?: { recursive? : boolean }): TOwnType | SelectionSet | undefined;
 
   minus(that: Selection): TOwnType | undefined {
     // If there is a subset, then we compute the diff of the subset and add that (if not empty).
@@ -1895,6 +2042,10 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     return undefined;
   }
 
+  // Attempts to optimize the subselection of this field selection using named fragments `candidates` _assuming_ that
+  // those candidates do apply at `parentType` (that is, `candidates.every((c) => c.canApplyAtType(parentType))` is true,
+  // which is ensured by the fact that `tryOptimizeSubselectionWithFragments` calls this on a subset of the candidates
+  // returned by `maybeApplyingAtType`).
   protected tryOptimizeSubselectionOnce(_: {
     parentType: CompositeType,
     subSelection: SelectionSet,
@@ -1968,7 +2119,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
   }
 
   optimize(fragments: NamedFragments): Selection {
-    let optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
+    let optimizedSelection = this.selectionSet ? this.selectionSet.optimizeSelections(fragments) : undefined;
     const fieldBaseType = baseType(this.element.definition.type!);
     if (isCompositeType(fieldBaseType) && optimizedSelection) {
       const optimized = this.tryOptimizeSubselectionWithFragments({
@@ -2007,7 +2158,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
   }{
     let optimizedSelection = subSelection;
     for (const candidate of candidates) {
-      const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+      const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
       if (contains) {
         // We can optimize the selection with this fragment. The replaced sub-selection will be
         // comprised of this new spread and the remaining `diff` if there is any.
@@ -2123,14 +2274,14 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this.mapToSelectionSet((s) => s.expandAllFragments());
   }
 
-  trimUnsatisfiableBranches(_: CompositeType): FieldSelection {
+  trimUnsatisfiableBranches(_: CompositeType, options?: { recursive? : boolean }): FieldSelection {
     if (!this.selectionSet) {
       return this;
     }
 
     const base = baseType(this.element.definition.type!)
     assert(isCompositeType(base), () => `Field ${this.element} should not have a sub-selection`);
-    const trimmed = this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base));
+    const trimmed = (options?.recursive ?? true) ? this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base)) : this;
     // In rare caes, it's possible that everything in the sub-selection was trimmed away and so the
     // sub-selection is empty. Which suggest something may be wrong with this part of the query
     // intent, but the query was valid while keeping an empty sub-selection isn't. So in that
@@ -2317,7 +2468,7 @@ class InlineFragmentSelection extends FragmentSelection {
   }
 
   optimize(fragments: NamedFragments): FragmentSelection {
-    let optimizedSelection = this.selectionSet.optimize(fragments);
+    let optimizedSelection = this.selectionSet.optimizeSelections(fragments);
     const typeCondition = this.element.typeCondition;
     if (typeCondition) {
       const optimized = this.tryOptimizeSubselectionWithFragments({
@@ -2353,7 +2504,7 @@ class InlineFragmentSelection extends FragmentSelection {
   }{
     let optimizedSelection = subSelection;
     for (const candidate of candidates) {
-      const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+      const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
       if (contains) {
         // The candidate selection is included in our sub-selection. One remaining thing to take into account
         // is applied directives: if the candidate has directives, then we can only use it if 1) there is
@@ -2424,12 +2575,14 @@ class InlineFragmentSelection extends FragmentSelection {
       : this.withUpdatedComponents(newElement, newSelection);
   }
 
-  trimUnsatisfiableBranches(currentType: CompositeType): FragmentSelection | SelectionSet | undefined {
+  trimUnsatisfiableBranches(currentType: CompositeType, options?: { recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
+    const recursive = options?.recursive ?? true;
+
     const thisCondition = this.element.typeCondition;
     // Note that if the condition has directives, we preserve the fragment no matter what.
     if (this.element.appliedDirectives.length === 0) {
       if (!thisCondition || currentType === this.element.typeCondition) {
-        const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+        const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
         return trimmed.isEmpty() ? undefined : trimmed;
       }
 
@@ -2444,12 +2597,17 @@ class InlineFragmentSelection extends FragmentSelection {
         if (isObjectType(thisCondition) || !possibleRuntimeTypes(thisCondition).includes(currentType)) {
           return undefined;
         } else {
-          const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+          const trimmed =this.selectionSet.trimUnsatisfiableBranches(currentType, options);
           return trimmed.isEmpty() ? undefined : trimmed;
         }
       }
     }
 
+    // As we preserve the current fragment, the rest is about recursing. If we don't recurse, we're done
+    if (!recursive) {
+      return this;
+    }
+
     // In all other cases, we first recurse on the sub-selection.
     const trimmedSelectionSet = this.selectionSet.trimUnsatisfiableBranches(this.element.typeCondition ?? this.parentType);
 

package/src/print.ts

@@ -3,6 +3,7 @@ import {
   Directive,
   DirectiveDefinition,
   EnumType,
+  EnumValue,
   ExtendableElement,
   Extension,
   FieldDefinition,
@@ -18,6 +19,7 @@ import {
   SchemaDefinition,
   SchemaElement,
   SchemaRootKind,
+  UnionMember,
   UnionType
 } from "./definitions";
 import { assert } from "./utils";
@@ -28,6 +30,11 @@ export type PrintOptions = {
   definitionsOrder: ('schema' | 'types' | 'directives')[],
   rootTypesOrder: SchemaRootKind[],
   typeCompareFn?: (t1: NamedType, t2: NamedType) => number;
+  implementedInterfaceCompareFn?: (t1: InterfaceImplementation<any>, t2: InterfaceImplementation<any>) => number;
+  fieldCompareFn?: (t1: FieldDefinition<any>, t2: FieldDefinition<any>) => number;
+  unionMemberCompareFn?: (t1: UnionMember, t2: UnionMember) => number;
+  enumValueCompareFn?: (t1: EnumValue, t2: EnumValue) => number;
+  inputObjectFieldCompareFn?: (t1: InputFieldDefinition, t2: InputFieldDefinition) => number;
   directiveCompareFn?: (d1: DirectiveDefinition, d2: DirectiveDefinition) => number;
   mergeTypesAndExtensions: boolean;
   showAllBuiltIns: boolean;
@@ -51,6 +58,19 @@ export const defaultPrintOptions: PrintOptions = {
 }
 
 export function orderPrintedDefinitions(options: PrintOptions): PrintOptions {
+  return {
+    ...options,
+    typeCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
+    implementedInterfaceCompareFn: (t1, t2) => t1.interface.name.localeCompare(t2.interface.name),
+    fieldCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
+    unionMemberCompareFn: (t1, t2) => t1.type.name.localeCompare(t2.type.name),
+    enumValueCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
+    inputObjectFieldCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
+    directiveCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
+  };
+}
+
+export function shallowOrderPrintedDefinitions(options: PrintOptions): PrintOptions {
   return {
     ...options,
     typeCompareFn: (t1, t2) => t1.name.localeCompare(t2.name),
@@ -255,7 +275,7 @@ function printImplementedInterfaces(implementations: readonly InterfaceImplement
 
 function printFieldBasedTypeDefinitionOrExtension(kind: string, type: ObjectType | InterfaceType, options: PrintOptions, extension?: Extension<any> | null): string | undefined {
   const directives = appliedDirectives(type, options, extension);
-  const interfaces = forExtension<InterfaceImplementation<any>>(type.interfaceImplementations(), extension);
+  let interfaces = forExtension<InterfaceImplementation<any>>(type.interfaceImplementations(), extension);
   let fields = forExtension<FieldDefinition<any>>(type.fields(), extension);
   if (options.fieldFilter) {
     fields = fields.filter(options.fieldFilter);
@@ -263,6 +283,12 @@ function printFieldBasedTypeDefinitionOrExtension(kind: string, type: ObjectType
   if (!directives.length && !interfaces.length && !fields.length && (extension || !type.preserveEmptyDefinition)) {
     return undefined;
   }
+  if (options.implementedInterfaceCompareFn) {
+    interfaces = interfaces.concat().sort(options.implementedInterfaceCompareFn);
+  }
+  if (options.fieldCompareFn) {
+    fields = fields.concat().sort(options.fieldCompareFn);
+  }
   return printDescription(type, options, extension)
     + printIsExtension(extension)
     + kind + ' ' + type
@@ -274,10 +300,13 @@ function printFieldBasedTypeDefinitionOrExtension(kind: string, type: ObjectType
 
 function printUnionDefinitionOrExtension(type: UnionType, options: PrintOptions, extension?: Extension<any> | null): string | undefined {
   const directives = appliedDirectives(type, options, extension);
-  const members = forExtension(type.members(), extension);
+  let members = forExtension(type.members(), extension);
   if (!directives.length && !members.length && (extension || !type.preserveEmptyDefinition)) {
     return undefined;
   }
+  if (options.unionMemberCompareFn) {
+    members = members.concat().sort(options.unionMemberCompareFn);
+  }
   const possibleTypes = members.length ? ' = ' + members.map(m => m.type).join(' | ') : '';
   return printDescription(type, options, extension)
     + printIsExtension(extension)
@@ -288,10 +317,13 @@ function printUnionDefinitionOrExtension(type: UnionType, options: PrintOptions,
 
 function printEnumDefinitionOrExtension(type: EnumType, options: PrintOptions, extension?: Extension<any> | null): string | undefined {
   const directives = appliedDirectives(type, options, extension);
-  const values = forExtension(type.values, extension);
+  let values = forExtension(type.values, extension);
   if (!directives.length && !values.length && (extension || !type.preserveEmptyDefinition)) {
     return undefined;
   }
+  if (options.enumValueCompareFn) {
+    values = values.concat().sort(options.enumValueCompareFn);
+  }
   const vals = values.map((v, i) =>
     printDescription(v, options, extension, options.indentString, !i)
     + options.indentString
@@ -307,10 +339,13 @@ function printEnumDefinitionOrExtension(type: EnumType, options: PrintOptions, e
 
 function printInputDefinitionOrExtension(type: InputObjectType, options: PrintOptions, extension?: Extension<any> | null): string | undefined {
   const directives = appliedDirectives(type, options, extension);
-  const fields = forExtension(type.fields(), extension);
+  let fields = forExtension(type.fields(), extension);
   if (!directives.length && !fields.length && (extension || !type.preserveEmptyDefinition)) {
     return undefined;
   }
+  if (options.inputObjectFieldCompareFn) {
+    fields = fields.concat().sort(options.inputObjectFieldCompareFn);
+  }
   return printDescription(type, options, extension)
     + printIsExtension(extension)
     + 'input ' + type

package/src/tagSpec.ts

@@ -41,11 +41,11 @@ export class TagSpecDefinition extends FeatureDefinition {
       name:'tag',
       locations: this.tagLocations,
       repeatable: true,
-      argumentFct: (schema) => ({
-        args: [{ name: 'name', type: new NonNullType(schema.stringType()) }],
-        errors: [],
-      }),
+      args: [{ name: 'name', type: (schema) => new NonNullType(schema.stringType()) }],
+      composes: true,
+      supergraphSpecification: () => TAG_VERSIONS.latest(),
     });
+    this.registerDirective(this.tagDirectiveSpec);
   }
 
   private isV01() {
@@ -56,10 +56,6 @@ export class TagSpecDefinition extends FeatureDefinition {
     return this.version.equals(new FeatureVersion(0, 2))
   }
 
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    return this.addDirectiveSpec(schema, this.tagDirectiveSpec);
-  }
-
   tagDirective(schema: Schema): DirectiveDefinition<{name: string}> {
     return this.directive(schema, 'tag')!;
   }
@@ -76,10 +72,6 @@ export class TagSpecDefinition extends FeatureDefinition {
     }
     return undefined;
   }
-
-  allElementNames(): string[] {
-    return ["@tag"];
-  }
 }
 
 export const TAG_VERSIONS = new FeatureDefinitions<TagSpecDefinition>(tagIdentity)