@apollo/federation-internals 2.4.1 → 2.4.2

package/src/directiveAndTypeSpecification.ts

@@ -21,10 +21,23 @@ import { ERRORS } from "./error";
 import { valueEquals, valueToString } from "./values";
 import { sameType } from "./types";
 import { arrayEquals, assert } from "./utils";
+import { ArgumentCompositionStrategy } from "./argumentCompositionStrategies";
+import { FeatureDefinition } from "./coreSpec";
 
 export type DirectiveSpecification = {
   name: string,
   checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+  composition?: DirectiveCompositionSpecification,
+}
+
+export type DirectiveCompositionSpecification = {
+  supergraphSpecification: () => FeatureDefinition,
+  argumentsMerger?: (schema: Schema) => ArgumentMerger | GraphQLError,
+}
+
+export type ArgumentMerger = {
+  merge: (argName: string, values: any[]) => any,
+  toString: () => string,
 }
 
 export type TypeSpecification = {
@@ -34,43 +47,117 @@ export type TypeSpecification = {
 
 export type ArgumentSpecification = {
   name: string,
-  type: InputType,
+  type: (schema: Schema, nameInSchema?: string) => InputType | GraphQLError[],
   defaultValue?: any,
 }
 
+export type DirectiveArgumentSpecification = ArgumentSpecification & {
+  compositionStrategy?: ArgumentCompositionStrategy,
+}
+
 export type FieldSpecification = {
   name: string,
   type: OutputType,
-  args?: ArgumentSpecification[],
-};
+  args?: ResolvedArgumentSpecification[],
+}
+
+type ResolvedArgumentSpecification = {
+  name: string,
+  type: InputType,
+  defaultValue?: any,
+}
 
 export function createDirectiveSpecification({
   name,
   locations,
   repeatable = false,
-  argumentFct = undefined,
+  args = [],
+  composes = false,
+  supergraphSpecification = undefined,
 }: {
   name: string,
   locations: DirectiveLocation[],
   repeatable?: boolean,
-  argumentFct?: (schema: Schema, nameInSchema?: string) => { args: ArgumentSpecification[], errors: GraphQLError[] },
+  args?: DirectiveArgumentSpecification[],
+  composes?: boolean,
+  supergraphSpecification?: () => FeatureDefinition,
 }): DirectiveSpecification {
+  let composition: DirectiveCompositionSpecification | undefined = undefined;
+  if (composes) {
+    assert(supergraphSpecification, `Should provide a @link specification to use in supergraph for directive @${name} if it composes`);
+    const argStrategies = new Map(args.filter((arg) => arg.compositionStrategy).map((arg) => [arg.name, arg.compositionStrategy!]));
+    let argumentsMerger: ((schema: Schema) => ArgumentMerger | GraphQLError) | undefined = undefined;
+    if (argStrategies.size > 0) {
+      assert(!repeatable, () => `Invalid directive specification for @${name}: @${name} is repeatable and should not define composition strategy for its arguments`);
+      assert(argStrategies.size === args.length, () => `Invalid directive specification for @${name}: not all arguments define a composition strategy`);
+      argumentsMerger = (schema) => {
+        // Validate that the arguments have compatible types with the declared strategies (a bit unfortunate that we can't do this until
+        // we have a schema but well, not a huge deal either).
+        for (const { name: argName, type } of args) {
+          const strategy = argStrategies.get(argName);
+          // Note that we've built `argStrategies` from the declared args and checked that all argument had a strategy, so it would be
+          // a bug in the code if we didn't get a strategy (not an issue in the directive declaration).
+          assert(strategy, () => `Should have a strategy for ${argName}`);
+          const argType = type(schema);
+          // By the time we call this, the directive should have been added to the schema and so getting the type should not raise errors.
+          assert(!Array.isArray(argType), () => `Should have gotten error getting type for @${name}(${argName}:), but got ${argType}`)
+          const strategyTypes = strategy.supportedTypes(schema);
+          if (!strategyTypes.some((t) => sameType(t, argType))) {
+            return new GraphQLError(
+              `Invalid composition strategy ${strategy.name} for argument @${name}(${argName}:) of type ${argType}; `
+              + `${strategy.name} only supports type(s) ${strategyTypes.join(', ')}`
+            );
+          }
+        };
+        return {
+          merge: (argName, values) => {
+            const strategy = argStrategies.get(argName);
+            assert(strategy, () => `Should have a strategy for ${argName}`);
+            return strategy.mergeValues(values);
+          },
+          toString: () => {
+            if (argStrategies.size === 0) {
+              return "<none>";
+            }
+            return '{ ' + [...argStrategies.entries()].map(([arg, strategy]) => `"${arg}": ${strategy.name}`).join(', ') + ' }';
+          }
+        };
+      }
+    }
+    composition = {
+      supergraphSpecification,
+      argumentsMerger,
+    };
+  }
+
   return {
     name,
+    composition,
     checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
       const actualName = nameInSchema ?? name;
-      const {args, errors} = argumentFct ? argumentFct(schema, actualName) : { args: [], errors: []};
+      const { resolvedArgs, errors } = args.reduce<{ resolvedArgs: (ResolvedArgumentSpecification & { compositionStrategy?: ArgumentCompositionStrategy })[], errors: GraphQLError[] }>(
+        ({ resolvedArgs, errors }, arg) => {
+          const typeOrErrors = arg.type(schema, actualName);
+          if (Array.isArray(typeOrErrors)) {
+            errors.push(...typeOrErrors);
+          } else {
+            resolvedArgs.push({ ...arg, type: typeOrErrors });
+          }
+          return { resolvedArgs, errors };
+        },
+        { resolvedArgs: [], errors: [] }
+      );
       if (errors.length > 0) {
         return errors;
       }
       const existing = schema.directive(actualName);
       if (existing) {
-        return ensureSameDirectiveStructure({name: actualName, locations, repeatable, args}, existing);
+        return ensureSameDirectiveStructure({ name: actualName, locations, repeatable, args: resolvedArgs }, existing);
       } else {
         const directive = schema.addDirectiveDefinition(new DirectiveDefinition(actualName, asBuiltIn));
         directive.repeatable = repeatable;
         directive.addLocations(...locations);
-        for (const { name, type, defaultValue } of args) {
+        for (const { name, type, defaultValue } of resolvedArgs) {
           directive.addArgument(name, type, defaultValue);
         }
         return [];
@@ -95,7 +182,7 @@ export function createScalarTypeSpecification({ name }: { name: string }): TypeS
   }
 }
 
-export function createObjectTypeSpecification({ 
+export function createObjectTypeSpecification({
   name,
   fieldsFct,
 }: {
@@ -156,7 +243,7 @@ export function createObjectTypeSpecification({
   }
 }
 
-export function createUnionTypeSpecification({ 
+export function createUnionTypeSpecification({
   name,
   membersFct,
 }: {
@@ -210,7 +297,7 @@ export function createEnumTypeSpecification({
   values,
 }: {
   name: string,
-  values: { name: string, description?: string}[],
+  values: { name: string, description?: string }[],
 }): TypeSpecification {
   return {
     name,
@@ -234,7 +321,7 @@ export function createEnumTypeSpecification({
         return errors;
       } else {
         const type = schema.addType(new EnumType(actualName, asBuiltIn));
-        for (const {name, description} of values) {
+        for (const { name, description } of values) {
           type.addValue(name).description = description;
         }
         return [];
@@ -259,7 +346,7 @@ function ensureSameDirectiveStructure(
     name: string,
     locations: DirectiveLocation[],
     repeatable: boolean,
-    args: ArgumentSpecification[]
+    args: ResolvedArgumentSpecification[]
   },
   actual: DirectiveDefinition<any>,
 ): GraphQLError[] {
@@ -285,7 +372,7 @@ function ensureSameDirectiveStructure(
 function ensureSameArguments(
   expected: {
     name: string,
-    args?: ArgumentSpecification[]
+    args?: ResolvedArgumentSpecification[]
   },
   actual: { argument(name: string): ArgumentDefinition<any> | undefined, arguments(): readonly ArgumentDefinition<any>[] },
   what: string,

package/src/federation.ts

@@ -80,6 +80,8 @@ import {
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
 import { didYouMean, suggestionList } from "./suggestions";
+import { coreFeatureDefinitionIfKnown } from "./knownCoreFeatures";
+import { joinIdentity } from "./joinSpec";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
@@ -110,7 +112,6 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
 const FEDERATION_VALIDATION_RULES = specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
 
 const ALL_DEFAULT_FEDERATION_DIRECTIVE_NAMES: string[] = Object.values(FederationDirectiveName);
-
 function validateFieldSetSelections({
   directiveName,
   selectionSet,
@@ -1342,12 +1343,14 @@ function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
     }
   }
 
-  return FEDERATION1_TYPES.map((spec) => spec.checkOrAdd(schema, '_' + spec.name))
+  const errors = FEDERATION1_TYPES.map((spec) => spec.checkOrAdd(schema, '_' + spec.name))
     .concat(FEDERATION1_DIRECTIVES.map((spec) => spec.checkOrAdd(schema)))
     .flat();
+
+  return errors.length === 0 ? expandKnownFeatures(schema) : errors;
 }
 
-function completeFed2SubgraphSchema(schema: Schema) {
+function completeFed2SubgraphSchema(schema: Schema): GraphQLError[] {
   const coreFeatures = schema.coreFeatures;
   assert(coreFeatures, 'This method should not have been called on a non-core schema');
 
@@ -1362,7 +1365,33 @@ function completeFed2SubgraphSchema(schema: Schema) {
     )];
   }
 
-  return spec.addElementsToSchema(schema);
+  const errors = spec.addElementsToSchema(schema);
+  return errors.length === 0 ? expandKnownFeatures(schema) : errors;
+}
+
+function expandKnownFeatures(schema: Schema): GraphQLError[] {
+  const coreFeatures = schema.coreFeatures;
+  if (!coreFeatures) {
+    return [];
+  }
+
+  let errors: GraphQLError[] = [];
+  for (const feature of coreFeatures.allFeatures()) {
+    // We should already have dealt with the core/link spec and federation at this point. Also, we shouldn't have the `join` spec in subgraphs,
+    // but some tests play with the idea and currently the join spec is implemented in a way that is not idempotent (it doesn't use
+    // `DirectiveSpecification.checkAndAdd`; we should clean it up at some point, but not exactly urgent).
+    if (feature === coreFeatures.coreItself || feature.url.identity === federationIdentity  || feature.url.identity === joinIdentity) {
+      continue;
+    }
+
+    const spec = coreFeatureDefinitionIfKnown(feature.url);
+    if (!spec) {
+      continue;
+    }
+
+    errors = errors.concat(spec.addElementsToSchema(schema));
+  }
+  return errors;
 }
 
 export function parseFieldSetArgument({

package/src/federationSpec.ts

@@ -8,11 +8,9 @@ import {
   ArgumentSpecification,
   createDirectiveSpecification,
   createScalarTypeSpecification,
-  DirectiveSpecification,
-  TypeSpecification,
 } from "./directiveAndTypeSpecification";
-import { DirectiveLocation, GraphQLError } from "graphql";
-import { assert, MapWithCachedArrays } from "./utils";
+import { DirectiveLocation } from "graphql";
+import { assert } from "./utils";
 import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
 import { registerKnownFeature } from "./knownCoreFeatures";
@@ -40,17 +38,16 @@ export enum FederationDirectiveName {
 
 const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
 
+const fieldsArgument: ArgumentSpecification = { name: 'fields', type: (schema) => fieldSetType(schema) };
+
 const keyDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.KEY,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
   repeatable: true,
-  argumentFct: (schema) => ({
-    args: [
-      fieldsArgument(schema),
-      { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
-    ],
-    errors: [],
-  }),
+  args: [
+    fieldsArgument,
+    { name: 'resolvable', type: (schema) => schema.booleanType(), defaultValue: true },
+  ]
 });
 
 const extendsDirectiveSpec = createDirectiveSpecification({
@@ -61,28 +58,19 @@ const extendsDirectiveSpec = createDirectiveSpecification({
 const externalDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.EXTERNAL,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [{ name: 'reason', type: schema.stringType() }],
-    errors: [],
-  }),
+  args: [{ name: 'reason', type: (schema) => schema.stringType() }],
 });
 
 const requiresDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.REQUIRES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [fieldsArgument(schema)],
-    errors: [],
-  }),
+  args: [fieldsArgument],
 });
 
 const providesDirectiveSpec = createDirectiveSpecification({
   name: FederationDirectiveName.PROVIDES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [fieldsArgument(schema)],
-    errors: [],
-  }),
+  args: [fieldsArgument],
 });
 
 const legacyFederationTypes = [
@@ -103,9 +91,6 @@ const legacyFederationDirectives = [
 export const FEDERATION1_TYPES = legacyFederationTypes;
 export const FEDERATION1_DIRECTIVES = legacyFederationDirectives;
 
-function fieldsArgument(schema: Schema): ArgumentSpecification {
-  return { name: 'fields', type: fieldSetType(schema) };
-}
 
 function fieldSetType(schema: Schema): InputType {
   const metadata = federationMetadata(schema);
@@ -114,9 +99,6 @@ function fieldSetType(schema: Schema): InputType {
 }
 
 export class FederationSpecDefinition extends FeatureDefinition {
-  private readonly _directiveSpecs = new MapWithCachedArrays<string, DirectiveSpecification>();
-  private readonly _typeSpecs = new MapWithCachedArrays<string, TypeSpecification>();
-
   constructor(version: FeatureVersion) {
     super(new FeatureUrl(federationIdentity, 'federation', version));
 
@@ -139,10 +121,7 @@ export class FederationSpecDefinition extends FeatureDefinition {
     this.registerDirective(createDirectiveSpecification({
       name: FederationDirectiveName.OVERRIDE,
       locations: [DirectiveLocation.FIELD_DEFINITION],
-      argumentFct: (schema) => ({
-        args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
-        errors: [],
-      }),
+      args: [{ name: 'from', type: (schema) => new NonNullType(schema.stringType()) }],
     }));
 
     if (version >= (new FeatureVersion(2, 1))) {
@@ -150,10 +129,7 @@ export class FederationSpecDefinition extends FeatureDefinition {
         name: FederationDirectiveName.COMPOSE_DIRECTIVE,
         locations: [DirectiveLocation.SCHEMA],
         repeatable: true,
-        argumentFct: (schema) => ({
-          args: [{ name: 'name', type: schema.stringType() }],
-          errors: [],
-        }),
+        args: [{ name: 'name', type: (schema) => schema.stringType() }],
       }));
     }
 
@@ -167,42 +143,6 @@ export class FederationSpecDefinition extends FeatureDefinition {
       );
     }
   }
-
-  private registerDirective(spec: DirectiveSpecification) {
-    this._directiveSpecs.set(spec.name, spec);
-  }
-
-  private registerType(spec: TypeSpecification) {
-    this._typeSpecs.set(spec.name, spec);
-  }
-
-  directiveSpecs(): readonly DirectiveSpecification[] {
-    return this._directiveSpecs.values();
-  }
-
-  typeSpecs(): readonly TypeSpecification[] {
-    return this._typeSpecs.values();
-  }
-
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    const feature = this.featureInSchema(schema);
-    assert(feature, 'The federation specification should have been added to the schema before this is called');
-
-    let errors: GraphQLError[] = [];
-    for (const type of this.typeSpecs()) {
-      errors = errors.concat(this.addTypeSpec(schema, type));
-    }
-
-    for (const directive of this.directiveSpecs()) {
-      errors = errors.concat(this.addDirectiveSpec(schema, directive));
-    }
-    return errors;
-  }
-
-  allElementNames(): string[] {
-    return this.directiveSpecs().map((spec) => `@${spec.name}`)
-      .concat(this.typeSpecs().map((spec) => spec.name));
-  }
 }
 
 export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefinition>(federationIdentity)

package/src/inaccessibleSpec.ts

@@ -62,17 +62,16 @@ export class InaccessibleSpecDefinition extends FeatureDefinition {
     this.inaccessibleDirectiveSpec = createDirectiveSpecification({
       name: 'inaccessible',
       locations: this.inaccessibleLocations,
+      composes: true,
+      supergraphSpecification: () => INACCESSIBLE_VERSIONS.latest(),
     });
+    this.registerDirective(this.inaccessibleDirectiveSpec);
   }
 
   isV01() {
     return this.version.equals(new FeatureVersion(0, 1));
   }
 
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    return this.addDirectiveSpec(schema, this.inaccessibleDirectiveSpec);
-  }
-
   inaccessibleDirective(schema: Schema): DirectiveDefinition<Record<string, never>> | undefined {
     return this.directive(schema, 'inaccessible');
   }
@@ -89,10 +88,6 @@ export class InaccessibleSpecDefinition extends FeatureDefinition {
     return undefined;
   }
 
-  allElementNames(): string[] {
-    return ['@inaccessible'];
-  }
-
   get defaultCorePurpose(): CorePurpose | undefined {
     return 'SECURITY';
   }
@@ -891,9 +886,7 @@ function getInputType(element: SchemaElementWithDefaultValue): InputType {
 // similar to the "Values of Correct Type" validation in the GraphQL spec.
 // However, there are two noteable differences:
 // 1. Variable references are not allowed.
-// 2. Scalar values are not required to be coercible (due to machine-specific
-//    differences in input coercion rules).
-//
+// 2. Scalar values are not required to be coercible (due to machine-specific differences in input coercion rules).
 // As it turns out, building a Schema object validates this (and a bit more)
 // already, so in the interests of not duplicating validations/keeping the logic
 // centralized, this code assumes the input values it receives satisfy the above

package/src/index.ts

@@ -18,3 +18,6 @@ export * from './error';
 export * from './schemaUpgrader';
 export * from './suggestions';
 export * from './graphQLJSSchemaToAST';
+export * from './directiveAndTypeSpecification';
+export { coreFeatureDefinitionIfKnown } from './knownCoreFeatures';
+export * from './argumentCompositionStrategies';

package/src/knownCoreFeatures.ts

@@ -11,3 +11,12 @@ export function registerKnownFeature(definitions: FeatureDefinitions) {
 export function coreFeatureDefinitionIfKnown(url: FeatureUrl): FeatureDefinition | undefined {
   return registeredFeatures.get(url.identity)?.find(url.version);
 }
+
+/**
+ * Removes a feature from the set of known features.
+ *
+ * This exists purely for testing purposes. There is no reason to unregistered features otherwise.
+ */
+export function unregisterKnownFeatures(definitions: FeatureDefinitions) {
+  registeredFeatures.delete(definitions.identity);
+}

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 = {
@@ -1598,9 +1598,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(

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