.github/release-drafter.yml

@@ -4,17 +4,19 @@ categories:
   - title: '🚀 Features'
     labels:
       - 'feature'
+  - title: '🧰 Enhancements'
+    labels:
       - 'enhancement'
+      - 'chore'
   - title: '🐛 Bug Fixes'
     labels:
       - 'fix'
       - 'bugfix'
       - 'bug'
-  - title: '🧰 Maintenance'
-    label: 'chore'
 change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
 exclude-labels:
   - dependencies
+  - docs
 version-resolver:
   major:
     labels:

.github/workflows/website.yml

@@ -9,6 +9,7 @@ jobs:
     name: Deploy Website
     timeout-minutes: 10
     runs-on: ubuntu-latest
+    if: contains(github.event.head_commit.message, '[deploy_website]') || contains(github.ref, 'refs/tags/')
     steps:
       - name: Checkout Master
         uses: actions/checkout@v1
@@ -40,6 +41,8 @@ jobs:
             ${{ runner.os }}-14-15-yarn-
       - name: Install Dependencies using Yarn
         run: yarn install && git checkout yarn.lock
+      - name: Build API Docs
+        run: yarn build:api-docs
       - name: Deploy 🚀
         run: yarn deploy:website
         env:

package.json

@@ -1,12 +1,13 @@
 {
   "name": "graphql-tools-monorepo",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "Useful tools to create and manipulate GraphQL schemas.",
   "private": true,
   "scripts": {
     "deploy:website": "cd website && yarn deploy",
     "ts:transpile": "tsc --project tsconfig.build.json",
     "build": "yarn ts:transpile && bob build",
+    "build:api-docs": "node scripts/build-api-docs.js",
     "lint": "eslint --ext .ts .",
     "prettier": "prettier --ignore-path .gitignore --write --list-different \"**/*.{ts,tsx,graphql,yml}\"",
     "prettier:check": "prettier --ignore-path .gitignore --check \"**/*.{ts,tsx,graphql,yml}\"",
@@ -38,27 +39,29 @@
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.1",
-    "@types/jest": "26.0.3",
-    "@types/node": "14.0.14",
-    "jest": "26.1.0",
-    "ts-jest": "26.1.1",
-    "typescript": "3.9.6",
-    "@typescript-eslint/eslint-plugin": "3.5.0",
-    "@typescript-eslint/parser": "3.5.0",
+    "@types/jest": "26.0.4",
+    "@types/node": "14.0.23",
+    "@typescript-eslint/eslint-plugin": "3.6.1",
+    "@typescript-eslint/parser": "3.6.1",
     "bob-the-bundler": "1.0.2",
-    "eslint": "7.3.1",
+    "eslint": "7.4.0",
     "eslint-config-prettier": "6.11.0",
     "eslint-config-standard": "14.1.1",
     "eslint-plugin-import": "2.22.0",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-promise": "4.2.1",
     "eslint-plugin-standard": "4.0.1",
     "fs-extra": "9.0.1",
-    "graphql": "15.2.0",
+    "graphql": "15.3.0",
+    "husky": "4.2.5",
+    "jest": "26.1.0",
     "lint-staged": "10.2.11",
     "nock": "13.0.2",
-    "husky": "4.2.5",
-    "prettier": "2.0.5"
+    "prettier": "2.0.5",
+    "ts-jest": "26.1.1",
+    "typedoc": "0.17.0-3",
+    "typedoc-plugin-markdown": "2.3.1",
+    "typescript": "3.9.6"
   },
   "husky": {
     "hooks": {
@@ -79,6 +82,6 @@
     "./website"
   ],
   "resolutions": {
-    "graphql": "15.2.0"
+    "graphql": "15.3.0"
   }
-}
+}

packages/batch-delegate/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@graphql-tools/batch-delegate",
+  "version": "6.0.12",
+  "description": "A set of utils for faster development of GraphQL tools",
+  "repository": "git@github.com:ardatan/graphql-tools.git",
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts",
+  "typescript": {
+    "definition": "dist/index.d.ts"
+  },
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0"
+  },
+  "buildOptions": {
+    "input": "./src/index.ts"
+  },
+  "dependencies": {
+    "@graphql-tools/delegate": "6.0.12",
+    "dataloader": "2.0.0",
+    "tslib": "~2.0.0"
+  },
+  "devDependencies": {
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/stitch": "6.0.12",
+    "@graphql-tools/utils": "6.0.12"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  }
+}

packages/batch-delegate/src/createBatchDelegateFn.ts

@@ -0,0 +1,51 @@
+import { FieldNode, getNamedType, GraphQLOutputType, GraphQLList } from 'graphql';
+
+import DataLoader from 'dataloader';
+
+import { delegateToSchema } from '@graphql-tools/delegate';
+
+import { BatchDelegateOptionsFn, BatchDelegateFn, BatchDelegateOptions } from './types';
+
+export function createBatchDelegateFn<K = any, V = any, C = K>(
+  argFn: (args: ReadonlyArray<K>) => Record<string, any>,
+  batchDelegateOptionsFn: BatchDelegateOptionsFn,
+  dataLoaderOptions?: DataLoader.Options<K, V, C>
+): BatchDelegateFn<K> {
+  let cache: WeakMap<ReadonlyArray<FieldNode>, DataLoader<K, V, C>>;
+
+  function createBatchFn(options: BatchDelegateOptions) {
+    return async (keys: ReadonlyArray<K>) => {
+      const results = await delegateToSchema({
+        returnType: new GraphQLList(getNamedType(options.info.returnType) as GraphQLOutputType),
+        args: argFn(keys),
+        ...batchDelegateOptionsFn(options),
+      });
+      return Array.isArray(results) ? results : keys.map(() => results);
+    };
+  }
+
+  function getLoader(options: BatchDelegateOptions) {
+    if (!cache) {
+      cache = new WeakMap();
+      const batchFn = createBatchFn(options);
+      const newValue = new DataLoader<K, V, C>(keys => batchFn(keys), dataLoaderOptions);
+      cache.set(options.info.fieldNodes, newValue);
+      return newValue;
+    }
+
+    const cachedValue = cache.get(options.info.fieldNodes);
+    if (cachedValue === undefined) {
+      const batchFn = createBatchFn(options);
+      const newValue = new DataLoader<K, V, C>(keys => batchFn(keys), dataLoaderOptions);
+      cache.set(options.info.fieldNodes, newValue);
+      return newValue;
+    }
+
+    return cachedValue;
+  }
+
+  return options => {
+    const loader = getLoader(options);
+    return loader.load(options.key);
+  };
+}

packages/batch-delegate/src/index.ts

@@ -0,0 +1,3 @@
+export { createBatchDelegateFn } from './createBatchDelegateFn';
+
+export * from './types';

packages/batch-delegate/src/types.ts

@@ -0,0 +1,14 @@
+import { IDelegateToSchemaOptions } from '@graphql-tools/delegate';
+
+export type BatchDelegateFn<TContext = Record<string, any>, K = any> = (
+  batchDelegateOptions: BatchDelegateOptions<TContext, K>
+) => any;
+
+export type BatchDelegateOptionsFn<TContext = Record<string, any>, K = any> = (
+  batchDelegateOptions: BatchDelegateOptions<TContext, K>
+) => IDelegateToSchemaOptions<TContext>;
+
+export interface BatchDelegateOptions<TContext = Record<string, any>, K = any>
+  extends Omit<IDelegateToSchemaOptions<TContext>, 'args'> {
+  key: K;
+}

packages/stitch/tests/typeMerging.example.test.ts → packages/batch-delegate/tests/typeMerging.example.test.ts

@@ -1,14 +1,16 @@
-// Conversion of Apollo Federation demo from https://github.com/apollographql/federation-demo.
-// See: https://github.com/ardatan/graphql-tools/issues/1697
+// Conversion of Apollo Federation demo
+// Compare: https://github.com/apollographql/federation-demo
+// See also:
+// https://github.com/ardatan/graphql-tools/issues/1697
+// https://github.com/ardatan/graphql-tools/issues/1710
 
