refactor(endpoint): no longer necessary

BREAKING CHANGE: batching is now performed (when enabled) for all subschema config objects with identical executors, removing the need for the endpoint abstraction

Author: yaacovCR

packages/delegate/src/Subschema.ts

@@ -7,8 +7,7 @@ import {
   CreateProxyingResolverFn,
   Subscriber,
   Executor,
-  Endpoint,
-  EndpointBatchingOptions,
+  BatchingOptions,
 } from './types';
 
 import { applySchemaTransforms } from './applySchemaTransforms';
@@ -28,8 +27,7 @@ export class Subschema<K = any, V = any, C = K> implements ISubschema {
   public executor?: Executor;
   public subscriber?: Subscriber;
   public batch?: boolean;
-  public batchingOptions?: EndpointBatchingOptions<K, V, C>;
-  public endpoint?: Endpoint;
+  public batchingOptions?: BatchingOptions<K, V, C>;
 
   public createProxyingResolver?: CreateProxyingResolverFn;
   public transforms: Array<Transform>;
@@ -45,7 +43,6 @@ export class Subschema<K = any, V = any, C = K> implements ISubschema {
     this.subscriber = config.subscriber;
     this.batch = config.batch;
     this.batchingOptions = config.batchingOptions;
-    this.endpoint = config.endpoint;
 
     this.createProxyingResolver = config.createProxyingResolver;
     this.transforms = config.transforms ?? [];

packages/delegate/src/delegateToSchema.ts

@@ -117,7 +117,7 @@ export function delegateRequest({
     targetFieldName = fieldName;
   }
 
-  const { targetSchema, targetRootValue, subschemaConfig, endpoint, allTransforms } = collectTargetParameters(
+  const { targetSchema, targetRootValue, subschemaConfig, allTransforms } = collectTargetParameters(
     subschemaOrSubschemaConfig,
     rootValue,
     info,
@@ -149,14 +149,15 @@ export function delegateRequest({
 
   if (targetOperation === 'query' || targetOperation === 'mutation') {
     let executor: Executor =
-      endpoint?.executor || createDefaultExecutor(targetSchema, subschemaConfig?.rootValue || targetRootValue);
+      subschemaConfig?.executor || createDefaultExecutor(targetSchema, subschemaConfig?.rootValue || targetRootValue);
 
-    if (endpoint?.batch) {
+    if (subschemaConfig?.batch) {
+      const batchingOptions = subschemaConfig?.batchingOptions;
       executor = getBatchingExecutor(
         context,
         executor,
-        endpoint?.batchingOptions?.dataLoaderOptions,
-        endpoint?.batchingOptions?.extensionsReducer
+        batchingOptions?.dataLoaderOptions,
+        batchingOptions?.extensionsReducer
       );
     }
 
@@ -175,7 +176,7 @@ export function delegateRequest({
   }
 
   const subscriber =
-    endpoint?.subscriber || createDefaultSubscriber(targetSchema, subschemaConfig?.rootValue || targetRootValue);
+    subschemaConfig?.subscriber || createDefaultSubscriber(targetSchema, subschemaConfig?.rootValue || targetRootValue);
 
   return subscriber({
     ...processedRequest,
@@ -218,7 +219,6 @@ function collectTargetParameters(
       targetSchema: subschemaOrSubschemaConfig.schema,
       targetRootValue: rootValue ?? subschemaOrSubschemaConfig?.rootValue ?? info?.rootValue ?? emptyObject,
       subschemaConfig: subschemaOrSubschemaConfig,
-      endpoint: subschemaOrSubschemaConfig.endpoint ?? subschemaOrSubschemaConfig,
       allTransforms:
         subschemaOrSubschemaConfig.transforms != null
           ? subschemaOrSubschemaConfig.transforms.concat(transforms)

packages/delegate/src/types.ts

@@ -150,28 +150,21 @@ export interface ICreateProxyingResolverOptions {
 
 export type CreateProxyingResolverFn = (options: ICreateProxyingResolverOptions) => GraphQLFieldResolver<any, any>;
 
-export interface Endpoint<K = any, V = any, C = K> {
-  rootValue?: Record<string, any>;
-  executor?: Executor;
-  subscriber?: Subscriber;
-  batch?: boolean;
-  batchingOptions?: EndpointBatchingOptions<K, V, C>;
-}
-
-export interface EndpointBatchingOptions<K = any, V = any, C = K> {
+export interface BatchingOptions<K = any, V = any, C = K> {
   extensionsReducer?: (mergedExtensions: Record<string, any>, executionParams: ExecutionParams) => Record<string, any>;
   dataLoaderOptions?: DataLoader.Options<K, V, C>;
 }
 
-export interface SubschemaPermutation {
+export interface SubschemaConfig<K = any, V = any, C = K> {
+  schema: GraphQLSchema;
   createProxyingResolver?: CreateProxyingResolverFn;
   transforms?: Array<Transform>;
   merge?: Record<string, MergedTypeConfig>;
-}
-
-export interface SubschemaConfig<K = any, V = any, C = K> extends SubschemaPermutation, Endpoint<K, V, C> {
-  schema: GraphQLSchema;
-  endpoint?: Endpoint;
+  rootValue?: Record<string, any>;
+  executor?: Executor;
+  subscriber?: Subscriber;
+  batch?: boolean;
+  batchingOptions?: BatchingOptions<K, V, C>;
 }
 
 export interface MergedTypeConfig<K = any, V = any> {

packages/delegate/tests/batchExecution.test.ts

@@ -1,7 +1,7 @@
 import { graphql, execute, ExecutionResult } from 'graphql';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import { delegateToSchema, SubschemaConfig, ExecutionParams, SyncExecutor, Endpoint } from '../src';
+import { delegateToSchema, SubschemaConfig, ExecutionParams, SyncExecutor, Executor } from '../src';
 import { stitchSchemas } from '@graphql-tools/stitch';
 import { FilterObjectFields } from '@graphql-tools/wrap';
 
@@ -61,7 +61,7 @@ describe('batch execution', () => {
     expect(executions).toEqual(1);
   });
 
-  it('should share batching dataloader between subschemas when using a common endpoint', async () => {
+  it('should share batching dataloader between subschemas when using a common executor', async () => {
     const innerSchemaA = makeExecutableSchema({
       typeDefs: `
         type Object {
@@ -104,13 +104,10 @@ describe('batch execution', () => {
 
     let executions = 0;
 
-    const endpoint: Endpoint = {
-      batch: true,
-      executor: ((params: ExecutionParams): ExecutionResult => {
-        executions++;
-        return execute(innerSchemaA, params.document, undefined, params.context, params.variables) as ExecutionResult;
-      }) as SyncExecutor
-    };
+    const executor = ((params: ExecutionParams): ExecutionResult => {
+      executions++;
+      return execute(innerSchemaA, params.document, undefined, params.context, params.variables) as ExecutionResult;
+    }) as Executor;
 
     const innerSubschemaConfigA: Array<SubschemaConfig> = [{
       schema: innerSchemaA,
@@ -121,7 +118,8 @@ describe('batch execution', () => {
           args: () => ({}),
         },
       },
-      endpoint,
+      batch: true,
+      executor,
     }, {
       schema: innerSchemaA,
       transforms: [new FilterObjectFields((typeName, fieldName) => typeName !== 'Object' || fieldName !== 'field1')],
@@ -131,7 +129,8 @@ describe('batch execution', () => {
           args: () => ({}),
         },
       },
-      endpoint,
+      batch: true,
+      executor,
     }];
 
     const innerSubschemaConfigB: SubschemaConfig = {

packages/stitch/src/isolateComputedFields.ts

@@ -46,16 +46,9 @@ export function isolateComputedFields(subschemaConfig: SubschemaConfig): Array<S
   });
 
   if (Object.keys(isolatedSchemaTypes).length) {
-    const endpoint = subschemaConfig.endpoint ?? {
-      rootValue: subschemaConfig.rootValue,
-      executor: subschemaConfig.executor,
-      subscriber: subschemaConfig.subscriber,
-      batch: subschemaConfig.batch,
-      batchingOptions: subschemaConfig.batchingOptions,
-    };
     return [
-      filterBaseSubschema({ ...subschemaConfig, endpoint, merge: baseSchemaTypes }, isolatedSchemaTypes),
-      filterIsolatedSubschema({ ...subschemaConfig, endpoint, merge: isolatedSchemaTypes }),
+      filterBaseSubschema({ ...subschemaConfig, merge: baseSchemaTypes }, isolatedSchemaTypes),
+      filterIsolatedSubschema({ ...subschemaConfig, merge: isolatedSchemaTypes }),
     ];
   }