feat(execution): add experimental schema batch resolver

Add schema-level batch resolution so a GraphQLSchema can handle pending object
field batches across object types before object-level and field-level batch
resolvers run. This gives schema owners a single place to route batches to a
global loader or execution planner.

Schema-level API shape:

    GraphQLSchemaConfig {
      experimentalBatchResolve?: GraphQLSchemaBatchResolver<TContext>;
    }

Relevant public types:

    GraphQLSchemaBatchResolver<TContext>
    GraphQLSchemaBatchInfo
    GraphQLSchemaBatchResolveInfo
    GraphQLObjectBatchFieldInfo

Example schema batch resolver:

    const resolveSchemaBatch: GraphQLSchemaBatchResolver<Context> =
      async (batches, context, info) => {
        const result = new Map<
          GraphQLObjectBatchFieldInfo,
          ReadonlyArray<unknown>
        >();

        for (const batch of batches) {
          if (batch.parentType.name !== 'User') {
            continue;
          }

          const rows = await context.users.loadMany(
            batch.sources.map((source) => source.id),
          );

          for (const field of batch.fields) {
            if (field.fieldName === 'name') {
              result.set(field, rows.map((row) => row.name));
            } else if (field.fieldName === 'email') {
              result.set(field, rows.map((row) => row.email));
            }
          }
        }

        return result;
      };

    const schema = new GraphQLSchema({
      query: QueryType,
      experimentalBatchResolve: resolveSchemaBatch,
    });

Each GraphQLSchemaBatchInfo groups one parent object type, its sources, and the
field batches pending for those sources. The returned Map uses the field info
objects as keys and arrays of values in source order.

Author: yaacovCR

benchmark/batch-resolution-benchmark.js

@@ -10,8 +10,35 @@ import {
 
 const WidgetType = new GraphQLObjectType({
   name: 'Widget',
+  experimentalBatchResolve: async (sources, fields) => {
+    await Promise.resolve();
+    const result = new Map();
+    for (const field of fields) {
+      if (field.fieldName === 'color') {
+        result.set(
+          field,
+          sources.map((source) => source.color),
+        );
+      }
+    }
+    return result;
+  },
   fields: () => ({
     id: { type: GraphQLID },
+    label: {
+      type: GraphQLID,
+      experimentalBatchResolve: async (sources) => {
+        await Promise.resolve();
+        return sources.map((source) => source.label);
+      },
+    },
+    color: {
+      type: GraphQLID,
+      experimentalBatchResolve: async (sources) => {
+        await Promise.resolve();
+        return sources.map((source) => source.color);
+      },
+    },
     widget: {
       type: WidgetType,
       experimentalBatchResolve: async (sources) => {
@@ -34,18 +61,45 @@ const QueryType = new GraphQLObjectType({
   },
 });
 
-const schema = new GraphQLSchema({ query: QueryType });
+const schema = new GraphQLSchema({
+  query: QueryType,
+  experimentalBatchResolve: async (batches) => {
+    await Promise.resolve();
+    const result = new Map();
+    for (const batch of batches) {
+      for (const field of batch.fields) {
+        switch (field.fieldName) {
+          case 'label':
+            result.set(
+              field,
+              batch.sources.map((source) => source.label),
+            );
+            break;
+        }
+      }
+    }
+    return result;
+  },
+});
 
 const rootValue = {
   widgets: Array.from({ length: 10000 }, () => ({
     id: 'gid://owner/Widget/1',
-    widget: { id: 'gid://owner/Widget/1' },
+    label: 'Widget 1',
+    color: 'blue',
+    widget: {
+      id: 'gid://owner/Widget/1',
+      label: 'Nested Widget 1',
+      color: 'green',
+    },
   })),
 };
-const document = parse(`{ widgets(first: 10000) { id widget { id } } }`);
+const document = parse(
+  `{ widgets(first: 10000) { id label color widget { id label color } } }`,
+);
 
 export const benchmark = {
-  name: 'Execute Batch Resolved Widget Field',
+  name: 'Execute Schema and Object Batch Resolved Widget Fields',
   measure: () =>
     execute({
       schema,