-import { graphql, ExecutionResult } from 'graphql';
+import { graphql } from 'graphql';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
-
-import { stitchSchemas } from '../src/stitchSchemas';
+import { ExecutionResult } from '@graphql-tools/utils';
+import { stitchSchemas } from '@graphql-tools/stitch';
 
 describe('merging using type merging', () => {
-
   const users = [
     {
       id: '1',
@@ -29,6 +31,7 @@ describe('merging using type merging', () => {
       type Query {
         me: User
         _userById(id: ID!): User
+        _usersById(ids: [ID!]!): [User]
       }
       type User {
         id: ID!
@@ -40,6 +43,7 @@ describe('merging using type merging', () => {
       Query: {
         me: () => users[0],
         _userById: (_root, { id }) => users.find(user => user.id === id),
+        _usersById: (_root, { ids }) => ids.map((id: any) => users.find(user => user.id === id)),
       },
     },
   });
@@ -109,6 +113,7 @@ describe('merging using type merging', () => {
       type Query {
         topProducts(first: Int = 5): [Product]
         _productByUpc(upc: String!): Product
+        _productsByUpc(upcs: [String!]!): [Product]
       }
       type Product {
         upc: String!
@@ -121,6 +126,7 @@ describe('merging using type merging', () => {
       Query: {
         topProducts: (_root, args) => products.slice(0, args.first),
         _productByUpc: (_root, { upc }) => products.find(product => product.upc === upc),
+        _productsByUpc: (_root, { upcs }) => upcs.map((upc: any) => products.find(product => product.upc === upc)),
       }
     },
   });
@@ -177,8 +183,10 @@ describe('merging using type merging', () => {
       }
       type Query {
         _userById(id: ID!): User
+        _usersById(ids: [ID!]!): [User]
         _reviewById(id: ID!): Review
         _productByUpc(upc: String!): Product
+        _productsByUpc(upcs: [String!]!): [Product]
       }
     `,
     resolvers: {
@@ -199,7 +207,9 @@ describe('merging using type merging', () => {
       Query: {
         _reviewById: (_root, { id }) => reviews.find(review => review.id === id),
         _userById: (_root, { id }) => ({ id }),
+        _usersById: (_root, { ids }) => ids.map((id: string) => ({ id })),
         _productByUpc: (_, { upc }) => ({ upc }),
+        _productsByUpc: (_, { upcs }) => upcs.map((upc: string) => ({ upc })),
       },
     }
   });
@@ -210,8 +220,8 @@ describe('merging using type merging', () => {
         schema: accountsSchema,
         merge: {
           User: {
-            fieldName: '_userById',
             selectionSet: '{ id }',
+            fieldName: '_userById',
             args: ({ id }) => ({ id })
           }
         }
@@ -220,8 +230,8 @@ describe('merging using type merging', () => {
         schema: inventorySchema,
         merge: {
           Product: {
-            fieldName: '_productByUpc',
             selectionSet: '{ upc weight price }',
+            fieldName: '_productByUpc',
             args: ({ upc, weight, price }) => ({ upc, weight, price }),
           }
         }
@@ -230,8 +240,8 @@ describe('merging using type merging', () => {
         schema: productsSchema,
         merge: {
           Product: {
-            fieldName: '_productByUpc',
             selectionSet: '{ upc }',
+            fieldName: '_productByUpc',
             args: ({ upc }) => ({ upc }),
           }
         }
@@ -240,13 +250,14 @@ describe('merging using type merging', () => {
         schema: reviewsSchema,
         merge: {
           User: {
-            fieldName: '_userById',
             selectionSet: '{ id }',
-            args: ({ id }) => ({ id }),
+            fieldName: '_usersById',
+            args: (ids) => ({ ids }),
+            key: ({ id }) => id,
           },
           Product: {
-            fieldName: '_productByUpc',
             selectionSet: '{ upc }',
+            fieldName: '_productByUpc',
             args: ({ upc }) => ({ upc }),
           },
         }

packages/delegate/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/delegate",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -18,8 +18,8 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/schema": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
     "@ardatan/aggregate-error": "0.0.1",
     "tslib": "~2.0.0"
   },

packages/delegate/src/createMergedResolver.ts

@@ -1,8 +1,70 @@
-import { IFieldResolver } from '@graphql-tools/utils';
+import { GraphQLError } from 'graphql';
+
+import { IFieldResolver, getErrors, setErrors, relocatedError, ERROR_SYMBOL } from '@graphql-tools/utils';
+
+import { OBJECT_SUBSCHEMA_SYMBOL } from './symbols';
+
+import { getSubschema, setObjectSubschema } from './Subschema';
 
-import { unwrapResult, dehoistResult } from './proxiedResult';
 import { defaultMergedResolver } from './defaultMergedResolver';
 
+import { handleNull } from './results/handleNull';
+
+function unwrapResult(parent: any, path: Array<string>): any {
+  let newParent: any = parent;
+  const pathLength = path.length;
+  for (let i = 0; i < pathLength; i++) {
+    const responseKey = path[i];
+    const errors = getErrors(newParent, responseKey);
+    const subschema = getSubschema(newParent, responseKey);
+
+    const object = newParent[responseKey];
+    if (object == null) {
+      return handleNull(errors);
+    }
+
+    setErrors(
+      object,
+      errors.map(error => relocatedError(error, error.path != null ? error.path.slice(1) : undefined))
+    );
+    setObjectSubschema(object, subschema);
+
+    newParent = object;
+  }
+
+  return newParent;
+}
+
+function dehoistResult(parent: any, delimeter = '__gqltf__'): any {
+  const result = Object.create(null);
+
+  Object.keys(parent).forEach(alias => {
+    let obj = result;
+
+    const fieldNames = alias.split(delimeter);
+    const fieldName = fieldNames.pop();
+    fieldNames.forEach(key => {
+      obj = obj[key] = obj[key] || Object.create(null);
+    });
+    obj[fieldName] = parent[alias];
+  });
+
+  result[ERROR_SYMBOL] = parent[ERROR_SYMBOL].map((error: GraphQLError) => {
+    if (error.path != null) {
+      const path = error.path.slice();
+      const pathSegment = path.shift();
+      const expandedPathSegment: Array<string | number> = (pathSegment as string).split(delimeter);
+      return relocatedError(error, expandedPathSegment.concat(path));
+    }
+
+    return error;
+  });
+
+  result[OBJECT_SUBSCHEMA_SYMBOL] = parent[OBJECT_SUBSCHEMA_SYMBOL];
+
+  return result;
+}
+
 export function createMergedResolver({
   fromPath,
   dehoist,

packages/delegate/src/delegateToSchema.ts

@@ -3,7 +3,6 @@ import {
   execute,
   validate,
   GraphQLSchema,
-  ExecutionResult,
   isSchema,
   FieldDefinitionNode,
   getOperationAST,
@@ -14,7 +13,7 @@ import {
   GraphQLObjectType,
 } from 'graphql';
 
-import { mapAsyncIterator, Transform } from '@graphql-tools/utils';
+import { mapAsyncIterator, Transform, ExecutionResult } from '@graphql-tools/utils';
 
 import { IDelegateToSchemaOptions, IDelegateRequestOptions, SubschemaConfig, ExecutionParams } from './types';
 

packages/delegate/src/delegationBindings.ts

@@ -2,12 +2,11 @@ import { Transform } from '@graphql-tools/utils';
 
 import { StitchingInfo, DelegationContext } from './types';
 
+import AddSelectionSets from './transforms/AddSelectionSets';
 import ExpandAbstractTypes from './transforms/ExpandAbstractTypes';
 import WrapConcreteTypes from './transforms/WrapConcreteTypes';
 import FilterToSchema from './transforms/FilterToSchema';
 import AddFragmentsByField from './transforms/AddFragmentsByField';
-import AddSelectionSetsByField from './transforms/AddSelectionSetsByField';
-import AddSelectionSetsByType from './transforms/AddSelectionSetsByType';
 import AddTypenameToAbstract from './transforms/AddTypenameToAbstract';
 import CheckResultAndHandleErrors from './transforms/CheckResultAndHandleErrors';
 import AddArgumentsAsVariables from './transforms/AddArgumentsAsVariables';
@@ -39,8 +38,13 @@ export function defaultDelegationBinding(delegationContext: DelegationContext):
 
   if (stitchingInfo != null) {
     delegationTransforms = delegationTransforms.concat([
-      new AddSelectionSetsByField(info.schema, stitchingInfo.selectionSetsByField),
-      new AddSelectionSetsByType(info.schema, stitchingInfo.selectionSetsByType),
+      new AddSelectionSets(
+        info.schema,
+        returnType,
+        stitchingInfo.selectionSetsByType,
+        stitchingInfo.selectionSetsByField,
+        stitchingInfo.dynamicSelectionSetsByField
+      ),
       new WrapConcreteTypes(returnType, transformedSchema),
       new ExpandAbstractTypes(info.schema, transformedSchema),
     ]);

packages/delegate/src/results/getFieldsNotInSubschema.ts

@@ -0,0 +1,81 @@
+import { GraphQLSchema, FieldNode, GraphQLObjectType, GraphQLResolveInfo } from 'graphql';
+
+import { collectFields, GraphQLExecutionContext } from '@graphql-tools/utils';
+import { isSubschemaConfig } from '../Subschema';
+import { MergedTypeInfo, SubschemaConfig, StitchingInfo } from '../types';
+
+import { memoizeInfoAnd2Objectsand1Primitive } from './memoize';
+
+function collectSubFields(info: GraphQLResolveInfo, typeName: string): Record<string, Array<FieldNode>> {
+  let subFieldNodes: Record<string, Array<FieldNode>> = Object.create(null);
+  const visitedFragmentNames = Object.create(null);
+
+  const type = info.schema.getType(typeName) as GraphQLObjectType;
+  const partialExecutionContext = ({
+    schema: info.schema,
+    variableValues: info.variableValues,
+    fragments: info.fragments,
+  } as unknown) as GraphQLExecutionContext;
+
+  info.fieldNodes.forEach(fieldNode => {
+    subFieldNodes = collectFields(
+      partialExecutionContext,
+      type,
+      fieldNode.selectionSet,
+      subFieldNodes,
+      visitedFragmentNames
+    );
+  });
+
+  const stitchingInfo = info.schema.extensions.stitchingInfo as StitchingInfo;
+  const selectionSetsByType = stitchingInfo.selectionSetsByType;
+  const selectionSetsByField = stitchingInfo.selectionSetsByField;
+
+  Object.keys(subFieldNodes).forEach(responseName => {
+    const fieldName = subFieldNodes[responseName][0].name.value;
+    const typeSelectionSet = selectionSetsByType[typeName];
+    if (typeSelectionSet != null) {
+      subFieldNodes = collectFields(
+        partialExecutionContext,
+        type,
+        typeSelectionSet,
+        subFieldNodes,
+        visitedFragmentNames
+      );
+    }
+    const fieldSelectionSet = selectionSetsByField?.[typeName]?.[fieldName];
+    if (fieldSelectionSet != null) {
+      subFieldNodes = collectFields(
+        partialExecutionContext,
+        type,
+        fieldSelectionSet,
+        subFieldNodes,
+        visitedFragmentNames
+      );
+    }
+  });
+
+  return subFieldNodes;
+}
+
+export const getFieldsNotInSubschema = memoizeInfoAnd2Objectsand1Primitive(function (
+  info: GraphQLResolveInfo,
+  subschema: GraphQLSchema | SubschemaConfig,
+  mergedTypeInfo: MergedTypeInfo,
+  typeName: string
+): Array<FieldNode> {
+  const typeMap = isSubschemaConfig(subschema) ? mergedTypeInfo.typeMaps.get(subschema) : subschema.getTypeMap();
+  const fields = (typeMap[typeName] as GraphQLObjectType).getFields();
+
+  const subFieldNodes = collectSubFields(info, typeName);
+
+  let fieldsNotInSchema: Array<FieldNode> = [];
+  Object.keys(subFieldNodes).forEach(responseName => {
+    const fieldName = subFieldNodes[responseName][0].name.value;
+    if (!(fieldName in fields)) {
+      fieldsNotInSchema = fieldsNotInSchema.concat(subFieldNodes[responseName]);
+    }
+  });
+
+  return fieldsNotInSchema;
+});

packages/delegate/src/results/handleObject.ts

@@ -1,17 +1,13 @@
-import {
-  GraphQLCompositeType,
-  GraphQLError,
-  GraphQLSchema,
-  isAbstractType,
-  FieldNode,
-  GraphQLObjectType,
-  GraphQLResolveInfo,
-} from 'graphql';
+import { GraphQLCompositeType, GraphQLError, GraphQLSchema, isAbstractType, GraphQLResolveInfo } from 'graphql';
 
-import { collectFields, GraphQLExecutionContext, setErrors, slicedError } from '@graphql-tools/utils';
-import { setObjectSubschema, isSubschemaConfig } from '../Subschema';
-import { mergeFields } from '../mergeFields';
-import { MergedTypeInfo, SubschemaConfig, StitchingInfo } from '../types';
+import { setErrors, slicedError } from '@graphql-tools/utils';
+
+import { SubschemaConfig } from '../types';
+
+import { setObjectSubschema } from '../Subschema';
+
+import { mergeFields } from './mergeFields';
+import { getFieldsNotInSubschema } from './getFieldsNotInSubschema';
 
 export function handleObject(
   type: GraphQLCompositeType,
@@ -40,102 +36,23 @@ export function handleObject(
   let targetSubschemas: Array<SubschemaConfig>;
 
   if (mergedTypeInfo != null) {
-    targetSubschemas = mergedTypeInfo.subschemas;
+    targetSubschemas = mergedTypeInfo.targetSubschemas.get(subschema);
   }
 
   if (!targetSubschemas) {
     return object;
   }
 
-  targetSubschemas = targetSubschemas.filter(s => s !== subschema);
-  if (!targetSubschemas.length) {
-    return object;
-  }
-
-  const fieldNodes = getFieldsNotInSubschema(info, subschema, mergedTypeInfo, object.__typename);
+  const fieldNodes = getFieldsNotInSubschema(info, subschema, mergedTypeInfo, typeName);
 
   return mergeFields(
     mergedTypeInfo,
     typeName,
     object,
     fieldNodes,
-    [subschema as SubschemaConfig],
+    subschema as SubschemaConfig,
     targetSubschemas,
     context,
     info
   );
 }
-
-function collectSubFields(info: GraphQLResolveInfo, typeName: string): Record<string, Array<FieldNode>> {
-  let subFieldNodes: Record<string, Array<FieldNode>> = Object.create(null);
-  const visitedFragmentNames = Object.create(null);
-
-  const type = info.schema.getType(typeName) as GraphQLObjectType;
-  const partialExecutionContext = ({
-    schema: info.schema,
-    variableValues: info.variableValues,
-    fragments: info.fragments,
-  } as unknown) as GraphQLExecutionContext;
-
-  info.fieldNodes.forEach(fieldNode => {
-    subFieldNodes = collectFields(
-      partialExecutionContext,
-      type,
-      fieldNode.selectionSet,
-      subFieldNodes,
-      visitedFragmentNames
-    );
-  });
-
-  const stitchingInfo = info.schema.extensions.stitchingInfo as StitchingInfo;
-  const selectionSetsByType = stitchingInfo.selectionSetsByType;
-  const selectionSetsByField = stitchingInfo.selectionSetsByField;
-
-  Object.keys(subFieldNodes).forEach(responseName => {
-    const fieldName = subFieldNodes[responseName][0].name.value;
-    const typeSelectionSet = selectionSetsByType[typeName];
-    if (typeSelectionSet != null) {
-      subFieldNodes = collectFields(
-        partialExecutionContext,
-        type,
-        typeSelectionSet,
-        subFieldNodes,
-        visitedFragmentNames
-      );
-    }
-    const fieldSelectionSet = selectionSetsByField?.[typeName]?.[fieldName];
-    if (fieldSelectionSet != null) {
-      subFieldNodes = collectFields(
-        partialExecutionContext,
-        type,
-        fieldSelectionSet,
-        subFieldNodes,
-        visitedFragmentNames
-      );
-    }
-  });
-
-  return subFieldNodes;
-}
-
-function getFieldsNotInSubschema(
-  info: GraphQLResolveInfo,
-  subschema: GraphQLSchema | SubschemaConfig,
-  mergedTypeInfo: MergedTypeInfo,
-  typeName: string
-): Array<FieldNode> {
-  const typeMap = isSubschemaConfig(subschema) ? mergedTypeInfo.typeMaps.get(subschema) : subschema.getTypeMap();
-  const fields = (typeMap[typeName] as GraphQLObjectType).getFields();
-
-  const subFieldNodes = collectSubFields(info, typeName);
-
-  let fieldsNotInSchema: Array<FieldNode> = [];
-  Object.keys(subFieldNodes).forEach(responseName => {
-    const fieldName = subFieldNodes[responseName][0].name.value;
-    if (!(fieldName in fields)) {
-      fieldsNotInSchema = fieldsNotInSchema.concat(subFieldNodes[responseName]);
-    }
-  });
-
-  return fieldsNotInSchema;
-}

packages/delegate/src/results/memoize.ts

@@ -0,0 +1,160 @@
+import { GraphQLResolveInfo, FieldNode } from 'graphql';
+
+export function memoizeInfoAnd2Objectsand1Primitive<
+  T1 extends GraphQLResolveInfo,
+  T2 extends Record<string, any>,
+  T3 extends Record<string, any>,
+  T4 extends string,
+  R extends any
+>(fn: (A1: T1, A2: T2, A3: T3, A4: T4) => R): (A1: T1, A2: T2, A3: T3, A4: T4) => R {
+  let cache1: WeakMap<ReadonlyArray<FieldNode>, WeakMap<T2, WeakMap<T3, Record<string, R>>>>;
+
+  function memoized(a1: T1, a2: T2, a3: T3, a4: T4) {
+    if (!cache1) {
+      cache1 = new WeakMap();
+      const cache2: WeakMap<T2, WeakMap<T3, Record<T4, R>>> = new WeakMap();
+      cache1.set(a1.fieldNodes, cache2);
+      const cache3: WeakMap<T3, Record<T4, R>> = new WeakMap();
+      cache2.set(a2, cache3);
+      const cache4 = Object.create(null);
+      cache3.set(a3, cache4);
+      const newValue = fn(a1, a2, a3, a4);
+      cache4[a4] = newValue;
+      return newValue;
+    }
+
+    let cache2 = cache1.get(a1.fieldNodes);
+    if (!cache2) {
+      cache2 = new WeakMap();
+      cache1.set(a1.fieldNodes, cache2);
+      const cache3: WeakMap<T3, Record<T4, R>> = new WeakMap();
+      cache2.set(a2, cache3);
+      const cache4 = Object.create(null);
+      cache3.set(a3, cache4);
+      const newValue = fn(a1, a2, a3, a4);
+      cache4[a4] = newValue;
+      return newValue;
+    }
+
+    let cache3 = cache2.get(a2);
+    if (!cache3) {
+      cache3 = new WeakMap();
+      cache2.set(a2, cache3);
+      const cache4 = Object.create(null);
+      cache3.set(a3, cache4);
+      const newValue = fn(a1, a2, a3, a4);
+      cache4[a4] = newValue;
+      return newValue;
+    }
+
+    let cache4 = cache3.get(a3);
+    if (!cache4) {
+      cache4 = Object.create(null);
+      cache3.set(a3, cache4);
+      const newValue = fn(a1, a2, a3, a4);
+      cache4[a4] = newValue;
+      return newValue;
+    }
+
+    const cachedValue = cache4[a4];
+    if (cachedValue === undefined) {
+      const newValue = fn(a1, a2, a3, a4);
+      cache4[a4] = newValue;
+      return newValue;
+    }
+
+    return cachedValue;
+  }
+
+  return memoized;
+}
+
+export function memoize3<
+  T1 extends Record<string, any>,
+  T2 extends Record<string, any>,
+  T3 extends Record<string, any>,
+  R extends any
+>(fn: (A1: T1, A2: T2, A3: T3) => R): (A1: T1, A2: T2, A3: T3) => R {
+  let cache1: WeakMap<T1, WeakMap<T2, WeakMap<T3, R>>>;
+
+  function memoized(a1: T1, a2: T2, a3: T3) {
+    if (!cache1) {
+      cache1 = new WeakMap();
+      const cache2: WeakMap<T2, WeakMap<T3, R>> = new WeakMap();
+      cache1.set(a1, cache2);
+      const cache3: WeakMap<T3, R> = new WeakMap();
+      cache2.set(a2, cache3);
+      const newValue = fn(a1, a2, a3);
+      cache3.set(a3, newValue);
+      return newValue;
+    }
+
+    let cache2 = cache1.get(a1);
+    if (!cache2) {
+      cache2 = new WeakMap();
+      cache1.set(a1, cache2);
+      const cache3: WeakMap<T3, R> = new WeakMap();
+      cache2.set(a2, cache3);
+      const newValue = fn(a1, a2, a3);
+      cache3.set(a3, newValue);
+      return newValue;
+    }
+
+    let cache3 = cache2.get(a2);
+    if (!cache3) {
+      cache3 = new WeakMap();
+      cache2.set(a2, cache3);
+      const newValue = fn(a1, a2, a3);
+      cache3.set(a3, newValue);
+      return newValue;
+    }
+
+    const cachedValue = cache3.get(a3);
+    if (cachedValue === undefined) {
+      const newValue = fn(a1, a2, a3);
+      cache3.set(a3, newValue);
+      return newValue;
+    }
+
+    return cachedValue;
+  }
+
+  return memoized;
+}
+
+export function memoize2<T1 extends Record<string, any>, T2 extends Record<string, any>, R extends any>(
+  fn: (A1: T1, A2: T2) => R
+): (A1: T1, A2: T2) => R {
+  let cache1: WeakMap<T1, WeakMap<T2, R>>;
+
+  function memoized(a1: T1, a2: T2) {
+    if (!cache1) {
+      cache1 = new WeakMap();
+      const cache2: WeakMap<T2, R> = new WeakMap();
+      cache1.set(a1, cache2);
+      const newValue = fn(a1, a2);
+      cache2.set(a2, newValue);
+      return newValue;
+    }
+
+    let cache2 = cache1.get(a1);
+    if (!cache2) {
+      cache2 = new WeakMap();
+      cache1.set(a1, cache2);
+      const newValue = fn(a1, a2);
+      cache2.set(a2, newValue);
+      return newValue;
+    }
+
+    const cachedValue = cache2.get(a2);
+    if (cachedValue === undefined) {
+      const newValue = fn(a1, a2);
+      cache2.set(a2, newValue);
+      return newValue;
+    }
+
+    return cachedValue;
+  }
+
+  return memoized;
+}

packages/delegate/src/mergeFields.ts → packages/delegate/src/results/mergeFields.ts

@@ -1,16 +1,15 @@
-import { FieldNode, SelectionNode, Kind, GraphQLResolveInfo } from 'graphql';
+import { FieldNode, SelectionNode, Kind, GraphQLResolveInfo, SelectionSetNode } from 'graphql';
 
-import { mergeProxiedResults } from './proxiedResult';
-import { MergedTypeInfo, SubschemaConfig } from './types';
+import { MergedTypeInfo, SubschemaConfig } from '../types';
 
-function buildDelegationPlan(
+import { memoize3, memoize2 } from './memoize';
+import { mergeProxiedResults } from './mergeProxiedResults';
+
+const sortSubschemasByProxiability = memoize3(function (
   mergedTypeInfo: MergedTypeInfo,
-  fieldNodes: Array<FieldNode>,
-  sourceSubschemas: Array<SubschemaConfig>,
+  sourceSubschemaOrSourceSubschemas: SubschemaConfig | Array<SubschemaConfig>,
   targetSubschemas: Array<SubschemaConfig>
 ): {
-  delegationMap: Map<SubschemaConfig, Array<SelectionNode>>;
-  unproxiableFieldNodes: Array<FieldNode>;
   proxiableSubschemas: Array<SubschemaConfig>;
   nonProxiableSubschemas: Array<SubschemaConfig>;
 } {
@@ -20,6 +19,9 @@ function buildDelegationPlan(
   const proxiableSubschemas: Array<SubschemaConfig> = [];
   const nonProxiableSubschemas: Array<SubschemaConfig> = [];
 
+  const sourceSubschemas = Array.isArray(sourceSubschemaOrSourceSubschemas)
+    ? sourceSubschemaOrSourceSubschemas
+    : [sourceSubschemaOrSourceSubschemas];
   targetSubschemas.forEach(t => {
     if (
       sourceSubschemas.some(s => {
@@ -33,6 +35,20 @@ function buildDelegationPlan(
     }
   });
 
+  return {
+    proxiableSubschemas,
+    nonProxiableSubschemas,
+  };
+});
+
+const buildDelegationPlan = memoize3(function (
+  mergedTypeInfo: MergedTypeInfo,
+  fieldNodes: Array<FieldNode>,
+  proxiableSubschemas: Array<SubschemaConfig>
+): {
+  delegationMap: Map<SubschemaConfig, SelectionSetNode>;
+  unproxiableFieldNodes: Array<FieldNode>;
+} {
   const { uniqueFields, nonUniqueFields } = mergedTypeInfo;
   const unproxiableFieldNodes: Array<FieldNode> = [];
 
@@ -87,20 +103,36 @@ function buildDelegationPlan(
     }
   });
 
+  const finalDelegationMap: Map<SubschemaConfig, SelectionSetNode> = new Map();
+
+  delegationMap.forEach((selections, subschema) => {
+    finalDelegationMap.set(subschema, {
+      kind: Kind.SELECTION_SET,
+      selections,
+    });
+  });
+
   return {
-    delegationMap,
+    delegationMap: finalDelegationMap,
     unproxiableFieldNodes,
-    proxiableSubschemas,
-    nonProxiableSubschemas,
   };
-}
+});
+
+const combineSubschemas = memoize2(function (
+  subschemaOrSubschemas: SubschemaConfig | Array<SubschemaConfig>,
+  additionalSubschemas: Array<SubschemaConfig>
+): Array<SubschemaConfig> {
+  return Array.isArray(subschemaOrSubschemas)
+    ? subschemaOrSubschemas.concat(additionalSubschemas)
+    : [subschemaOrSubschemas].concat(additionalSubschemas);
+});
 
 export function mergeFields(
   mergedTypeInfo: MergedTypeInfo,
   typeName: string,
   object: any,
   fieldNodes: Array<FieldNode>,
-  sourceSubschemas: Array<SubschemaConfig>,
+  sourceSubschemaOrSourceSubschemas: SubschemaConfig | Array<SubschemaConfig>,
   targetSubschemas: Array<SubschemaConfig>,
   context: Record<string, any>,
   info: GraphQLResolveInfo
@@ -109,33 +141,27 @@ export function mergeFields(
     return object;
   }
 
-  const { delegationMap, unproxiableFieldNodes, proxiableSubschemas, nonProxiableSubschemas } = buildDelegationPlan(
+  const { proxiableSubschemas, nonProxiableSubschemas } = sortSubschemasByProxiability(
     mergedTypeInfo,
-    fieldNodes,
-    sourceSubschemas,
+    sourceSubschemaOrSourceSubschemas,
     targetSubschemas
   );
 
+  const { delegationMap, unproxiableFieldNodes } = buildDelegationPlan(mergedTypeInfo, fieldNodes, proxiableSubschemas);
+
   if (!delegationMap.size) {
     return object;
   }
 
+  let containsPromises = false;
   const maybePromises: Promise<any> | any = [];
-  delegationMap.forEach((selections: Array<SelectionNode>, s: SubschemaConfig) => {
-    const maybePromise = s.merge[typeName].resolve(object, context, info, s, {
-      kind: Kind.SELECTION_SET,
-      selections,
-    });
+  delegationMap.forEach((selectionSet: SelectionSetNode, s: SubschemaConfig) => {
+    const maybePromise = s.merge[typeName].resolve(object, context, info, s, selectionSet);
     maybePromises.push(maybePromise);
-  });
-
-  let containsPromises = false;
-  for (const maybePromise of maybePromises) {
-    if (maybePromise instanceof Promise) {
+    if (!containsPromises && maybePromise instanceof Promise) {
       containsPromises = true;
-      break;
     }
-  }
+  });
 
   return containsPromises
     ? Promise.all(maybePromises).then(results =>
@@ -144,7 +170,7 @@ export function mergeFields(
           typeName,
           mergeProxiedResults(object, ...results),
           unproxiableFieldNodes,
-          sourceSubschemas.concat(proxiableSubschemas),
+          combineSubschemas(sourceSubschemaOrSourceSubschemas, proxiableSubschemas),
           nonProxiableSubschemas,
           context,
           info
@@ -155,7 +181,7 @@ export function mergeFields(
         typeName,
         mergeProxiedResults(object, ...maybePromises),
         unproxiableFieldNodes,
-        sourceSubschemas.concat(proxiableSubschemas),
+        combineSubschemas(sourceSubschemaOrSourceSubschemas, proxiableSubschemas),
         nonProxiableSubschemas,
         context,
         info

packages/delegate/src/results/mergeProxiedResults.ts

@@ -0,0 +1,25 @@
+import { mergeDeep, ERROR_SYMBOL } from '@graphql-tools/utils';
+
+import { SubschemaConfig } from '../types';
+import { OBJECT_SUBSCHEMA_SYMBOL, FIELD_SUBSCHEMA_MAP_SYMBOL } from '../symbols';
+
+export function mergeProxiedResults(target: any, ...sources: Array<any>): any {
+  const results = sources.filter(source => !(source instanceof Error));
+  const fieldSubschemaMap = results.reduce((acc: Record<any, SubschemaConfig>, source: any) => {
+    const subschema = source[OBJECT_SUBSCHEMA_SYMBOL];
+    Object.keys(source).forEach(key => {
+      acc[key] = subschema;
+    });
+    return acc;
+  }, {});
+
+  const result = results.reduce(mergeDeep, target);
+  result[FIELD_SUBSCHEMA_MAP_SYMBOL] = target[FIELD_SUBSCHEMA_MAP_SYMBOL]
+    ? Object.assign({}, target[FIELD_SUBSCHEMA_MAP_SYMBOL], fieldSubschemaMap)
+    : fieldSubschemaMap;
+
+  const errors = sources.map((source: any) => (source instanceof Error ? source : source[ERROR_SYMBOL]));
+  result[ERROR_SYMBOL] = target[ERROR_SYMBOL].concat(...errors);
+
+  return result;
+}

packages/delegate/src/transforms/AddSelectionSets.ts

@@ -0,0 +1,81 @@
+import { GraphQLSchema, SelectionSetNode, TypeInfo, GraphQLOutputType, Kind, FieldNode } from 'graphql';
+
+import { Transform, Request } from '@graphql-tools/utils';
+import VisitSelectionSets from './VisitSelectionSets';
+
+export default class AddSelectionSetsByField implements Transform {
+  private readonly transformer: VisitSelectionSets;
+
+  constructor(
+    sourceSchema: GraphQLSchema,
+    initialType: GraphQLOutputType,
+    selectionSetsByType: Record<string, SelectionSetNode>,
+    selectionSetsByField: Record<string, Record<string, SelectionSetNode>>,
+    dynamicSelectionSetsByField: Record<string, Record<string, Array<(node: FieldNode) => SelectionSetNode>>>
+  ) {
+    this.transformer = new VisitSelectionSets(sourceSchema, initialType, (node, typeInfo) =>
+      visitSelectionSet(node, typeInfo, selectionSetsByType, selectionSetsByField, dynamicSelectionSetsByField)
+    );
+  }
+
+  public transformRequest(originalRequest: Request): Request {
+    return this.transformer.transformRequest(originalRequest);
+  }
+}
+
+function visitSelectionSet(
+  node: SelectionSetNode,
+  typeInfo: TypeInfo,
+  selectionSetsByType: Record<string, SelectionSetNode>,
+  selectionSetsByField: Record<string, Record<string, SelectionSetNode>>,
+  dynamicSelectionSetsByField: Record<string, Record<string, Array<(node: FieldNode) => SelectionSetNode>>>
+): SelectionSetNode {
+  const parentType = typeInfo.getParentType();
+  if (parentType != null) {
+    const parentTypeName = parentType.name;
+    let selections = node.selections;
+
+    if (parentTypeName in selectionSetsByType) {
+      const selectionSet = selectionSetsByType[parentTypeName];
+      if (selectionSet != null) {
+        selections = selections.concat(selectionSet.selections);
+      }
+    }
+
+    if (parentTypeName in selectionSetsByField) {
+      node.selections.forEach(selection => {
+        if (selection.kind === Kind.FIELD) {
+          const name = selection.name.value;
+          const selectionSet = selectionSetsByField[parentTypeName][name];
+          if (selectionSet != null) {
+            selections = selections.concat(selectionSet.selections);
+          }
+        }
+      });
+    }
+
+    if (parentTypeName in dynamicSelectionSetsByField) {
+      node.selections.forEach(selection => {
+        if (selection.kind === Kind.FIELD) {
+          const name = selection.name.value;
+          const dynamicSelectionSets = dynamicSelectionSetsByField[parentTypeName][name];
+          if (dynamicSelectionSets != null) {
+            dynamicSelectionSets.forEach(selectionSetFn => {
+              const selectionSet = selectionSetFn(selection);
+              if (selectionSet != null) {
+                selections = selections.concat(selectionSet.selections);
+              }
+            });
+          }
+        }
+      });
+    }
+
+    if (selections !== node.selections) {
+      return {
+        ...node,
+        selections,
+      };
+    }
+  }
+}

packages/delegate/src/transforms/CheckResultAndHandleErrors.ts

@@ -1,6 +1,6 @@
-import { GraphQLResolveInfo, ExecutionResult, GraphQLOutputType, GraphQLSchema } from 'graphql';
+import { GraphQLResolveInfo, GraphQLOutputType, GraphQLSchema } from 'graphql';
 
-import { Transform, getResponseKeyFromInfo } from '@graphql-tools/utils';
+import { Transform, getResponseKeyFromInfo, ExecutionResult } from '@graphql-tools/utils';
 import { handleResult } from '../results/handleResult';
 import { SubschemaConfig } from '../types';
 

packages/delegate/src/transforms/VisitSelectionSets.ts

@@ -0,0 +1,137 @@
+import {
+  DocumentNode,
+  GraphQLSchema,
+  Kind,
+  SelectionSetNode,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo,
+  GraphQLOutputType,
+  OperationDefinitionNode,
+  FragmentDefinitionNode,
+  SelectionNode,
+  DefinitionNode,
+} from 'graphql';
+
+import { Transform, Request, collectFields, GraphQLExecutionContext } from '@graphql-tools/utils';
+
+export default class VisitSelectionSets implements Transform {
+  private readonly schema: GraphQLSchema;
+  private readonly initialType: GraphQLOutputType;
+  private readonly visitor: (node: SelectionSetNode, typeInfo: TypeInfo) => SelectionSetNode;
+
+  constructor(
+    schema: GraphQLSchema,
+    initialType: GraphQLOutputType,
+    visitor: (node: SelectionSetNode, typeInfo: TypeInfo) => SelectionSetNode
+  ) {
+    this.schema = schema;
+    this.initialType = initialType;
+    this.visitor = visitor;
+  }
+
+  public transformRequest(originalRequest: Request): Request {
+    const document = visitSelectionSets(originalRequest, this.schema, this.initialType, this.visitor);
+    return {
+      ...originalRequest,
+      document,
+    };
+  }
+}
+
+function visitSelectionSets(
+  request: Request,
+  schema: GraphQLSchema,
+  initialType: GraphQLOutputType,
+  visitor: (node: SelectionSetNode, typeInfo: TypeInfo) => SelectionSetNode
+): DocumentNode {
+  const { document, variables } = request;
+
+  const operations: Array<OperationDefinitionNode> = [];
+  const fragments: Record<string, FragmentDefinitionNode> = Object.create(null);
+  document.definitions.forEach(def => {
+    if (def.kind === Kind.OPERATION_DEFINITION) {
+      operations.push(def);
+    } else if (def.kind === Kind.FRAGMENT_DEFINITION) {
+      fragments[def.name.value] = def;
+    }
+  });
+
+  const partialExecutionContext = {
+    schema,
+    variableValues: variables,
+    fragments,
+  } as GraphQLExecutionContext;
+
+  const typeInfo = new TypeInfo(schema, undefined, initialType);
+  const newDefinitions: Array<DefinitionNode> = operations.map(operation => {
+    const type =
+      operation.operation === 'query'
+        ? schema.getQueryType()
+        : operation.operation === 'mutation'
+        ? schema.getMutationType()
+        : schema.getSubscriptionType();
+
+    const fields = collectFields(
+      partialExecutionContext,
+      type,
+      operation.selectionSet,
+      Object.create(null),
+      Object.create(null)
+    );
+
+    const newSelections: Array<SelectionNode> = [];
+    Object.keys(fields).forEach(responseKey => {
+      const fieldNodes = fields[responseKey];
+      fieldNodes.forEach(fieldNode => {
+        const selectionSet = fieldNode.selectionSet;
+
+        if (selectionSet == null) {
+          newSelections.push(fieldNode);
+          return;
+        }
+
+        const newSelectionSet = visit(
+          selectionSet,
+          visitWithTypeInfo(typeInfo, {
+            [Kind.SELECTION_SET]: node => visitor(node, typeInfo),
+          })
+        );
+
+        if (newSelectionSet === selectionSet) {
+          newSelections.push(fieldNode);
+          return;
+        }
+
+        newSelections.push({
+          ...fieldNode,
+          selectionSet: newSelectionSet,
+        });
+      });
+    });
+
+    return {
+      ...operation,
+      selectionSet: {
+        kind: Kind.SELECTION_SET,
+        selections: newSelections,
+      },
+    };
+  });
+
+  Object.values(fragments).forEach(fragment => {
+    newDefinitions.push(
+      visit(
+        fragment,
+        visitWithTypeInfo(typeInfo, {
+          [Kind.SELECTION_SET]: node => visitor(node, typeInfo),
+        })
+      )
+    );
+  });
+
+  return {
+    ...document,
+    definitions: newDefinitions,
+  };
+}

packages/delegate/src/transforms/index.ts

@@ -1,13 +1,14 @@
 export { default as CheckResultAndHandleErrors } from './CheckResultAndHandleErrors';
 export { checkResultAndHandleErrors } from './CheckResultAndHandleErrors';
 export { default as ExpandAbstractTypes } from './ExpandAbstractTypes';
-export { default as AddSelectionSetsByField } from './AddSelectionSetsByField';
-export { default as AddMergedTypeSelectionSets } from './AddSelectionSetsByType';
+export { default as VisitSelectionSets } from './VisitSelectionSets';
+export { default as AddSelectionSets } from './AddSelectionSets';
 export { default as AddArgumentsAsVariables } from './AddArgumentsAsVariables';
 export { default as FilterToSchema } from './FilterToSchema';
 export { default as AddTypenameToAbstract } from './AddTypenameToAbstract';
 
-// superseded by AddFragmentsByField
+// superseded by VisitSelectionSets and AddSelectionSets
+export { default as AddSelectionSetsByField } from './AddSelectionSetsByField';
+export { default as AddMergedTypeSelectionSets } from './AddSelectionSetsByType';
 export { default as ReplaceFieldWithFragment } from './ReplaceFieldWithFragment';
-// superseded by AddSelectionSetsByField
 export { default as AddFragmentsByField } from './AddFragmentsByField';

packages/delegate/src/types.ts

@@ -81,7 +81,7 @@ export interface ICreateRequest {
 }
 
 export interface MergedTypeInfo {
-  subschemas: Array<SubschemaConfig>;
+  targetSubschemas: Map<SubschemaConfig, Array<SubschemaConfig>>;
   selectionSet?: SelectionSetNode;
   uniqueFields: Record<string, SubschemaConfig>;
   nonUniqueFields: Record<string, Array<SubschemaConfig>>;
@@ -135,7 +135,8 @@ export interface SubschemaConfig {
 export interface MergedTypeConfig {
   selectionSet?: string;
   fieldName?: string;
-  args?: (originalResult: any) => Record<string, any>;
+  args?: (source: any) => Record<string, any>;
+  key?: (originalResult: any) => any;
   resolve?: MergedTypeResolver;
 }
 
@@ -150,7 +151,8 @@ export type MergedTypeResolver = (
 export interface StitchingInfo {
   transformedSchemas: Map<GraphQLSchema | SubschemaConfig, GraphQLSchema>;
   fragmentsByField: Record<string, Record<string, InlineFragmentNode>>;
-  selectionSetsByField: Record<string, Record<string, SelectionSetNode>>;
   selectionSetsByType: Record<string, SelectionSetNode>;
+  selectionSetsByField: Record<string, Record<string, SelectionSetNode>>;
+  dynamicSelectionSetsByField: Record<string, Record<string, Array<(node: FieldNode) => SelectionSetNode>>>;
   mergedTypes: Record<string, MergedTypeInfo>;
 }

packages/graphql-tag-pluck/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/graphql-tag-pluck",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "Pluck graphql-tag template literals",
   "license": "MIT",
   "repository": "git@github.com:ardatan/graphql-tools.git",
@@ -18,13 +18,13 @@
     "@babel/parser": "7.10.4",
     "@babel/traverse": "7.10.4",
     "@babel/types": "7.10.4",
-    "@graphql-tools/utils": "6.0.11"
+    "@graphql-tools/utils": "6.0.12"
   },
   "optionalDependencies": {
     "vue-template-compiler": "^2.6.11"
   },
   "devDependencies": {
-    "@types/babel__traverse": "7.0.12",
+    "@types/babel__traverse": "7.0.13",
     "vue-template-compiler": "2.6.11"
   },
   "publishConfig": {

packages/graphql-tag-pluck/src/index.ts

@@ -5,9 +5,98 @@ import createVisitor from './visitor';
 import traverse from '@babel/traverse';
 import { freeText } from './utils';
 
+/**
+ * Additional options for determining how a file is parsed.
+ */
 export interface GraphQLTagPluckOptions {
+  /**
+   * Additional options for determining how a file is parsed.An array of packages that are responsible for exporting the GraphQL string parser function. The following modules are supported by default:
+   * ```js
+   * {
+   *   modules: [
+   *     {
+   *       // import gql from 'graphql-tag'
+   *       name: 'graphql-tag',
+   *     },
+   *     {
+   *       name: 'graphql-tag.macro',
+   *     },
+   *     {
+   *       // import { graphql } from 'gatsby'
+   *       name: 'gatsby',
+   *       identifier: 'graphql',
+   *     },
+   *     {
+   *       name: 'apollo-server-express',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'react-relay',
+   *       identifier: 'graphql',
+   *     },
+   *     {
+   *       name: 'apollo-boost',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-koa',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-hapi',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-fastify',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: ' apollo-server-lambda',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-micro',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-azure-functions',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-cloud-functions',
+   *       identifier: 'gql',
+   *     },
+   *     {
+   *       name: 'apollo-server-cloudflare',
+   *       identifier: 'gql',
+   *     },
+   *   ];
+   * }
+   * ```
+   */
   modules?: Array<{ name: string; identifier?: string }>;
+  /**
+   * The magic comment anchor to look for when parsing GraphQL strings. Defaults to `graphql`.
+   */
   gqlMagicComment?: string;
+  /**
+   * Allows to use a global identifier instead of a module import.
+   * ```js
+   * // `graphql` is a global function
+   * export const usersQuery = graphql`
+   *   {
+   *     users {
+   *       id
+   *       name
+   *     }
+   *   }
+   * `;
+   * ```
+   */
   globalGqlIdentifierName?: string | string[];
 }
 
@@ -20,6 +109,15 @@ function parseWithVue(vueTemplateCompiler: typeof import('vue-template-compiler'
   return parsed.script ? parsed.script.content : '';
 }
 
+/**
+ * Asynchronously plucks GraphQL template literals from a single file.
+ *
+ * Supported file extensions include: `.js`, `.jsx`, `.ts`, `.tsx`, `.flow`, `.flow.js`, `.flow.jsx`, `.vue`
+ *
+ * @param filePath Path to the file containing the code. Required to detect the file type
+ * @param code The contents of the file being parsed.
+ * @param options Additional options for determining how a file is parsed.
+ */
 export const gqlPluckFromCodeString = async (
   filePath: string,
   code: string,
@@ -36,6 +134,15 @@ export const gqlPluckFromCodeString = async (
   return parseCode({ code, filePath, options });
 };
 
+/**
+ * Synchronously plucks GraphQL template literals from a single file
+ *
+ * Supported file extensions include: `.js`, `.jsx`, `.ts`, `.tsx`, `.flow`, `.flow.js`, `.flow.jsx`, `.vue`
+ *
+ * @param filePath Path to the file containing the code. Required to detect the file type
+ * @param code The contents of the file being parsed.
+ * @param options Additional options for determining how a file is parsed.
+ */
 export const gqlPluckFromCodeStringSync = (
   filePath: string,
   code: string,
@@ -85,7 +192,7 @@ function extractExtension(filePath: string) {
 
   if (fileExt) {
     if (!supportedExtensions.includes(fileExt)) {
-      throw TypeError(`Provided file type must be one of ${supportedExtensions.join(', ')}`);
+      throw TypeError(`Provided file type must be one of ${supportedExtensions.join(', ')} `);
     }
   }
 

packages/graphql-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-tools",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "Useful tools to create and manipulate GraphQL schemas.",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -19,26 +19,27 @@
     "directory": "dist"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "6.0.11",
-    "@graphql-tools/graphql-tag-pluck": "6.0.11",
-    "@graphql-tools/import": "6.0.11",
-    "@graphql-tools/links": "6.0.11",
-    "@graphql-tools/load": "6.0.11",
-    "@graphql-tools/code-file-loader": "6.0.11",
-    "@graphql-tools/git-loader": "6.0.11",
-    "@graphql-tools/github-loader": "6.0.11",
-    "@graphql-tools/graphql-file-loader": "6.0.11",
-    "@graphql-tools/json-file-loader": "6.0.11",
-    "@graphql-tools/module-loader": "6.0.11",
-    "@graphql-tools/url-loader": "6.0.11",
-    "@graphql-tools/load-files": "6.0.11",
-    "@graphql-tools/merge": "6.0.11",
-    "@graphql-tools/mock": "6.0.11",
-    "@graphql-tools/relay-operation-optimizer": "6.0.11",
-    "@graphql-tools/resolvers-composition": "6.0.11",
-    "@graphql-tools/schema": "6.0.11",
-    "@graphql-tools/stitch": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/wrap": "6.0.11"
+    "@graphql-tools/batch-delegate": "6.0.12",
+    "@graphql-tools/delegate": "6.0.12",
+    "@graphql-tools/graphql-tag-pluck": "6.0.12",
+    "@graphql-tools/import": "6.0.12",
+    "@graphql-tools/links": "6.0.12",
+    "@graphql-tools/load": "6.0.12",
+    "@graphql-tools/code-file-loader": "6.0.12",
+    "@graphql-tools/git-loader": "6.0.12",
+    "@graphql-tools/github-loader": "6.0.12",
+    "@graphql-tools/graphql-file-loader": "6.0.12",
+    "@graphql-tools/json-file-loader": "6.0.12",
+    "@graphql-tools/module-loader": "6.0.12",
+    "@graphql-tools/url-loader": "6.0.12",
+    "@graphql-tools/load-files": "6.0.12",
+    "@graphql-tools/merge": "6.0.12",
+    "@graphql-tools/mock": "6.0.12",
+    "@graphql-tools/relay-operation-optimizer": "6.0.12",
+    "@graphql-tools/resolvers-composition": "6.0.12",
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/stitch": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/wrap": "6.0.12"
   }
-}
+}

packages/graphql-tools/src/index.ts

@@ -1,3 +1,4 @@
+export * from '@graphql-tools/batch-delegate';
 export * from '@graphql-tools/delegate';
 export * from '@graphql-tools/graphql-tag-pluck';
 export * from '@graphql-tools/import';

packages/import/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/import",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",

packages/links/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/links",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -19,11 +19,11 @@
   },
   "devDependencies": {
     "@types/graphql-upload": "8.0.3",
-    "express-graphql": "0.9.0",
+    "express-graphql": "0.11.0",
     "graphql-upload": "11.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
     "apollo-link": "1.2.14",
     "apollo-upload-client": "13.0.0",
     "form-data": "3.0.0",

packages/links/tests/upload.test.ts

@@ -3,7 +3,7 @@ import { AddressInfo } from 'net';
 import { Readable } from 'stream';
 
 import express, { Express } from 'express';
-import graphqlHTTP from 'express-graphql';
+import { graphqlHTTP } from 'express-graphql';
 import { GraphQLUpload, graphqlUploadExpress } from 'graphql-upload';
 import FormData from 'form-data';
 import { fetch } from 'cross-fetch';

packages/load-files/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/load-files",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",

packages/load-files/src/index.ts

@@ -73,14 +73,25 @@ function extractExports(fileExport: any, exportNames: string[]): any | null {
   return fileExport;
 }
 
+/**
+ * Additional options for loading files
+ */
 export interface LoadFilesOptions {
+  // Extensions to explicitly ignore. Defaults to `['spec', 'test', 'd', 'map']`
   ignoredExtensions?: string[];
+  // Extensions to include when loading files. Defaults to `['gql', 'graphql', 'graphqls', 'ts', 'js']`
   extensions?: string[];
+  // Load files using `require` regardless of the file extension
   useRequire?: boolean;
+  // An alternative to `require` to use if `require` would be used to load a file
   requireMethod?: any;
+  // Additional options to pass to globby
   globOptions?: GlobbyOptions;
+  // Named exports to extract from each file. Defaults to ['typeDefs', 'schema']
   exportNames?: string[];
+  // Load files from nested directories. Set to `false` to only search the top-level directory.
   recursive?: boolean;
+  // Set to `true` to ignore files named `index.js` and `index.ts`
   ignoreIndex?: boolean;
 }
 
@@ -97,6 +108,11 @@ const LoadFilesDefaultOptions: LoadFilesOptions = {
   ignoreIndex: false,
 };
 
+/**
+ * Synchronously loads files using the provided glob pattern.
+ * @param pattern Glob pattern or patterns to use when loading files
+ * @param options Additional options
+ */
 export function loadFilesSync<T = any>(
   pattern: string | string[],
   options: LoadFilesOptions = LoadFilesDefaultOptions
@@ -188,6 +204,11 @@ const checkExtension = (
   return false;
 };
 
+/**
+ * Asynchronously loads files using the provided glob pattern.
+ * @param pattern Glob pattern or patterns to use when loading files
+ * @param options Additional options
+ */
 export async function loadFiles(
   pattern: string | string[],
   options: LoadFilesOptions = LoadFilesDefaultOptions

packages/load/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/load",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -18,16 +18,16 @@
   "devDependencies": {
     "@types/is-glob": "4.0.1",
     "@types/valid-url": "1.0.3",
-    "graphql-tag": "2.10.3",
+    "graphql-tag": "2.10.4",
     "graphql-type-json": "0.3.2"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/merge": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/merge": "6.0.12",
     "globby": "11.0.1",
     "import-from": "3.0.0",
     "is-glob": "4.0.1",
-    "p-limit": "3.0.1",
+    "p-limit": "3.0.2",
     "tslib": "~2.0.0",
     "unixify": "1.0.0",
     "valid-url": "1.0.9"

packages/load/src/documents.ts

@@ -2,21 +2,44 @@ import { Source } from '@graphql-tools/utils';
 import { Kind } from 'graphql';
 import { LoadTypedefsOptions, loadTypedefs, loadTypedefsSync, UnnormalizedTypeDefPointer } from './load-typedefs';
 
+/**
+ * Kinds of AST nodes that are included in executable documents
+ */
 export const OPERATION_KINDS = [Kind.OPERATION_DEFINITION, Kind.FRAGMENT_DEFINITION];
+
+/**
+ * Kinds of AST nodes that are included in type system definition documents
+ */
 export const NON_OPERATION_KINDS = Object.keys(Kind)
   .reduce((prev, v) => [...prev, Kind[v]], [])
   .filter(v => !OPERATION_KINDS.includes(v));
 
+/**
+ * Asynchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
 export function loadDocuments(
-  documentDef: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
+  pointerOrPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadTypedefsOptions
 ): Promise<Source[]> {
-  return loadTypedefs(documentDef, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
+  return loadTypedefs(pointerOrPointers, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
 }
 
+/**
+ * Synchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
 export function loadDocumentsSync(
-  documentDef: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
+  pointerOrPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadTypedefsOptions
 ): Source[] {
-  return loadTypedefsSync(documentDef, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
+  return loadTypedefsSync(pointerOrPointers, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
 }

packages/load/src/filter-document-kind.ts

@@ -1,6 +1,9 @@
 import { debugLog } from '@graphql-tools/utils';
 import { DocumentNode, DefinitionNode, Kind } from 'graphql';
 
+/**
+ * @internal
+ */
 export const filterKind = (content: DocumentNode, filterKinds: null | string[]) => {
   if (content && content.definitions && content.definitions.length && filterKinds && filterKinds.length > 0) {
     const invalidDefinitions: DefinitionNode[] = [];

packages/load/src/load-typedefs.ts

@@ -18,6 +18,13 @@ export type LoadTypedefsOptions<ExtraConfig = { [key: string]: any }> = SingleFi
 
 export type UnnormalizedTypeDefPointer = { [key: string]: any } | string;
 
+/**
+ * Asynchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
 export async function loadTypedefs<AdditionalConfig = Record<string, unknown>>(
   pointerOrPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadTypedefsOptions<Partial<AdditionalConfig>>
@@ -56,6 +63,13 @@ export async function loadTypedefs<AdditionalConfig = Record<string, unknown>>(
   return prepareResult({ options, pointerOptionMap, validSources });
 }
 
+/**
+ * Synchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
 export function loadTypedefsSync<AdditionalConfig = Record<string, unknown>>(
   pointerOrPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadTypedefsOptions<Partial<AdditionalConfig>>

packages/load/src/schema.ts

@@ -15,6 +15,11 @@ export type LoadSchemaOptions = BuildSchemaOptions &
     includeSources?: boolean;
   };
 
+/**
+ * Asynchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
 export async function loadSchema(
   schemaPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadSchemaOptions
@@ -40,6 +45,11 @@ export async function loadSchema(
   return schema;
 }
 
+/**
+ * Synchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
 export function loadSchemaSync(
   schemaPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[],
   options: LoadSchemaOptions

packages/loaders/apollo-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/apollo-engine-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,7 +16,7 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
     "cross-fetch": "3.0.5",
     "tslib": "~2.0.0"
   },

packages/loaders/apollo-engine/src/index.ts

@@ -2,6 +2,9 @@ import { SchemaLoader, Source, SingleFileOptions } from '@graphql-tools/utils';
 import { fetch } from 'cross-fetch';
 import { buildClientSchema } from 'graphql';
 
+/**
+ * Additional options for loading from Apollo Engine
+ */
 export interface ApolloEngineOptions extends SingleFileOptions {
   engine: {
     endpoint?: string;
@@ -14,6 +17,9 @@ export interface ApolloEngineOptions extends SingleFileOptions {
 
 const DEFAULT_APOLLO_ENDPOINT = 'https://engine-graphql.apollographql.com/api/graphql';
 
+/**
+ * This loader loads a schema from Apollo Engine
+ */
 export class ApolloEngineLoader implements SchemaLoader<ApolloEngineOptions> {
   loaderId() {
     return 'apollo-engine';
@@ -65,6 +71,9 @@ export class ApolloEngineLoader implements SchemaLoader<ApolloEngineOptions> {
   }
 }
 
+/**
+ * @internal
+ */
 export const SCHEMA_QUERY = /* GraphQL */ `
   query GetSchemaByTag($tag: String!, $id: ID!) {
     service(id: $id) {

packages/loaders/code-file/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/code-file-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,8 +16,8 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/graphql-tag-pluck": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/graphql-tag-pluck": "6.0.12",
     "fs-extra": "9.0.1",
     "tslib": "~2.0.0"
   },

packages/loaders/code-file/src/exports.ts

@@ -5,12 +5,18 @@ const identifiersToLookFor = ['default', 'schema', 'typeDefs', 'data'];
 
 // Pick exports
 
+/**
+ * @internal
+ */
 export function pickExportFromModule({ module, filepath }: { module: any; filepath: string }) {
   ensureModule({ module, filepath });
 
   return resolveModule(ensureExports({ module, filepath }));
 }
 
+/**
+ * @internal
+ */
 export function pickExportFromModuleSync({ module, filepath }: { module: any; filepath: string }) {
   ensureModule({ module, filepath });
 

packages/loaders/code-file/src/helpers.ts

@@ -1,5 +1,8 @@
 import { DocumentNode, IntrospectionQuery } from 'graphql';
 
+/**
+ * @internal
+ */
 export function pick<T>(obj: any, keys: string[]): T {
   for (const key of keys) {
     if (obj[key]) {
@@ -12,22 +15,34 @@ export function pick<T>(obj: any, keys: string[]): T {
 
 // checkers
 
+/**
+ * @internal
+ */
 export function isSchemaText(obj: any): obj is string {
   return typeof obj === 'string';
 }
 
+/**
+ * @internal
+ */
 export function isWrappedSchemaJson(obj: any): obj is { data: IntrospectionQuery } {
   const json = obj as { data: IntrospectionQuery };
 
   return json.data !== undefined && json.data.__schema !== undefined;
 }
 
+/**
+ * @internal
+ */
 export function isSchemaJson(obj: any): obj is IntrospectionQuery {
   const json = obj as IntrospectionQuery;
 
   return json !== undefined && json.__schema !== undefined;
 }
 
+/**
+ * @internal
+ */
 export function isSchemaAst(obj: any): obj is DocumentNode {
   return (obj as DocumentNode).kind !== undefined;
 }

packages/loaders/code-file/src/index.ts

@@ -21,6 +21,9 @@ import { isAbsolute, resolve } from 'path';
 import { readFileSync, readFile, pathExists, pathExistsSync } from 'fs-extra';
 import { cwd } from 'process';
 
+/**
+ * Additional options for loading from a code file
+ */
 export type CodeFileLoaderOptions = {
   require?: string | string[];
   pluckConfig?: GraphQLTagPluckOptions;
@@ -30,6 +33,20 @@ export type CodeFileLoaderOptions = {
 
 const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.vue'];
 
+/**
+ * This loader loads GraphQL documents and type definitions from code files
+ * using `graphql-tag-pluck`.
+ *
+ * ```js
+ * const documents = await loadDocuments('queries/*.js', {
+ *   loaders: [
+ *     new CodeFileLoader()
+ *   ]
+ * });
+ * ```
+ *
+ * Supported extensions include: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`
+ */
 export class CodeFileLoader implements UniversalLoader<CodeFileLoaderOptions> {
   loaderId(): string {
     return 'code-file';

packages/loaders/code-file/src/load-from-module.ts

@@ -1,6 +1,9 @@
 import { DocumentNode, GraphQLSchema } from 'graphql';
 import { pickExportFromModule, pickExportFromModuleSync } from './exports';
 
+/**
+ * @internal
+ */
 export async function tryToLoadFromExport(rawFilePath: string): Promise<GraphQLSchema | DocumentNode> {
   try {
     const filepath = ensureFilepath(rawFilePath);
@@ -13,6 +16,9 @@ export async function tryToLoadFromExport(rawFilePath: string): Promise<GraphQLS
   }
 }
 
+/**
+ * @internal
+ */
 export function tryToLoadFromExportSync(rawFilePath: string): GraphQLSchema | DocumentNode {
   try {
     const filepath = ensureFilepath(rawFilePath);
@@ -25,6 +31,9 @@ export function tryToLoadFromExportSync(rawFilePath: string): GraphQLSchema | Do
   }
 }
 
+/**
+ * @internal
+ */
 function ensureFilepath(filepath: string) {
   if (typeof require !== 'undefined' && require.cache) {
     filepath = require.resolve(filepath);

packages/loaders/git/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/git-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,9 +16,9 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/graphql-tag-pluck": "6.0.11",
-    "simple-git": "2.11.0"
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/graphql-tag-pluck": "6.0.12",
+    "simple-git": "2.12.0"
   },
   "buildOptions": {
     "external": [

packages/loaders/git/src/index.ts

@@ -27,10 +27,27 @@ function extractData(
   };
 }
 
-type GitLoaderOptions = SingleFileOptions & { pluckConfig: GraphQLTagPluckOptions };
+/**
+ * Additional options for loading from git
+ */
+export type GitLoaderOptions = SingleFileOptions & {
+  /**
+   * Additional options to pass to `graphql-tag-pluck`
+   */
+  pluckConfig: GraphQLTagPluckOptions;
+};
 
 const createInvalidExtensionError = (path: string) => new Error(`Invalid file extension: ${path}`);
 
+/**
+ * This loader loads a file from git.
+ *
+ * ```js
+ * const typeDefs = await loadTypedefs('git:someBranch:some/path/to/file.js', {
+ *   loaders: [new GitLoader()],
+ * })
+ * ```
+ */
 export class GitLoader implements UniversalLoader {
   loaderId() {
     return 'git-loader';

packages/loaders/git/src/load-git.ts

@@ -8,6 +8,9 @@ const createCommand = ({ ref, path }: Input) => {
   return [`${ref}:${path}`];
 };
 
+/**
+ * @internal
+ */
 export async function loadFromGit(input: Input): Promise<string | never> {
   try {
     const git = simplegit();
@@ -17,6 +20,9 @@ export async function loadFromGit(input: Input): Promise<string | never> {
   }
 }
 
+/**
+ * @internal
+ */
 export function loadFromGitSync(input: Input): string | never {
   try {
     const git = simplegitSync();

packages/loaders/git/src/parse.ts

@@ -1,5 +1,8 @@
 import { parseGraphQLSDL, parseGraphQLJSON, Source } from '@graphql-tools/utils';
 
+/**
+ * @internal
+ */
 export function parse<T>({
   path,
   pointer,

packages/loaders/github/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/github-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,8 +16,8 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/graphql-tag-pluck": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/graphql-tag-pluck": "6.0.12",
     "cross-fetch": "3.0.5"
   },
   "publishConfig": {

packages/loaders/github/src/index.ts

@@ -23,11 +23,30 @@ function extractData(
   };
 }
 
+/**
+ * Additional options for loading from GitHub
+ */
 export interface GithubLoaderOptions extends SingleFileOptions {
+  /**
+   * A GitHub access token
+   */
   token: string;
+  /**
+   * Additional options to pass to `graphql-tag-pluck`
+   */
   pluckConfig?: GraphQLTagPluckOptions;
 }
 
+/**
+ * This loader loads a file from GitHub.
+ *
+ * ```js
+ * const typeDefs = await loadTypedefs('github:githubUser/githubRepo#branchName:path/to/file.ts', {
+ *   loaders: [new GithubLoader()],
+ *   token: YOUR_GITHUB_TOKEN,
+ * })
+ * ```
+ */
 export class GithubLoader implements UniversalLoader<GithubLoaderOptions> {
   loaderId() {
     return 'github-loader';

packages/loaders/graphql-file/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/graphql-file-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -19,8 +19,8 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/import": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/import": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
     "fs-extra": "9.0.1",
     "tslib": "~2.0.0"
   },

packages/loaders/graphql-file/src/index.ts

@@ -14,7 +14,13 @@ import { processImport } from '@graphql-tools/import';
 
 const FILE_EXTENSIONS = ['.gql', '.gqls', '.graphql', '.graphqls'];
 
+/**
+ * Additional options for loading from a GraphQL file
+ */
 export interface GraphQLFileLoaderOptions extends SingleFileOptions {
+  /**
+   * Set to `true` to disable handling `#import` syntax
+   */
   skipGraphQLImport?: boolean;
 }
 
@@ -23,6 +29,29 @@ function isGraphQLImportFile(rawSDL: string) {
   return trimmedRawSDL.startsWith('# import') || trimmedRawSDL.startsWith('#import');
 }
 
+/**
+ * This loader loads documents and type definitions from `.graphql` files.
+ *
+ * You can load a single source:
+ *
+ * ```js
+ * const schema = await loadSchema('schema.graphql', {
+ *   loaders: [
+ *     new GraphQLFileLoader()
+ *   ]
+ * });
+ * ```
+ *
+ * Or provide a glob pattern to load multiple sources:
+ *
+ * ```js
+ * const schema = await loadSchema('graphql/*.graphql', {
+ *   loaders: [
+ *     new GraphQLFileLoader()
+ *   ]
+ * });
+ * ```
+ */
 export class GraphQLFileLoader implements UniversalLoader<GraphQLFileLoaderOptions> {
   loaderId(): string {
     return 'graphql-file';

packages/loaders/json-file/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/json-file-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,7 +16,7 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
     "fs-extra": "9.0.1",
     "tslib": "~2.0.0"
   },

packages/loaders/json-file/src/index.ts

@@ -12,8 +12,34 @@ import { cwd } from 'process';
 
 const FILE_EXTENSIONS = ['.json'];
 
+/**
+ * Additional options for loading from a JSON file
+ */
 export interface JsonFileLoaderOptions extends SingleFileOptions {}
 
+/**
+ * This loader loads documents and type definitions from JSON files.
+ *
+ * The JSON file can be the result of an introspection query made against a schema:
+ *
+ * ```js
+ * const schema = await loadSchema('schema-introspection.json', {
+ *   loaders: [
+ *     new JsonFileLoader()
+ *   ]
+ * });
+ * ```
+ *
+ * Or it can be a `DocumentNode` object representing a GraphQL document or type definitions:
+ *
+ * ```js
+ * const documents = await loadDocuments('queries/*.json', {
+ *   loaders: [
+ *     new GraphQLFileLoader()
+ *   ]
+ * });
+ * ```
+ */
 export class JsonFileLoader implements DocumentLoader {
   loaderId(): string {
     return 'json-file';

packages/loaders/module/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/module-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,7 +16,7 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
     "tslib": "~2.0.0"
   },
   "publishConfig": {

packages/loaders/module/src/index.ts

@@ -30,6 +30,15 @@ function extractData(
   };
 }
 
+/**
+ * * This loader loads documents and type definitions from a Node module
+ *
+ * ```js
+ * const schema = await loadSchema('module:someModuleName#someNamedExport', {
+ *   loaders: [new ModuleLoader()],
+ * })
+ * ```
+ */
 export class ModuleLoader implements UniversalLoader {
   loaderId() {
     return 'module-loader';

packages/loaders/prisma/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/prisma-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,8 +16,8 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/url-loader": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/url-loader": "6.0.12",
     "fs-extra": "9.0.1",
     "prisma-yml": "1.34.10",
     "tslib": "~2.0.0"

packages/loaders/prisma/src/index.ts

@@ -5,12 +5,18 @@ import { pathExists } from 'fs-extra';
 import { homedir } from 'os';
 import { cwd } from 'process';
 
-interface PrismaLoaderOptions extends LoadFromUrlOptions {
+/**
+ * additional options for loading from a `prisma.yml` file
+ */
+export interface PrismaLoaderOptions extends LoadFromUrlOptions {
   envVars?: { [key: string]: string };
   graceful?: boolean;
   cwd?: string;
 }
 
+/**
+ * This loader loads a schema from a `prisma.yml` file
+ */
 export class PrismaLoader extends UrlLoader {
   loaderId() {
     return 'prisma';

packages/loaders/url/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/url-loader",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -16,21 +16,21 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "devDependencies": {
-    "@types/express": "4.17.6",
+    "@types/express": "4.17.7",
     "@types/supertest": "2.0.10",
     "apollo-server-express": "2.15.1",
     "express": "4.17.1",
     "supertest": "4.0.2"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "6.0.11",
-    "@graphql-tools/wrap": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
-    "@types/websocket": "1.0.0",
+    "@graphql-tools/delegate": "6.0.12",
+    "@graphql-tools/wrap": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
+    "@types/websocket": "1.0.1",
     "cross-fetch": "3.0.5",
     "tslib": "~2.0.0",
     "valid-url": "1.0.9",
-    "subscriptions-transport-ws": "0.9.16",
+    "subscriptions-transport-ws": "0.9.17",
     "websocket": "1.0.31"
   },
   "publishConfig": {

packages/loaders/url/src/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-case-declarations */
 import { print, IntrospectionOptions, DocumentNode, GraphQLResolveInfo, Kind } from 'graphql';
 import {
   SchemaPointerSingle,
@@ -18,15 +19,50 @@ export type FetchFn = typeof import('cross-fetch').fetch;
 
 type Headers = Record<string, string> | Array<Record<string, string>>;
 
+/**
+ * Additional options for loading from a URL
+ */
 export interface LoadFromUrlOptions extends SingleFileOptions, Partial<IntrospectionOptions> {
+  /**
+   * Additional headers to include when querying the original schema
+   */
   headers?: Headers;
+  /**
+   * A custom `fetch` implementation to use when querying the original schema.
+   * Defaults to `cross-fetch`
+   */
   customFetch?: FetchFn | string;
+  /**
+   * HTTP method to use when querying the original schema.
+   */
   method?: 'GET' | 'POST';
+  /**
+   * Whether to enable subscriptions on the loaded schema
+   */
   enableSubscriptions?: boolean;
+  /**
+   * Custom WebSocket implementation used by the loaded schema if subscriptions
+   * are enabled
+   */
   webSocketImpl?: typeof w3cwebsocket | string;
+  /**
+   * Whether to use the GET HTTP method for queries when querying the original schema
+   */
   useGETForQueries?: boolean;
 }
 
+/**
+ * This loader loads a schema from a URL. The loaded schema is a fully-executable,
+ * remote schema since it's created using [@graphql-tools/wrap](remote-schemas).
+ *
+ * ```
+ * const schema = await loadSchema('http://localhost:3000/graphql', {
+ *   loaders: [
+ *     new UrlLoader(),
+ *   ]
+ * });
+ * ```
+ */
 export class UrlLoader implements DocumentLoader<LoadFromUrlOptions> {
   loaderId(): string {
     return 'url';
@@ -66,15 +102,31 @@ export class UrlLoader implements DocumentLoader<LoadFromUrlOptions> {
           }
         }
       }
-      const fetchResult = await fetch(HTTP_URL, {
-        method,
-        ...(method === 'POST'
-          ? {
-              body: JSON.stringify({ query: print(document), variables }),
-            }
-          : {}),
-        headers: extraHeaders,
-      });
+
+      let fetchResult: Response;
+      const query = print(document);
+      switch (method) {
+        case 'GET':
+          const urlObj = new URL(HTTP_URL);
+          urlObj.searchParams.set('query', query);
+          urlObj.searchParams.set(variables, JSON.stringify(variables));
+          const finalUrl = urlObj.toString();
+          fetchResult = await fetch(finalUrl, {
+            method: 'GET',
+            headers: extraHeaders,
+          });
+          break;
+        case 'POST':
+          fetchResult = await fetch(HTTP_URL, {
+            method: 'POST',
+            body: JSON.stringify({
+              query,
+              variables,
+            }),
+            headers: extraHeaders,
+          });
+          break;
+      }
       return fetchResult.json();
     };
   }

packages/merge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/merge",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -19,8 +19,8 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/schema": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
     "tslib": "~2.0.0"
   },
   "publishConfig": {

packages/merge/src/merge-resolvers.ts

@@ -3,10 +3,42 @@ import { IResolvers, mergeDeep } from '@graphql-tools/utils';
 export type ResolversFactory<TContext> = (...args: any[]) => IResolvers<any, TContext>;
 export type ResolversDefinition<TContext> = IResolvers<any, TContext> | ResolversFactory<TContext>;
 
+/**
+ * Additional options for merging resolvers
+ */
 export interface MergeResolversOptions {
   exclusions?: string[];
 }
 
+/**
+ * Deep merges multiple resolver definition objects into a single definition.
+ * @param resolversDefinitions Resolver definitions to be merged
+ * @param options Additional options
+ *
+ * ```js
+ * const { mergeResolvers } = require('@graphql-tools/merge');
+ * const clientResolver = require('./clientResolver');
+ * const productResolver = require('./productResolver');
+ *
+ * const resolvers = mergeResolvers([
+ *  clientResolver,
+ *  productResolver,
+ * ]);
+ * ```
+ *
+ * If you don't want to manually create the array of resolver objects, you can
+ * also use this function along with loadFiles:
+ *
+ * ```js
+ * const path = require('path');
+ * const { mergeResolvers } = require('@graphql-tools/merge');
+ * const { loadFilesSync } = require('@graphql-tools/load-files');
+ *
+ * const resolversArray = loadFilesSync(path.join(__dirname, './resolvers'));
+ *
+ * const resolvers = mergeResolvers(resolversArray)
+ * ```
+ */
 export function mergeResolvers<TContext, T extends ResolversDefinition<TContext>>(
   resolversDefinitions: T[],
   options?: MergeResolversOptions

packages/merge/src/merge-schemas.ts

@@ -11,12 +11,33 @@ import {
 } from '@graphql-tools/utils';
 import { mergeExtensions, extractExtensionsFromSchema, applyExtensions, SchemaExtensions } from './extensions';
 
+/**
+ * Configuration object for schema merging
+ */
 export interface MergeSchemasConfig<Resolvers extends IResolvers = IResolvers> extends Config, BuildSchemaOptions {
+  /**
+   * The schemas to be merged
+   */
   schemas: GraphQLSchema[];
+  /**
+   * Additional type definitions to also merge
+   */
   typeDefs?: (DocumentNode | string)[] | DocumentNode | string;
+  /**
+   * Additional resolvers to also merge
+   */
   resolvers?: Resolvers | Resolvers[];
+  /**
+   * Schema directives to apply to the type definitions being merged, if provided
+   */
   schemaDirectives?: { [directiveName: string]: typeof SchemaDirectiveVisitor };
+  /**
+   * Options to validate the resolvers being merged, if provided
+   */
   resolverValidationOptions?: IResolverValidationOptions;
+  /**
+   * Custom logger instance
+   */
   logger?: ILogger;
 }
 
@@ -28,6 +49,10 @@ const defaultResolverValidationOptions: Partial<IResolverValidationOptions> = {
   allowResolversNotInSchema: true,
 };
 
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
 export function mergeSchemas(config: MergeSchemasConfig) {
   const typeDefs = mergeTypes(config);
   const extractedResolvers: IResolvers<any, any>[] = [];
@@ -44,6 +69,10 @@ export function mergeSchemas(config: MergeSchemasConfig) {
   return makeSchema({ resolvers, typeDefs, extensions }, config);
 }
 
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
 export async function mergeSchemasAsync(config: MergeSchemasConfig) {
   const [typeDefs, resolvers, extensions] = await Promise.all([
     mergeTypes(config),

packages/merge/src/typedefs-mergers/merge-typedefs.ts

@@ -73,6 +73,10 @@ export function mergeGraphQLSchemas(
   return mergeGraphQLTypes(types, config);
 }
 
+/**
+ * Merges multiple type definitions into a single `DocumentNode`
+ * @param types The type definitions to be merged
+ */
 export function mergeTypeDefs(types: Array<string | Source | DocumentNode | GraphQLSchema>): DocumentNode;
 export function mergeTypeDefs(
   types: Array<string | Source | DocumentNode | GraphQLSchema>,

packages/mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/mock",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -18,8 +18,8 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/schema": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
     "tslib": "~2.0.0"
   },
   "devDependencies": {

packages/mock/src/mocking.ts

@@ -25,7 +25,16 @@ import { IMocks, IMockServer, IMockFn, IMockOptions, IMockTypeFn } from './types
 import { ITypeDefinitions, mapSchema, MapperKind } from '@graphql-tools/utils';
 
 /**
- * This function wraps addMocksToSchema for more convenience
+ * A convenience wrapper on top of addMocksToSchema. It adds your mock resolvers
+ * to your schema and returns a client that will correctly execute your query with
+ * variables. Note: when executing queries from the returned server, context and
+ * root will both equal `{}`.
+ * @param schema The schema to which to add mocks. This can also be a set of type
+ * definitions instead.
+ * @param mocks The mocks to add to the schema.
+ * @param preserveResolvers Set to `true` to prevent existing resolvers from being
+ * overwritten to provide mock data. This can be used to mock some parts of the
+ * server and not others.
  */
 export function mockServer(
   schema: GraphQLSchema | ITypeDefinitions,
@@ -64,6 +73,12 @@ defaultMockMap.set('ID', () => uuidv4());
 // TODO allow providing a seed such that lengths of list could be deterministic
 // this could be done by using casual to get a random list length if the casual
 // object is global.
+
+/**
+ * Given an instance of GraphQLSchema and a mock object, returns a new schema
+ * that can return mock data for any valid query that is sent to the server.
+ * @param options Options object
+ */
 export function addMocksToSchema({ schema, mocks = {}, preserveResolvers = false }: IMockOptions): GraphQLSchema {
   if (!schema) {
     throw new Error('Must provide schema to mock');
@@ -327,6 +342,9 @@ function mergeMocks(genericMockFunction: () => any, customMock: any): any {
   return customMock;
 }
 
+/**
+ * @internal
+ */
 export function isMockList(obj: any): obj is MockList {
   if (typeof obj?.len === 'number' || (Array.isArray(obj?.len) && typeof obj?.len[0] === 'number')) {
     if (typeof obj.wrappedFunction === 'undefined' || typeof obj.wrappedFunction === 'function') {
@@ -337,21 +355,33 @@ export function isMockList(obj: any): obj is MockList {
   return false;
 }
 
+/**
+ * This is an object you can return from your mock resolvers which calls the
+ * provided `mockFunction` once for each list item.
+ */
 export class MockList {
   private readonly len: number | Array<number>;
   private readonly wrappedFunction: GraphQLFieldResolver<any, any> | undefined;
 
-  // wrappedFunction can return another MockList or a value
-  constructor(len: number | Array<number>, wrappedFunction?: GraphQLFieldResolver<any, any>) {
-    this.len = len;
-    if (typeof wrappedFunction !== 'undefined') {
-      if (typeof wrappedFunction !== 'function') {
+  /**
+   * @param length Either the exact length of items to return or an inclusive
+   * range of possible lengths.
+   * @param mockFunction The function to call for each item in the list to
+   * resolve it. It can return another MockList or a value.
+   */
+  constructor(length: number | Array<number>, mockFunction?: GraphQLFieldResolver<any, any>) {
+    this.len = length;
+    if (typeof mockFunction !== 'undefined') {
+      if (typeof mockFunction !== 'function') {
         throw new Error('Second argument to MockList must be a function or undefined');
       }
-      this.wrappedFunction = wrappedFunction;
+      this.wrappedFunction = mockFunction;
     }
   }
 
+  /**
+   * @internal
+   */
   public mock(
     root: any,
     args: Record<string, any>,

packages/mock/src/types.ts

@@ -1,20 +1,40 @@
-import { GraphQLFieldResolver, GraphQLType, GraphQLSchema, ExecutionResult } from 'graphql';
+import { GraphQLFieldResolver, GraphQLType, GraphQLSchema } from 'graphql';
 
-/* XXX on mocks, args are optional, Not sure if a bug. */
+import { ExecutionResult } from '@graphql-tools/utils';
+
+// XXX on mocks, args are optional, Not sure if a bug.
 export type IMockFn = GraphQLFieldResolver<any, any>;
 
 export interface IMocks {
   [key: string]: IMockFn;
 }
 
+/**
+ * @internal
+ */
 export type IMockTypeFn = (type: GraphQLType, typeName?: string, fieldName?: string) => GraphQLFieldResolver<any, any>;
 
 export interface IMockOptions {
+  /**
+   * The schema to which to add mocks. This can also be a set of type definitions instead.
+   */
   schema?: GraphQLSchema;
+  /**
+   * The mocks to add to the schema.
+   */
   mocks?: IMocks;
+  /**
+   * Set to `true` to prevent existing resolvers from being overwritten to provide
+   * mock data. This can be used to mock some parts of the server and not others.
+   */
   preserveResolvers?: boolean;
 }
 
 export interface IMockServer {
+  /**
+   * Executes the provided query against the mocked schema.
+   * @param query GraphQL query to execute
+   * @param vars Variables
+   */
   query: (query: string, vars?: Record<string, any>) => Promise<ExecutionResult>;
 }

packages/node-require/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/node-require",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -18,8 +18,8 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/load": "6.0.11",
-    "@graphql-tools/graphql-file-loader": "6.0.11",
+    "@graphql-tools/load": "6.0.12",
+    "@graphql-tools/graphql-file-loader": "6.0.12",
     "tslib": "~2.0.0"
   },
   "publishConfig": {

packages/relay-operation-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/relay-operation-optimizer",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "Package for optimizing your GraphQL operations relay style.",
   "author": {
     "name": "Laurin Quast",
@@ -27,8 +27,8 @@
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "relay-compiler": "9.1.0"
+    "@graphql-tools/utils": "6.0.12",
+    "relay-compiler": "10.0.0"
   },
   "devDependencies": {
     "@types/relay-compiler": "8.0.0"

packages/resolvers-composition/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/resolvers-composition",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "Common package containting utils and types for GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "author": "Dotan Simha <dotansimha@gmail.com>",
@@ -19,8 +19,8 @@
     "@types/lodash": "4.14.157"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
-    "lodash": "4.17.15"
+    "@graphql-tools/utils": "6.0.12",
+    "lodash": "4.17.19"
   },
   "publishConfig": {
     "access": "public",

packages/schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/schema",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -21,7 +21,7 @@
     "input": "./src/index.ts"
   },
   "dependencies": {
-    "@graphql-tools/utils": "6.0.11",
+    "@graphql-tools/utils": "6.0.12",
     "tslib": "~2.0.0"
   },
   "publishConfig": {

packages/schema/src/makeExecutableSchema.ts

@@ -11,6 +11,50 @@ import { addErrorLoggingToSchema } from './addErrorLoggingToSchema';
 import { addCatchUndefinedToSchema } from './addCatchUndefinedToSchema';
 import { IExecutableSchemaDefinition } from './types';
 
+/**
+ * Builds a schema from the provided type definitions and resolvers.
+ *
+ * The type definitions are written using Schema Definition Language (SDL). They
+ * can be provided as a string, a `DocumentNode`, a function, or an array of any
+ * of these. If a function is provided, it will be passed no arguments and
+ * should return an array of strings or `DocumentNode`s.
+ *
+ * Note: You can use `graphql-tag` to not only parse a string into a
+ * `DocumentNode` but also to provide additinal syntax hightlighting in your
+ * editor (with the appropriate editor plugin).
+ *
+ * ```js
+ * const typeDefs = gql`
+ *   type Query {
+ *     posts: [Post]
+ *     author(id: Int!): Author
+ *   }
+ * `;
+ * ```
+ *
+ * The `resolvers` object should be a map of type names to nested object, which
+ * themselves map the type's fields to their appropriate resolvers.
+ * See the [Resolvers](resolvers) section of the documentation for more details.
+ *
+ * ```js
+ * const resolvers = {
+ *   Query: {
+ *     posts: (obj, args, ctx, info) => getAllPosts(),
+ *     author: (obj, args, ctx, info) => getAuthorById(args.id)
+ *   }
+ * };
+ * ```
+ *
+ * Once you've defined both the `typeDefs` and `resolvers`, you can create your
+ * schema:
+ *
+ * ```js
+ * const schema = makeExecutableSchema({
+ *   typeDefs,
+ *   resolvers,
+ * })
+ * ```
+ */
 export function makeExecutableSchema<TContext = any>({
   typeDefs,
   resolvers = {},

packages/schema/src/types.ts

@@ -13,16 +13,57 @@ export interface ILogger {
   log: (error: Error) => void;
 }
 
+/**
+ * Configuration object for creating an executable schema
+ */
 export interface IExecutableSchemaDefinition<TContext = any> {
+  /**
+   * The type definitions used to create the schema
+   */
   typeDefs: ITypeDefinitions;
+  /**
+   * Object describing the field resolvers for the provided type definitions
+   */
   resolvers?: IResolvers<any, TContext> | Array<IResolvers<any, TContext>>;
+  /**
+   * Logger instance used to print errors to the server console that are
+   * usually swallowed by GraphQL.
+   */
   logger?: ILogger;
+  /**
+   * Set to `false` to have resolvers throw an if they return undefined, which
+   * can help make debugging easier
+   */
   allowUndefinedInResolve?: boolean;
+  /**
+   * Additional options for validating the provided resolvers
+   */
   resolverValidationOptions?: IResolverValidationOptions;
+  /**
+   * Map of directive resolvers
+   */
   directiveResolvers?: IDirectiveResolvers<any, TContext>;
+  /**
+   * A map of schema directives used with the legacy class-based implementation
+   * of schema directives
+   */
   schemaDirectives?: Record<string, SchemaDirectiveVisitorClass>;
+  /**
+   * An array of schema transformation functions
+   */
   schemaTransforms?: Array<SchemaTransform>;
+  /**
+   * Additional options for parsing the type definitions if they are provided
+   * as a string
+   */
   parseOptions?: GraphQLParseOptions;
+  /**
+   * GraphQL object types that implement interfaces will inherit any missing
+   * resolvers from their interface types defined in the `resolvers` object
+   */
   inheritResolversFromInterfaces?: boolean;
+  /**
+   * Additional options for removing unused types from the schema
+   */
   pruningOptions?: PruneSchemaOptions;
 }

packages/schema/tests/resolution.test.ts

@@ -3,13 +3,14 @@ import {
   parse,
   graphql,
   subscribe,
-  ExecutionResult,
   graphqlSync,
 } from 'graphql';
 import { PubSub } from 'graphql-subscriptions';
 
 import { makeExecutableSchema, addSchemaLevelResolver } from '@graphql-tools/schema';
 
+import { ExecutionResult } from '@graphql-tools/utils';
+
 import { forAwaitEach } from './forAwaitEach';
 
 describe('Resolve', () => {

packages/schema/tests/schemaGenerator.test.ts

@@ -13,7 +13,6 @@ import {
   Kind,
   IntValueNode,
   parse,
-  ExecutionResult,
   GraphQLError,
   GraphQLEnumType,
   execute,
@@ -42,7 +41,8 @@ import {
   NextResolverFn,
   VisitSchemaKind,
   ITypeDefinitions,
-  visitSchema
+  visitSchema,
+  ExecutionResult
 } from '@graphql-tools/utils';
 
 import TypeA from './fixtures/circularSchemaA';

packages/stitch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/stitch",
-  "version": "6.0.11",
+  "version": "6.0.12",
   "description": "A set of utils for faster development of GraphQL tools",
   "repository": "git@github.com:ardatan/graphql-tools.git",
   "license": "MIT",
@@ -21,15 +21,16 @@
     "dataloader": "2.0.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "6.0.11",
-    "@graphql-tools/merge": "6.0.11",
-    "@graphql-tools/schema": "6.0.11",
-    "@graphql-tools/utils": "6.0.11",
-    "@graphql-tools/wrap": "6.0.11",
+    "@graphql-tools/batch-delegate": "6.0.12",
+    "@graphql-tools/delegate": "6.0.12",
+    "@graphql-tools/merge": "6.0.12",
+    "@graphql-tools/schema": "6.0.12",
+    "@graphql-tools/utils": "6.0.12",
+    "@graphql-tools/wrap": "6.0.12",
     "tslib": "~2.0.0"
   },
   "publishConfig": {
     "access": "public",
     "directory": "dist"
   }
-}
+}

packages/stitch/src/stitchingInfo.ts

@@ -21,6 +21,7 @@ import {
 } from '@graphql-tools/utils';
 
 import { delegateToSchema, isSubschemaConfig, SubschemaConfig } from '@graphql-tools/delegate';
+import { createBatchDelegateFn } from '@graphql-tools/batch-delegate';
 
 import { MergeTypeCandidate, MergedTypeInfo, StitchingInfo, MergeTypeFilter } from './types';
 
@@ -46,8 +47,9 @@ export function createStitchingInfo(
   return {
     transformedSchemas,
     fragmentsByField: undefined,
-    selectionSetsByField: undefined,
     selectionSetsByType,
+    selectionSetsByField: undefined,
+    dynamicSelectionSetsByField: undefined,
     mergedTypes,
   };
 }
@@ -103,25 +105,57 @@ function createMergedTypes(
           }
 
           if (!mergedTypeConfig.resolve) {
-            mergedTypeConfig.resolve = (originalResult, context, info, subschema, selectionSet) =>
-              delegateToSchema({
-                schema: subschema,
-                operation: 'query',
-                fieldName: mergedTypeConfig.fieldName,
-                returnType: getNamedType(info.returnType) as GraphQLOutputType,
-                args: mergedTypeConfig.args(originalResult),
-                selectionSet,
-                context,
-                info,
-                skipTypeMerging: true,
-              });
+            if (mergedTypeConfig.key != null) {
+              const batchDelegateToSubschema = createBatchDelegateFn(
+                mergedTypeConfig.args,
+                ({ schema, selectionSet, context, info }) => ({
+                  schema,
+                  operation: 'query',
+                  fieldName: mergedTypeConfig.fieldName,
+                  selectionSet,
+                  context,
+                  info,
+                  skipTypeMerging: true,
+                })
+              );
+
+              mergedTypeConfig.resolve = (originalResult, context, info, subschema, selectionSet) =>
+                batchDelegateToSubschema({
+                  key: mergedTypeConfig.key(originalResult),
+                  schema: subschema,
+                  context,
+                  info,
+                  selectionSet,
+                });
+            } else {
+              mergedTypeConfig.resolve = (originalResult, context, info, subschema, selectionSet) =>
+                delegateToSchema({
+                  schema: subschema,
+                  operation: 'query',
+                  fieldName: mergedTypeConfig.fieldName,
+                  returnType: getNamedType(info.returnType) as GraphQLOutputType,
+                  args: mergedTypeConfig.args(originalResult),
+                  selectionSet,
+                  context,
+                  info,
+                  skipTypeMerging: true,
+                });
+            }
           }
 
           subschemas.push(subschemaConfig);
         });
 
+        const targetSubschemas: Map<SubschemaConfig, Array<SubschemaConfig>> = new Map();
+        subschemas.forEach(subschema => {
+          const filteredSubschemas = subschemas.filter(s => s !== subschema);
+          if (filteredSubschemas.length) {
+            targetSubschemas.set(subschema, filteredSubschemas);
+          }
+        });
+
         mergedTypes[typeName] = {
-          subschemas,
+          targetSubschemas,
           typeMaps,
           requiredSelections,
           selectionSets,
@@ -161,6 +195,7 @@ function createMergedTypes(
 
 export function completeStitchingInfo(stitchingInfo: StitchingInfo, resolvers: IResolvers): StitchingInfo {
   const selectionSetsByField = Object.create(null);
+  const dynamicSelectionSetsByField = Object.create(null);
   const rawFragments: Array<{ field: string; fragment: string }> = [];
 
   Object.keys(resolvers).forEach(typeName => {
@@ -171,20 +206,32 @@ export function completeStitchingInfo(stitchingInfo: StitchingInfo, resolvers: I
     Object.keys(type).forEach(fieldName => {
       const field = type[fieldName] as IFieldResolverOptions;
       if (field.selectionSet) {
-        const selectionSet = parseSelectionSet(field.selectionSet);
-        if (!(typeName in selectionSetsByField)) {
-          selectionSetsByField[typeName] = Object.create(null);
-        }
+        if (typeof field.selectionSet === 'function') {
+          if (!(typeName in selectionSetsByField)) {
+            dynamicSelectionSetsByField[typeName] = Object.create(null);
+          }
+
+          if (!(fieldName in selectionSetsByField[typeName])) {
+            dynamicSelectionSetsByField[typeName][fieldName] = [];
+          }
 
-        if (!(fieldName in selectionSetsByField[typeName])) {
-          selectionSetsByField[typeName][fieldName] = {
-            kind: Kind.SELECTION_SET,
-            selections: [],
-          };
+          dynamicSelectionSetsByField[typeName][fieldName].push(field.selectionSet);
+        } else {
+          const selectionSet = parseSelectionSet(field.selectionSet);
+          if (!(typeName in selectionSetsByField)) {
+            selectionSetsByField[typeName] = Object.create(null);
+          }
+
+          if (!(fieldName in selectionSetsByField[typeName])) {
+            selectionSetsByField[typeName][fieldName] = {
+              kind: Kind.SELECTION_SET,
+              selections: [],
+            };
+          }
+          selectionSetsByField[typeName][fieldName].selections = selectionSetsByField[typeName][
+            fieldName
+          ].selections.concat(selectionSet.selections);
         }
-        selectionSetsByField[typeName][fieldName].selections = selectionSetsByField[typeName][
-          fieldName
-        ].selections.concat(selectionSet.selections);
       }
       if (field.fragment) {
         rawFragments.push({
@@ -221,6 +268,7 @@ export function completeStitchingInfo(stitchingInfo: StitchingInfo, resolvers: I
   });
 
   stitchingInfo.selectionSetsByField = selectionSetsByField;
+  stitchingInfo.dynamicSelectionSetsByField = dynamicSelectionSetsByField;
   stitchingInfo.fragmentsByField = fragmentsByField;
 
   return stitchingInfo;

packages/stitch/src/typeCandidates.ts

@@ -7,9 +7,9 @@ import {
   GraphQLDirective,
   ASTNode,
   isSchema,
-  isScalarType,
   SchemaDefinitionNode,
   SchemaExtensionNode,
+  isSpecifiedScalarType,
 } from 'graphql';
 
 import { wrapSchema } from '@graphql-tools/wrap';
@@ -204,7 +204,7 @@ export function buildTypeMap({
       typeName === operationTypeNames.query ||
       typeName === operationTypeNames.mutation ||
       typeName === operationTypeNames.subscription ||
-      (mergeTypes === true && !isScalarType(typeCandidates[typeName][0].type)) ||
+      (mergeTypes === true && !typeCandidates[typeName].some(candidate => isSpecifiedScalarType(candidate.type))) ||
       (typeof mergeTypes === 'function' && mergeTypes(typeCandidates[typeName], typeName)) ||
       (Array.isArray(mergeTypes) && mergeTypes.includes(typeName)) ||
       (stitchingInfo != null && typeName in stitchingInfo.mergedTypes)

packages/stitch/src/types.ts

@@ -5,6 +5,7 @@ import {
   DocumentNode,
   SelectionNode,
   InlineFragmentNode,
+  FieldNode,
 } from 'graphql';
 import { ITypeDefinitions, TypeMap } from '@graphql-tools/utils';
 import { SubschemaConfig } from '@graphql-tools/delegate';
@@ -20,7 +21,7 @@ export type MergeTypeCandidate = {
 export type MergeTypeFilter = (mergeTypeCandidates: Array<MergeTypeCandidate>, typeName: string) => boolean;
 
 export interface MergedTypeInfo {
-  subschemas: Array<SubschemaConfig>;
+  targetSubschemas: Map<SubschemaConfig, Array<SubschemaConfig>>;
   requiredSelections: Array<SelectionNode>;
   uniqueFields: Record<string, SubschemaConfig>;
   nonUniqueFields: Record<string, Array<SubschemaConfig>>;
@@ -32,8 +33,9 @@ export interface MergedTypeInfo {
 export interface StitchingInfo {
   transformedSchemas: Map<GraphQLSchema | SubschemaConfig, GraphQLSchema>;
   fragmentsByField: Record<string, Record<string, InlineFragmentNode>>;
-  selectionSetsByField: Record<string, Record<string, SelectionSetNode>>;
   selectionSetsByType: Record<string, SelectionSetNode>;
+  selectionSetsByField: Record<string, Record<string, SelectionSetNode>>;
+  dynamicSelectionSetsByField: Record<string, Record<string, Array<(node: FieldNode) => SelectionSetNode>>>;
   mergedTypes: Record<string, MergedTypeInfo>;
 }
 
@@ -65,6 +67,6 @@ export type OnTypeConflict = (
 declare module '@graphql-tools/utils' {
   interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
     fragment?: string;
-    selectionSet?: string;
+    selectionSet?: string | ((node: FieldNode) => SelectionSetNode);
   }
 }