[RFC] compile createSourceEventStream

src/__benchmarks__/benchmarks.ts

@@ -1,12 +1,14 @@
 import Benchmark from "benchmark";
 import {
+  createSourceEventStream,
   DocumentNode,
   execute,
   getIntrospectionQuery,
   GraphQLSchema,
   parse
 } from "graphql";
 import { compileQuery, isCompiledQuery, isPromise } from "../execution";
+import { benchmarkCreateSourceEventStream } from "./createSourceEventStream";
 import {
   query as fewResolversQuery,
   schema as fewResolversSchema
@@ -51,8 +53,8 @@ const benchmarks: { [key: string]: BenchmarkMaterial } = {
 async function runBenchmarks() {
   const skipJS = process.argv[2] === "skip-js";
   const skipJSON = process.argv[2] === "skip-json";
-  const benchs = await Promise.all(
-    Object.entries(benchmarks).map(
+  const benchs = await Promise.all([
+    ...Object.entries(benchmarks).map(
       async ([bench, { query, schema, variables }]) => {
         const compiledQuery = compileQuery(schema, query, undefined, {
           debug: true
@@ -145,7 +147,9 @@ async function runBenchmarks() {
           });
         return suite;
       }
-    )
+    ),
+    benchmarkCreateSourceEventStream(),
+    ]
   );
 
   const benchsToRun = benchs.filter(isNotNull);

src/__benchmarks__/createSourceEventStream.ts

@@ -0,0 +1,153 @@
+import Benchmark from "benchmark";
+import {
+  createSourceEventStream,
+  GraphQLBoolean,
+  GraphQLID,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLSchema,
+  GraphQLString,
+  parse
+
+} from "graphql";
+import { isPromise } from "../execution";
+import { compileSourceEventStream } from "..";
+
+const schema = function schema() {
+  const BlogArticle: GraphQLObjectType = new GraphQLObjectType({
+    name: "Article",
+    fields: {
+      id: { type: new GraphQLNonNull(GraphQLID) },
+      isPublished: { type: GraphQLBoolean },
+      title: { type: GraphQLString },
+      body: { type: GraphQLString },
+      keywords: { type: new GraphQLList(GraphQLString) }
+    }
+  });
+
+  const BlogQuery = new GraphQLObjectType({
+    name: "Query",
+    fields: {
+      article: {
+        type: BlogArticle,
+        args: { id: { type: GraphQLID } },
+        resolve: (_, { id }) => article(id)
+      },
+    }
+  });
+  const BlogSubscription = new GraphQLObjectType({
+    name: "Subscription",
+    fields: {
+      news: {
+        type: BlogArticle,
+        args: {},
+        subscribe: async () => {
+          const it: AsyncIterable<any> = {
+            [Symbol.asyncIterator]() {
+              return {
+                next: async () => ({done: true, value: undefined})
+              }
+            },
+          }
+          return it;
+        }
+      },
+    }
+  });
+
+  function article(id: number): any {
+    return {
+      id,
+      isPublished: true,
+      title: "My Article " + id,
+      body: "This is a post",
+      hidden: "This data is not exposed in the schema",
+      keywords: ["foo", "bar", 1, true, null]
+    };
+  }
+
+  return new GraphQLSchema({
+    query: BlogQuery,
+    subscription: BlogSubscription
+  });
+}()
+
+const subscription = parse(`
+subscription {
+  news {
+    ...articleFields,
+  }
+}
+
+fragment articleFields on Article {
+  __typename
+  id,
+  isPublished,
+  title,
+  body,
+  hidden,
+  notdefined
+}
+`);
+
+// TODO
+const skipJS = false;
+
+export function benchmarkCreateSourceEventStream() {
+  const compiledQuery = compileSourceEventStream(schema, subscription, undefined, {
+    debug: true
+  } as any);
+  if (!compiledQuery) {
+    // eslint-disable-next-line no-console
+    console.error(`failed to compile`);
+    return null;
+  }
+  const suite = new Benchmark.Suite('createSourceEventStream');
+  if (!skipJS) {
+    suite.add("graphql-js", {
+      minSamples: 150,
+      defer: true,
+      fn(deferred: any) {
+        const stream = createSourceEventStream(
+          schema,
+          subscription,
+          {},
+        );
+        if (isPromise(stream)) {
+          return stream.then((res) =>
+            deferred.resolve(res)
+          );
+        }
+        return deferred.resolve()
+      }
+    });
+  }
+  suite
+    .add("graphql-jit", {
+      minSamples: 150,
+      defer: true,
+      fn(deferred: any) {
+        const stream = compiledQuery(
+          {},
+          undefined
+        );
+        if (isPromise(stream)) {
+          return stream.then((res) =>
+            deferred.resolve(res)
+          );
+        }
+        return deferred.resolve()
+      }
+    })
+    // add listeners
+    .on("cycle", (event: any) => {
+      // eslint-disable-next-line no-console
+      console.log(String(event.target));
+    })
+    .on("start", () => {
+      // eslint-disable-next-line no-console
+      console.log("Starting createSourceEventStream");
+    });
+  return suite;
+}