WIP: Some other refactor

.changeset/brave-rats-march.md

@@ -0,0 +1,5 @@
+---
+'@graphql-tools/wrap': major
+---
+
+BREAKING - remove makeRemoteExecutableSchema

.eslintrc.json

@@ -61,7 +61,8 @@
     "packages/load/tests/loaders/schema",
     "website",
     "scripts",
-    "packages/loaders/code-file/tests/test-files"
+    "packages/loaders/code-file/tests/test-files",
+    "packages/loaders/git/tests/test-files"
   ],
   "globals":{
     "BigInt": true

.github/workflows/tests.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Lint
         run: yarn lint
   build:
-    name: Build on ${{matrix.os}} GraphQL v${{matrix.graphql_version}}
+    name: Type Check on GraphQL v${{matrix.graphql_version}}
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -55,9 +55,9 @@ jobs:
       - name: Install Dependencies using Yarn
         run: yarn install --ignore-engines && git checkout yarn.lock
       - name: Build
-        run: yarn ts:transpile
+        run: yarn ts:check
   test:
-    name: Test, Node ${{matrix.node_version}} and GraphQL v${{matrix.graphql_version}}
+    name: Unit Test on Node ${{matrix.node_version}} and GraphQL v${{matrix.graphql_version}}
     runs-on: ubuntu-latest
     strategy:
       matrix:

package.json

@@ -7,7 +7,8 @@
     "postinstall": "patch-package && husky install",
     "predeploy:website": "yarn build:api-docs",
     "deploy:website": "cd website && yarn deploy",
-    "ts:transpile": "concurrently \"tsc --project tsconfig.build.json\" \"tsc --project tsconfig.build.es5.json\"",
+    "ts:check": "tsc --noEmit --incremental",
+    "ts:transpile": "concurrently \"tsc --project tsconfig.build.json --incremental\" \"tsc --project tsconfig.build.es5.json --incremental\"",
     "clean-dist": "rimraf \"packages/**/dist\" && rimraf \"packages/**/dist-es5\" && rimraf \".bob\"",
     "build": "yarn ts:transpile && bob build",
     "build:api-docs": "node scripts/build-api-docs.js",

packages/batch-delegate/src/batchDelegateToSchema.ts

@@ -2,7 +2,7 @@ import { BatchDelegateOptions } from './types';
 
 import { getLoader } from './getLoader';
 
-export function batchDelegateToSchema(options: BatchDelegateOptions): any {
+export function batchDelegateToSchema<TContext = any>(options: BatchDelegateOptions<TContext>): any {
   const key = options.key;
   if (key == null) {
     return null;

packages/batch-delegate/tests/basic.example.test.ts

@@ -89,7 +89,7 @@ describe('batch delegation within basic stitching example', () => {
 
     expect(numCalls).toEqual(1);
     expect(result.errors).toBeUndefined();
-    expect(result.data!.trendingChirps[0].chirpedAtUser.email).not.toBe(null);
+    expect(result.data!['trendingChirps'][0].chirpedAtUser.email).not.toBe(null);
   });
 
   test('works with key arrays', async () => {

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

@@ -84,7 +84,7 @@ describe('merging using type merging', () => {
       Query: {
         mostStockedProduct: () => inventory.find(i => i.upc === '3'),
         _products: (_root, { representations }) => {
-          return representations.map((rep: Record<string, any>) => ({ ...rep, ...inventory.find(i => i.upc === rep.upc) }));
+          return representations.map((rep: Record<string, any>) => ({ ...rep, ...inventory.find(i => i.upc === rep['upc']) }));
         },
       },
     },

packages/batch-delegate/tests/withTransforms.test.ts

@@ -73,7 +73,7 @@ describe('works with complex transforms', () => {
         ]
       }),
       resultTransformer: (results, delegationContext) => {
-        const userIds = delegationContext.args.userIds;
+        const userIds = delegationContext.args['userIds'];
         const booksByUserIds = results.reduce(
           (acc: any, { userId, books }: { userId: string, books: any[] }) => {
             acc[userId] = books

packages/batch-execute/src/createBatchingExecutor.ts

@@ -51,20 +51,18 @@ function createLoadFn(
       }
     }
 
-    const executionResults: Array<ValueOrPromise<ExecutionResult>> = [];
-    execBatches.forEach(execBatch => {
+    const executionResults: Array<ValueOrPromise<ExecutionResult>> = execBatches.map(execBatch => {
       const mergedExecutionParams = mergeExecutionParams(execBatch, extensionsReducer);
-      executionResults.push(new ValueOrPromise(() => executor(mergedExecutionParams)));
+      return new ValueOrPromise(() => executor(mergedExecutionParams));
     });
 
     return ValueOrPromise.all(executionResults)
-      .then(resultBatches => {
-        let results: Array<ExecutionResult> = [];
-        resultBatches.forEach((resultBatch, index) => {
-          results = [...results, ...splitResult(resultBatch!, execBatches[index].length)];
-        });
-        return results;
-      })
+      .then(resultBatches =>
+        resultBatches.reduce(
+          (results, resultBatch, index) => results.concat(splitResult(resultBatch, execBatches[index].length)),
+          new Array<ExecutionResult<Record<string, any>>>()
+        )
+      )
       .resolve();
   };
 }

packages/batch-execute/src/mergeExecutionParams.ts

@@ -68,22 +68,25 @@ export function mergeExecutionParams(
 
   let operation: Maybe<OperationTypeNode>;
 
-  execs.forEach((executionParams, index) => {
+  for (const index in execs) {
+    const executionParams = execs[index];
     const prefixedExecutionParams = prefixExecutionParams(createPrefix(index), executionParams);
 
-    prefixedExecutionParams.document.definitions.forEach(def => {
+    for (const def of prefixedExecutionParams.document.definitions) {
       if (isOperationDefinition(def)) {
         operation = def.operation;
         mergedSelections.push(...def.selectionSet.selections);
-        mergedVariableDefinitions.push(...(def.variableDefinitions ?? []));
+        if (def.variableDefinitions) {
+          mergedVariableDefinitions.push(...def.variableDefinitions);
+        }
       }
       if (isFragmentDefinition(def)) {
         mergedFragmentDefinitions.push(def);
       }
-    });
+    }
     Object.assign(mergedVariables, prefixedExecutionParams.variables);
     mergedExtensions = extensionsReducer(mergedExtensions, executionParams);
-  });
+  }
 
   if (operation == null) {
     throw new Error('Could not identify operation type. Did the document only include fragment definitions?');

packages/batch-execute/src/prefix.ts

@@ -1,6 +1,6 @@
 // adapted from https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby-source-graphql/src/batching/merge-queries.js
 
-export function createPrefix(index: number): string {
+export function createPrefix(index: string): string {
   return `graphqlTools${index}_`;
 }
 

packages/batch-execute/src/splitResult.ts

@@ -9,60 +9,41 @@ import { parseKey } from './prefix';
 /**
  * Split and transform result of the query produced by the `merge` function
  */
-export function splitResult(mergedResult: ExecutionResult, numResults: number): Array<ExecutionResult> {
+export function splitResult({ data, errors }: ExecutionResult, numResults: number): Array<ExecutionResult> {
   const splitResults: Array<ExecutionResult> = [];
   for (let i = 0; i < numResults; i++) {
     splitResults.push({});
   }
 
-  const data = mergedResult.data;
   if (data) {
-    Object.keys(data).forEach(prefixedKey => {
+    for (const prefixedKey in data) {
       const parsedKey = parseKey(prefixedKey);
       assertSome(parsedKey, "'parsedKey' should not be null.");
       const { index, originalKey } = parsedKey;
       const result = splitResults[index];
       if (result == null) {
-        return;
+        continue;
       }
       if (result.data == null) {
         result.data = { [originalKey]: data[prefixedKey] };
       } else {
         result.data[originalKey] = data[prefixedKey];
       }
-    });
+    }
   }
 
-  const errors = mergedResult.errors;
   if (errors) {
-    const newErrors: Record<string, Array<GraphQLError>> = Object.create(null);
-    errors.forEach(error => {
+    for (const error of errors) {
       if (error.path) {
         const parsedKey = parseKey(error.path[0] as string);
         if (parsedKey) {
           const { index, originalKey } = parsedKey;
           const newError = relocatedError(error, [originalKey, ...error.path.slice(1)]);
-          if (!newErrors[index]) {
-            newErrors[index] = [newError];
-          } else {
-            newErrors[index].push(newError);
-          }
-          return;
+          const errors = (splitResults[index].errors = (splitResults[index].errors || []) as GraphQLError[]);
+          errors.push(newError);
         }
       }
-
-      splitResults.forEach((_splitResult, index) => {
-        if (!newErrors[index]) {
-          newErrors[index] = [error];
-        } else {
-          newErrors[index].push(error);
-        }
-      });
-    });
-
-    Object.keys(newErrors).forEach(index => {
-      splitResults[index].errors = newErrors[index];
-    });
+    }
   }
 
   return splitResults;

packages/delegate/src/Transformer.ts

@@ -16,7 +16,9 @@ export class Transformer<TContext = Record<string, any>> {
   constructor(context: DelegationContext<TContext>, binding: DelegationBinding<TContext> = defaultDelegationBinding) {
     this.delegationContext = context;
     const delegationTransforms: Array<Transform> = binding(this.delegationContext);
-    delegationTransforms.forEach(transform => this.addTransform(transform, {}));
+    for (const transform of delegationTransforms) {
+      this.addTransform(transform, {});
+    }
   }
 
   private addTransform(transform: Transform, context = {}) {

packages/delegate/src/createRequest.ts

@@ -10,7 +10,6 @@ import {
   typeFromAST,
   NamedTypeNode,
   GraphQLInputType,
-  GraphQLArgument,
   VariableDefinitionNode,
   SelectionSetNode,
   DefinitionNode,
@@ -107,15 +106,15 @@ export function createRequest({
   const variableDefinitionMap = Object.create(null);
 
   if (sourceSchema != null && variableDefinitions != null) {
-    variableDefinitions.forEach(def => {
+    for (const def of variableDefinitions) {
       const varName = def.variable.name.value;
       variableDefinitionMap[varName] = def;
       const varType = typeFromAST(sourceSchema, def.type as NamedTypeNode) as GraphQLInputType;
       const serializedValue = serializeInputValue(varType, variableValues?.[varName]);
       if (serializedValue !== undefined) {
         newVariables[varName] = serializedValue;
       }
-    });
+    }
   }
 
   if (sourceParentType != null && sourceFieldName != null) {
@@ -130,7 +129,7 @@ export function createRequest({
 
   const rootfieldNode: FieldNode = {
     kind: Kind.FIELD,
-    arguments: Object.keys(argumentNodeMap).map(argName => argumentNodeMap[argName]),
+    arguments: Object.values(argumentNodeMap),
     name: {
       kind: Kind.NAME,
       value:
@@ -152,17 +151,17 @@ export function createRequest({
     kind: Kind.OPERATION_DEFINITION,
     name: operationName,
     operation: targetOperation,
-    variableDefinitions: Object.keys(variableDefinitionMap).map(varName => variableDefinitionMap[varName]),
+    variableDefinitions: Object.values(variableDefinitionMap),
     selectionSet: {
       kind: Kind.SELECTION_SET,
       selections: [rootfieldNode],
     },
   };
 
-  let definitions: Array<DefinitionNode> = [operationDefinition];
+  const definitions: Array<DefinitionNode> = [operationDefinition];
 
   if (fragments != null) {
-    definitions = definitions.concat(Object.keys(fragments).map(fragmentName => fragments[fragmentName]));
+    definitions.push(...Object.values(fragments));
   }
 
   const document: DocumentNode = {
@@ -184,7 +183,7 @@ function updateArgumentsWithDefaults(
   variableValues: Record<string, any>
 ): void {
   const sourceField = sourceParentType.getFields()[sourceFieldName];
-  sourceField.args.forEach((argument: GraphQLArgument) => {
+  for (const argument of sourceField.args) {
     const argName = argument.name;
     const sourceArgType = argument.type;
 
@@ -202,5 +201,5 @@ function updateArgumentsWithDefaults(
         );
       }
     }
-  });
+  }
 }

packages/delegate/src/externalObjects.ts

@@ -41,7 +41,8 @@ export function mergeExternalObjects(
   const results: Array<any> = [];
   let errors: Array<GraphQLError> = [];
 
-  sources.forEach((source, index) => {
+  for (const index in sources) {
+    const source = sources[index];
     if (source instanceof Error || source === null) {
       const selectionSet = selectionSets[index];
       const fieldNodes = collectFields(
@@ -56,39 +57,32 @@ export function mergeExternalObjects(
         Object.create(null)
       );
       const nullResult = {};
-      Object.keys(fieldNodes).forEach(responseKey => {
+      for (const responseKey in fieldNodes) {
         if (source instanceof GraphQLError) {
           nullResult[responseKey] = relocatedError(source, path.concat([responseKey]));
         } else if (source instanceof Error) {
           nullResult[responseKey] = locatedError(source, fieldNodes[responseKey], path.concat([responseKey]));
         } else {
           nullResult[responseKey] = null;
         }
-      });
+      }
       results.push(nullResult);
     } else {
       errors = errors.concat(source[UNPATHED_ERRORS_SYMBOL]);
       results.push(source);
     }
-  });
+  }
 
   const combinedResult: ExternalObject = results.reduce(mergeDeep, target);
 
-  const newFieldSubschemaMap = target[FIELD_SUBSCHEMA_MAP_SYMBOL] ?? Object.create(null);
-
-  results.forEach((source: ExternalObject) => {
+  const newFieldSubschemaMap = results.reduce((newFieldSubschemaMap, source) => {
     const objectSubschema = source[OBJECT_SUBSCHEMA_SYMBOL];
     const fieldSubschemaMap = source[FIELD_SUBSCHEMA_MAP_SYMBOL];
-    if (fieldSubschemaMap === undefined) {
-      Object.keys(source).forEach(responseKey => {
-        newFieldSubschemaMap[responseKey] = objectSubschema;
-      });
-    } else {
-      Object.keys(source).forEach(responseKey => {
-        newFieldSubschemaMap[responseKey] = fieldSubschemaMap[responseKey] ?? objectSubschema;
-      });
+    for (const responseKey in source) {
+      newFieldSubschemaMap[responseKey] = fieldSubschemaMap?.[responseKey] ?? objectSubschema;
     }
-  });
+    return newFieldSubschemaMap;
+  }, target[FIELD_SUBSCHEMA_MAP_SYMBOL] ?? Object.create(null));
 
   combinedResult[FIELD_SUBSCHEMA_MAP_SYMBOL] = newFieldSubschemaMap;
   combinedResult[OBJECT_SUBSCHEMA_SYMBOL] = target[OBJECT_SUBSCHEMA_SYMBOL];