feat: compile operations

Add a compiled execution path for validated operations and subscriptions.

Benchmarks were run on Node v24.14.1 against 17.x.x. The compiler path shows rough ops/sec wins across the benchmark scenarios:

- async root fields: 1,511 vs 638 ops/sec, +137%
- field argument values: 11,245 vs 3,595 ops/sec, +213%
- introspection query: 70.4 vs 49.9 ops/sec, +41%
- async list field: 6,725 vs 3,083 ops/sec, +118%
- async non-null list items: 6,853 vs 2,960 ops/sec, +132%
- sync list field: 44,583 vs 14,248 ops/sec, +213%
- variable field collection: 18,498 vs 5,708 ops/sec, +224%

Author: yaacovCR

benchmark/compile/compiled-async-root-fields-benchmark.js

@@ -0,0 +1,53 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+
+const fieldCount = 1000;
+const fieldNames = Array.from(
+  { length: fieldCount },
+  (_, index) => `f${index}`,
+);
+
+const schema = buildSchema(
+  `type Query { ${fieldNames.map((fieldName) => `${fieldName}: Int`).join(' ')} }`,
+  { assumeValid: true },
+);
+
+const document = parse(`{ ${fieldNames.join(' ')} }`);
+
+const rootValue = Object.fromEntries(
+  fieldNames.map((fieldName, index) => [
+    fieldName,
+    () => Promise.resolve(index),
+  ]),
+);
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+export const benchmark = {
+  name: 'Compiled Asynchronous Root Fields',
+  measure: () => {
+    const runtimeArgs = { rootValue };
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute(runtimeArgs)
+        : compiled.executeRootSelectionSet(runtimeArgs);
+    }
+
+    const validatedArgs = execution.validateExecutionArgs({
+      schema,
+      document,
+      ...runtimeArgs,
+    });
+    if (!('schema' in validatedArgs)) {
+      throw validatedArgs[0];
+    }
+    return execution.executeRootSelectionSet(validatedArgs);
+  },
+};

benchmark/compile/compiled-field-argument-values-benchmark.js

@@ -0,0 +1,96 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+
+const fieldCount = 100;
+const fieldNames = Array.from(
+  { length: fieldCount },
+  (_, index) => `f${index}`,
+);
+
+const schema = buildSchema(
+  `
+    input FieldInput {
+      enabled: Boolean
+      value: Int
+    }
+
+    type Query {
+      ${fieldNames
+        .map(
+          (fieldName) => `
+            ${fieldName}(
+              value: Int!
+              enabled: Boolean
+              input: FieldInput
+              list: [Int]
+            ): Int
+          `,
+        )
+        .join('\n')}
+    }
+  `,
+  { assumeValid: true },
+);
+
+const document = parse(`
+  query CompiledArgumentValues($value: Int!, $enabled: Boolean!) {
+    ${fieldNames
+      .map(
+        (fieldName, index) => `
+          ${fieldName}(
+            value: $value
+            enabled: $enabled
+            input: { enabled: $enabled, value: ${index} }
+            list: [${index}, $value]
+          )
+        `,
+      )
+      .join('\n')}
+  }
+`);
+
+const rootValue = Object.fromEntries(
+  fieldNames.map((fieldName, index) => [
+    fieldName,
+    (args) => args.value + args.input.value + args.list[0] + index,
+  ]),
+);
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+let value = 0;
+let enabled = false;
+
+export const benchmark = {
+  name: 'Compiled Field Argument Values',
+  measure: () => {
+    value = (value + 1) % 10;
+    enabled = !enabled;
+    const runtimeArgs = {
+      rootValue,
+      variableValues: { value, enabled },
+    };
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute(runtimeArgs)
+        : compiled.executeRootSelectionSet(runtimeArgs);
+    }
+
+    const validatedArgs = execution.validateExecutionArgs({
+      schema,
+      document,
+      ...runtimeArgs,
+    });
+    if (!('schema' in validatedArgs)) {
+      throw validatedArgs[0];
+    }
+    return execution.executeRootSelectionSet(validatedArgs);
+  },
+};

benchmark/compile/compiled-introspectionFromSchema-benchmark.js

