Introduce batch delegation

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,16 +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 } from 'graphql';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
-
 import { ExecutionResult } from '@graphql-tools/utils';
-
-import { stitchSchemas } from '../src/stitchSchemas';
+import { stitchSchemas } from '@graphql-tools/stitch';
 
 describe('merging using type merging', () => {
-
   const users = [
     {
       id: '1',
@@ -31,6 +31,7 @@ describe('merging using type merging', () => {
       type Query {
         me: User
         _userById(id: ID!): User
+        _usersById(ids: [ID!]!): [User]
       }
       type User {
         id: ID!
@@ -42,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)),
       },
     },
   });
@@ -111,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!
@@ -123,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)),
       }
     },
   });
@@ -179,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: {
@@ -201,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 })),
       },
     }
   });
@@ -212,8 +220,8 @@ describe('merging using type merging', () => {
         schema: accountsSchema,
         merge: {
           User: {
-            fieldName: '_userById',
             selectionSet: '{ id }',
+            fieldName: '_userById',
             args: ({ id }) => ({ id })
           }
         }
@@ -222,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 }),
           }
         }
@@ -232,8 +240,8 @@ describe('merging using type merging', () => {
         schema: productsSchema,
         merge: {
           Product: {
-            fieldName: '_productByUpc',
             selectionSet: '{ upc }',
+            fieldName: '_productByUpc',
             args: ({ upc }) => ({ upc }),
           }
         }
@@ -242,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/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,