Update dev graphql to 16 and add in peerDependency

composition-js/package.json

@@ -31,6 +31,6 @@
     "@apollo/query-graphs": "file:../query-graphs-js"
   },
   "peerDependencies": {
-    "graphql": "^15.7.0"
+    "graphql": "^15.7.0 || ^16.1.0"
   }
 }

composition-js/src/__tests__/validation_errors.test.ts

@@ -28,8 +28,8 @@ describe('composition', () => {
         type A @key(fields: "id") {
           id: ID! @external
           x: Int @external
-          y: Int @requires(fields: "x") 
-          z: Int @requires(fields: "x") 
+          y: Int @requires(fields: "x")
+          z: Int @requires(fields: "x")
         }
       `
     };
@@ -43,8 +43,7 @@ describe('composition', () => {
         a {
           y
         }
-      }
-      cannot be satisfied by the subgraphs because:
+      }cannot be satisfied by the subgraphs because:
       - from subgraph "A": cannot find field "A.y".
       - from subgraph "B": cannot satisfy @require conditions on field "A.y" (please ensure that this is not due to key field "id" being accidentally marked @external).
       `,
@@ -54,8 +53,7 @@ describe('composition', () => {
         a {
           z
         }
-      }
-      cannot be satisfied by the subgraphs because:
+      }cannot be satisfied by the subgraphs because:
       - from subgraph "A": cannot find field "A.z".
       - from subgraph "B": cannot satisfy @require conditions on field "A.z" (please ensure that this is not due to key field "id" being accidentally marked @external).
       `

composition-js/src/merging/merge.ts

@@ -30,7 +30,6 @@ import {
   isFederationType,
   Directive,
   isFederationField,
-  SchemaRootKind,
   CompositeType,
   Subgraphs,
   federationBuiltIns,
@@ -54,7 +53,7 @@ import {
   isInterfaceType,
   sourceASTs,
 } from "@apollo/federation-internals";
-import { ASTNode, GraphQLError, DirectiveLocationEnum } from "graphql";
+import { ASTNode, GraphQLError, DirectiveLocation, OperationTypeNode } from "graphql";
 import {
   CompositionHint,
   HintID,
@@ -209,7 +208,7 @@ function isMergedDirective(definition: DirectiveDefinition | Directive): boolean
 // This mainly avoid us trying to set the supergraph root in the rare case where the supergraph has
 // no actual queries (knowing that subgraphs will _always_ have a queries since they have at least
 // the federation ones).
-function filteredRoot(def: SchemaDefinition, rootKind: SchemaRootKind): ObjectType | undefined {
+function filteredRoot(def: SchemaDefinition, rootKind: OperationTypeNode): ObjectType | undefined {
   const type = def.root(rootKind)?.type;
   return type && hasMergedFields(type) ? type : undefined;
 }
@@ -249,7 +248,7 @@ function hasTagUsage(subgraph: Schema): boolean {
   return !!directive && directive.applications().length > 0;
 }
 
-function locationString(locations: DirectiveLocationEnum[]): string {
+function locationString(locations: DirectiveLocation[]): string {
   if (locations.length === 0) {
     return "";
   }
@@ -339,7 +338,7 @@ class Merger {
       }
     }
 
-    if (!this.merged.schemaDefinition.rootType('query')) {
+    if (!this.merged.schemaDefinition.rootType(OperationTypeNode.QUERY)) {
       this.errors.push(new GraphQLError("No queries found in any subgraph: a supergraph must have a query root type."));
     }
 
@@ -1329,7 +1328,7 @@ class Merger {
 
     let repeatable: boolean | undefined = undefined;
     let inconsistentRepeatable = false;
-    let locations: DirectiveLocationEnum[] | undefined = undefined;
+    let locations: DirectiveLocation[] | undefined = undefined;
     let inconsistentLocations = false;
     for (const source of sources) {
       if (!source) {
@@ -1388,7 +1387,7 @@ class Merger {
   private mergeExecutionDirectiveDefinition(sources: (DirectiveDefinition | undefined)[], dest: DirectiveDefinition) {
     let repeatable: boolean | undefined = undefined;
     let inconsistentRepeatable = false;
-    let locations: DirectiveLocationEnum[] | undefined = undefined;
+    let locations: DirectiveLocation[] | undefined = undefined;
     let inconsistentLocations = false;
     for (const source of sources) {
       if (!source) {
@@ -1483,12 +1482,12 @@ class Merger {
     }
   }
 
-  private extractLocations(source: DirectiveDefinition): DirectiveLocationEnum[] {
+  private extractLocations(source: DirectiveDefinition): DirectiveLocation[] {
     // We sort the locations so that the return list of locations essentially act like a set.
     return this.filterExecutableDirectiveLocations(source).concat().sort();
   }
 
-  private filterExecutableDirectiveLocations(source: DirectiveDefinition): readonly DirectiveLocationEnum[] {
+  private filterExecutableDirectiveLocations(source: DirectiveDefinition): readonly DirectiveLocation[] {
     if (MERGED_TYPE_SYSTEM_DIRECTIVES.includes(source.name)) {
       return source.locations;
     }

composition-js/src/validate.ts

@@ -14,7 +14,6 @@ import {
   Operation,
   operationToDocument,
   Schema,
-  SchemaRootKind,
   Selection,
   selectionOfElement,
   SelectionSet,
@@ -48,7 +47,7 @@ import {
   SimultaneousPathsWithLazyIndirectPaths,
   advanceOptionsToString,
 } from "@apollo/query-graphs";
-import { print } from "graphql";
+import { OperationTypeNode, print } from "graphql";
 
 const debug = newDebugLogger('validation');
 
@@ -247,7 +246,7 @@ export function computeSubgraphPaths(supergraphPath: RootPath<Transition>, subgr
   }
 }
 
-function initialSubgraphPaths(kind: SchemaRootKind, subgraphs: QueryGraph): RootPath<Transition>[] {
+function initialSubgraphPaths(kind: OperationTypeNode, subgraphs: QueryGraph): RootPath<Transition>[] {
   const root = subgraphs.root(kind);
   assert(root, () => `The supergraph shouldn't have a ${kind} root if no subgraphs have one`);
   assert(
@@ -266,7 +265,7 @@ export class ValidationState {
   ) {
   }
 
-  static initial(supergraph: QueryGraph, kind: SchemaRootKind, subgraphs: QueryGraph) {
+  static initial(supergraph: QueryGraph, kind: OperationTypeNode, subgraphs: QueryGraph) {
     return new ValidationState(GraphPath.fromGraphRoot(supergraph, kind)!, initialSubgraphPaths(kind, subgraphs));
   }
 

gateway-js/package.json

@@ -25,6 +25,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@apollo/client": "^3.5.6",
     "@apollo/composition": "file:../composition-js",
     "@apollo/core-schema": "^0.2.0",
     "@apollo/query-planner": "file:../query-planner-js",
@@ -37,12 +38,11 @@
     "apollo-server-env": "^3.0.0 || ^4.0.0",
     "apollo-server-errors": "^2.5.0 || ^3.0.0",
     "apollo-server-types": "^0.9.0 || ^3.0.0",
-    "apollo-utilities": "^1.3.0",
     "loglevel": "^1.6.1",
     "make-fetch-happen": "^8.0.0",
     "pretty-format": "^27.0.0"
   },
   "peerDependencies": {
-    "graphql": "^15.7.0"
+    "graphql": "^15.7.0 || ^16.1.0"
   }
 }

gateway-js/src/__tests__/execution-utils.ts

@@ -11,7 +11,7 @@ import {
 } from '@apollo/gateway';
 import { QueryPlan, QueryPlanner } from '@apollo/query-planner';
 import { LocalGraphQLDataSource } from '../datasources/LocalGraphQLDataSource';
-import { mergeDeep } from 'apollo-utilities';
+import { mergeDeep } from '@apollo/client/utilities';
 
 import { queryPlanSerializer, astSerializer } from 'apollo-federation-integration-testsuite';
 import gql from 'graphql-tag';

gateway-js/src/datasources/LocalGraphQLDataSource.ts

@@ -39,7 +39,7 @@ export class LocalGraphQLDataSource<
       throw new Error(result.errors.map((error) => error.message).join('\n\n'));
     }
 
-    const sdl = result.data && result.data._service && result.data._service.sdl;
+    const sdl = result.data && result.data._service && (result.data._service as any).sdl;
     return parse(sdl);
   }
 }