@@ -0,0 +1,30 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+import { getIntrospectionQuery } from 'graphql/utilities/getIntrospectionQuery.js';
+
+import { bigSchemaSDL } from '../fixtures.js';
+
+const schema = buildSchema(bigSchemaSDL, { assumeValid: true });
+const document = parse(getIntrospectionQuery());
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+export const benchmark = {
+  name: 'Compiled Execute Introspection Query',
+  measure: () => {
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute()
+        : compiled.executeRootSelectionSet();
+    }
+
+    return execution.executeSync({ schema, document });
+  },
+};

benchmark/compile/compiled-list-async-benchmark.js

@@ -0,0 +1,48 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+
+const schema = buildSchema('type Query { listField: [String] }', {
+  assumeValid: true,
+});
+const document = parse('{ listField }');
+
+function listField() {
+  const results = [];
+  for (let index = 0; index < 1000; index++) {
+    results.push(Promise.resolve(index));
+  }
+  return results;
+}
+
+const rootValue = { listField };
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+export const benchmark = {
+  name: 'Compiled Asynchronous List Field',
+  measure: () => {
+    const runtimeArgs = { rootValue };
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute(runtimeArgs)
+        : compiled.executeRootSelectionSet(runtimeArgs);
+    }
+
+    const validatedArgs = execution.validateExecutionArgs({
+      schema,
+      document,
+      ...runtimeArgs,
+    });
+    if (!('schema' in validatedArgs)) {
+      throw validatedArgs[0];
+    }
+    return execution.executeRootSelectionSet(validatedArgs);
+  },
+};

benchmark/compile/compiled-list-async-non-null-items-benchmark.js

@@ -0,0 +1,48 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+
+const schema = buildSchema('type Query { listField: [String!] }', {
+  assumeValid: true,
+});
+const document = parse('{ listField }');
+
+function listField() {
+  const results = [];
+  for (let index = 0; index < 1000; index++) {
+    results.push(Promise.resolve(index));
+  }
+  return results;
+}
+
+const rootValue = { listField };
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+export const benchmark = {
+  name: 'Compiled Asynchronous Non-Null List Items',
+  measure: () => {
+    const runtimeArgs = { rootValue };
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute(runtimeArgs)
+        : compiled.executeRootSelectionSet(runtimeArgs);
+    }
+
+    const validatedArgs = execution.validateExecutionArgs({
+      schema,
+      document,
+      ...runtimeArgs,
+    });
+    if (!('schema' in validatedArgs)) {
+      throw validatedArgs[0];
+    }
+    return execution.executeRootSelectionSet(validatedArgs);
+  },
+};

benchmark/compile/compiled-list-sync-benchmark.js

@@ -0,0 +1,48 @@
+import * as execution from 'graphql/execution/index.js';
+import { parse } from 'graphql/language/parser.js';
+import { buildSchema } from 'graphql/utilities/buildASTSchema.js';
+
+const schema = buildSchema('type Query { listField: [String] }', {
+  assumeValid: true,
+});
+const document = parse('{ listField }');
+
+function listField() {
+  const results = [];
+  for (let index = 0; index < 1000; index++) {
+    results.push(index);
+  }
+  return results;
+}
+
+const rootValue = { listField };
+
+const compiled =
+  typeof execution.compileExecution === 'function'
+    ? execution.compileExecution({ schema, document })
+    : undefined;
+if (Array.isArray(compiled)) {
+  throw compiled[0];
+}
+
+export const benchmark = {
+  name: 'Compiled Synchronous List Field',
+  measure: () => {
+    const runtimeArgs = { rootValue };
+    if (compiled !== undefined) {
+      return 'execute' in compiled
+        ? compiled.execute(runtimeArgs)
+        : compiled.executeRootSelectionSet(runtimeArgs);
+    }
+
+    const validatedArgs = execution.validateExecutionArgs({
+      schema,
+      document,
+      ...runtimeArgs,
+    });
+    if (!('schema' in validatedArgs)) {
+      throw validatedArgs[0];
+    }
+    return execution.executeRootSelectionSet(validatedArgs);
+  },
+};