gateway-js/src/executeQueryPlan.ts

@@ -12,6 +12,7 @@ import {
   GraphQLFormattedError,
   isAbstractType,
   GraphQLSchema,
+  isTypeSubTypeOf
 } from 'graphql';
 import { Trace, google } from 'apollo-reporting-protobuf';
 import { GraphQLDataSource, GraphQLDataSourceRequestKind } from './datasources/types';
@@ -546,7 +547,7 @@ function doesTypeConditionMatch(
   }
 
   if (isAbstractType(conditionalType)) {
-    return schema.isSubType(conditionalType, type);
+    return isTypeSubTypeOf(schema, type, conditionalType)
   }
 
   return false;

gateway-js/src/utilities/__tests__/cleanErrorOfInaccessibleElements.test.ts

@@ -49,16 +49,18 @@ describe('cleanErrorOfInaccessibleNames', () => {
   const schema = coreSchema.toAPISchema().toGraphQLJSSchema();
 
   it('removes inaccessible type names from error messages', async () => {
-    const result = await execute(schema, parse('{fooField{someField}}'), {
-      fooField: {
-        __typename: 'Bar',
-        someField: 'test',
-      },
+    const result = await execute({
+      schema, document: parse('{fooField{someField}}'), rootValue:{
+        fooField: {
+          __typename: 'Bar',
+          someField: 'test',
+        },
+      }
     });
 
     const cleaned = cleanErrorOfInaccessibleNames(schema, result.errors![0]!);
     expect(cleaned.message).toMatchInlineSnapshot(
-      `"Abstract type \\"Foo\\" was resolve to a type [inaccessible type] that does not exist inside schema."`,
+      `"Abstract type \\"Foo\\" was resolved to a type [inaccessible type] that does not exist inside the schema."`,
     );
   });
 

harmonizer/package.json

@@ -25,6 +25,6 @@
     "whatwg-url": "^11.0.0"
   },
   "peerDependencies": {
-    "graphql": "^15.7.0"
+    "graphql": "^15.7.0 || ^16.1.0"
   }
 }

internals-js/package.json

@@ -31,7 +31,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "graphql": "^15.7.0"
+    "graphql": "^15.7.0 || ^16.1.0"
   },
   "devDependencies": {
     "@types/js-levenshtein": "1.1.1"

internals-js/src/__tests__/definitions.test.ts

@@ -10,6 +10,7 @@ import {
   BuiltIns
 } from '../../dist/definitions';
 import {
+  OperationTypeNode,
   printSchema as printGraphQLjsSchema
 } from 'graphql';
 import { defaultPrintOptions, printSchema } from '../../dist/print';
@@ -114,15 +115,15 @@ expect.extend({
 
 test('building a simple schema programatically', () => {
   const schema = new Schema(federationBuiltIns);
-  const queryType = schema.schemaDefinition.setRoot('query', schema.addType(new ObjectType('Query'))).type;
+  const queryType = schema.schemaDefinition.setRoot(OperationTypeNode.QUERY, schema.addType(new ObjectType('Query'))).type;
   const typeA = schema.addType(new ObjectType('A'));
   const key = federationBuiltIns.keyDirective(schema);
 
   queryType.addField('a', typeA);
   typeA.addField('q', queryType);
   typeA.applyDirective(key, { fields: 'a'});
 
-  expect(queryType).toBe(schema.schemaDefinition.root('query')!.type);
+  expect(queryType).toBe(schema.schemaDefinition.root(OperationTypeNode.QUERY)!.type);
   expect(queryType).toHaveField('a', typeA);
   expect(typeA).toHaveField('q', queryType);
   expect(typeA).toHaveDirective(key, { fields: 'a'});
@@ -153,7 +154,7 @@ test('parse schema and modify', () => {
   const inaccessibleDirective = schema.directive('inaccessible')!;
   expectObjectType(queryType);
   expectObjectType(typeA);
-  expect(schema.schemaDefinition.root('query')!.type).toBe(queryType);
+  expect(schema.schemaDefinition.root(OperationTypeNode.QUERY)!.type).toBe(queryType);
   expect(queryType).toHaveField('a', typeA);
   const f2 = typeA.field('f2');
   expect(f2).toHaveDirective(inaccessibleDirective);
@@ -561,7 +562,7 @@ test('default arguments for directives', () => {
   const schema = parseSchema(sdl);
   expect(printSchema(schema)).toMatchString(sdl);
 
-  const query = schema.schemaDefinition.root('query')!.type;
+  const query = schema.schemaDefinition.root(OperationTypeNode.QUERY)!.type;
   const exampleDirective = schema.directive('Example')!;
   expect(query).toHaveField('v1');
   expect(query).toHaveField('v2');

internals-js/src/__tests__/removeInaccessibleElements.test.ts

@@ -1,6 +1,7 @@
 import { ObjectType } from '../definitions';
 import { buildSchema } from '../buildSchema';
 import { removeInaccessibleElements } from '../inaccessibleSpec';
+import { OperationTypeNode } from 'graphql';
 
 describe('removeInaccessibleElements', () => {
   it(`removes @inaccessible fields`, () => {
@@ -29,7 +30,7 @@ describe('removeInaccessibleElements', () => {
 
     removeInaccessibleElements(schema);
 
-    const queryType = schema.schemaDefinition.rootType('query')!;
+    const queryType = schema.schemaDefinition.rootType(OperationTypeNode.QUERY)!;
 
     expect(queryType.field('someField')).toBeDefined();
     expect(queryType.field('privateField')).toBeUndefined();
@@ -214,7 +215,7 @@ describe('removeInaccessibleElements', () => {
 
     removeInaccessibleElements(schema);
 
-    expect(schema.schemaDefinition.rootType('query')).toBeUndefined();
+    expect(schema.schemaDefinition.rootType(OperationTypeNode.QUERY)).toBeUndefined();
     expect(schema.type('Query')).toBeUndefined();
 
     expect(() => schema.validate()).toThrow();
@@ -254,7 +255,7 @@ describe('removeInaccessibleElements', () => {
 
     removeInaccessibleElements(schema);
 
-    expect(schema.schemaDefinition.rootType('mutation')).toBeUndefined();
+    expect(schema.schemaDefinition.rootType(OperationTypeNode.MUTATION)).toBeUndefined();
     expect(schema.type('Mutation')).toBeUndefined();
   });
 
@@ -292,7 +293,7 @@ describe('removeInaccessibleElements', () => {
 
     removeInaccessibleElements(schema);
 
-    expect(schema.schemaDefinition.rootType('subscription')).toBeUndefined();
+    expect(schema.schemaDefinition.rootType(OperationTypeNode.SUBSCRIPTION)).toBeUndefined();
     expect(schema.type('Subscription')).toBeUndefined();
   });
 });

internals-js/src/buildSchema.ts

@@ -1,7 +1,6 @@
 import {
   DefinitionNode,
   DirectiveDefinitionNode,
-  DirectiveLocationEnum,
   DirectiveNode,
   DocumentNode,
   FieldDefinitionNode,
@@ -18,7 +17,9 @@ import {
   StringValueNode,
   ASTNode,
   SchemaExtensionNode,
-  parseType
+  parseType,
+  Kind,
+  DirectiveLocation
 } from "graphql";
 import { Maybe } from "graphql/jsutils/Maybe";
 import {
@@ -332,9 +333,9 @@ export function builtTypeReference(encodedType: string, schema: Schema): Type {
 
 function buildTypeReferenceFromAST(typeNode: TypeNode, schema: Schema): Type {
   switch (typeNode.kind) {
-    case 'ListType':
+    case Kind.LIST_TYPE:
       return new ListType(buildTypeReferenceFromAST(typeNode.type, schema));
-    case 'NonNullType':
+    case Kind.NON_NULL_TYPE:
       const wrapped = buildTypeReferenceFromAST(typeNode.type, schema);
       if (wrapped.kind == 'NonNullType') {
         throw new GraphQLError(`Cannot apply the non-null operator (!) twice to the same type`, typeNode);
@@ -368,7 +369,7 @@ function buildDirectiveDefinitionInner(directiveNode: DirectiveDefinitionNode, d
     buildArgumentDefinitionInner(inputValueDef, directive.addArgument(inputValueDef.name.value));
   }
   directive.repeatable = directiveNode.repeatable;
-  const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocationEnum);
+  const locations = directiveNode.locations.map(({ value }) => value as DirectiveLocation);
   directive.addLocations(...locations);
   directive.description = directiveNode.description?.value;
   directive.sourceAST = directiveNode;