fix: precompute schemahash (#301)

* fix: precompute schemahash

* fix: apollo

* fix: apollo

benchmarks/apollo-debugger/index.js

@@ -13,10 +13,10 @@ if (cluster.isPrimary) {
 } else {
   const server = new ApolloServer({
     typeDefs: `
-        type Query {
-          hello: String!
-        }
-      `,
+      type Query {
+        hello: String!
+      }
+    `,
     resolvers: {
       Query: {
         hello: () => "world",

benchmarks/helix-debugger/index.js

@@ -57,10 +57,11 @@ if (cluster.isPrimary) {
       query,
       variables,
       request,
-      schema: tracedSchema,
+      schema: tracedSchema.schema,
       contextFactory: () => ({
         GraphQLDebuggerContext: new GraphQLDebuggerContext({
-          schema,
+          schema: tracedSchema.schema,
+          schemaHash: tracedSchema.schemaHash,
         }),
       }),
     });

docs/src/pages/docs/faq/missing-context.mdx

@@ -7,12 +7,15 @@ Inject the `GraphQLDebuggerContext` instance inside your GraphQL request context
 ```js
 import { GraphQLDebuggerContext } from "@graphql-debugger/trace-schema";
 
+const tracedScema = traceSchema({
+  schema,
+  adapter: // <-- See Adapters
+});
+
 const myServer = new GraphQLServerFooBar({
   schema,
   context: {
-    GraphQLDebuggerContext: new GraphQLDebuggerContext({
-      schema,
-    }),
+    GraphQLDebuggerContext: new GraphQLDebuggerContext(tracedSchema),
   },
 });
 ```

docs/src/pages/docs/how.mdx

@@ -210,8 +210,8 @@ const tracedSchema = traceSchema({
 
 // or
 const tracedSchema = traceSchema({
-schema,
-adapter,
+    schema,
+    adapter,
 });
 
 ```

e2e/tests/utils/create-test-schema.ts

@@ -1,7 +1,6 @@
 import { DebuggerClient } from "@graphql-debugger/client";
 import { traceSchema } from "@graphql-debugger/trace-schema";
 import { Schema } from "@graphql-debugger/types";
-import { hashSchema } from "@graphql-debugger/utils";
 
 import { faker } from "@faker-js/faker";
 import { makeExecutableSchema } from "@graphql-tools/schema";
@@ -63,27 +62,25 @@ export async function createTestSchema({
     resolvers,
   });
 
-  const schema = traceSchema({
+  const { schema, schemaHash } = traceSchema({
     schema: executableSchema,
     adapter: client.adapter,
   });
 
-  const hash = hashSchema(schema);
-
   const dbSchema = await client.schema.upsert({
     where: {
-      hash,
+      hash: schemaHash,
     },
     input: {
-      hash: hash,
+      hash: schemaHash,
       typeDefs: typeDefs,
     },
   });
 
   return {
     schema,
     typeDefs,
-    hash,
+    hash: schemaHash,
     dbSchema,
     query: /* GraphQL */ `
       query ${shouldNameQuery ? random : ""} {

packages/graphql-schema/src/schema.ts

@@ -4,6 +4,7 @@ import { traceSchema } from "@graphql-debugger/trace-schema";
 import { hashSchema } from "@graphql-debugger/utils";
 
 import SchemaBuilder from "@pothos/core";
+import { GraphQLSchema } from "graphql";
 
 import { TRACE_PRISMA, TRACE_SCHEMA } from "./config";
 import { Context } from "./context";
@@ -23,17 +24,24 @@ require("./mutations");
 const build = builder.toSchema();
 
 export function createSchema({ client }: { client: DebuggerClient }) {
-  const schema = TRACE_SCHEMA
-    ? traceSchema({
-        adapter: client.adapter,
-        schema: build,
-        ...(TRACE_PRISMA && {
-          instrumentations: [tracing],
-        }),
-      })
-    : build;
-
-  const hash = hashSchema(schema);
-
-  return { schema, hash };
+  let schema: GraphQLSchema;
+  let schemaHash: string;
+
+  if (TRACE_SCHEMA) {
+    const tracedSchema = traceSchema({
+      schema: build,
+      adapter: client.adapter,
+      shouldExportSchema: false,
+      ...(TRACE_PRISMA && {
+        instrumentations: [tracing],
+      }),
+    });
+    schema = tracedSchema.schema;
+    schemaHash = tracedSchema.schemaHash;
+  } else {
+    schema = build;
+    schemaHash = hashSchema(build);
+  }
+
+  return { schema, schemaHash };
 }

packages/trace-directive/src/context.ts

@@ -12,6 +12,7 @@ import { GraphQLSchema } from "graphql";
 
 export interface GraphQLDebuggerContextOptions {
   schema: GraphQLSchema;
+  schemaHash?: string;
 }
 
 export class GraphQLDebuggerContext {
@@ -23,7 +24,7 @@ export class GraphQLDebuggerContext {
 
   constructor(options: GraphQLDebuggerContextOptions) {
     this.schema = options.schema;
-    this.schemaHash = hashSchema(options.schema);
+    this.schemaHash = options.schemaHash || hashSchema(options.schema);
     this.tracer = getTracer();
   }
 

packages/trace-schema/src/trace-schema.ts

@@ -2,6 +2,7 @@
 import { BaseAdapter } from "@graphql-debugger/adapter-base";
 import { SetupOtelInput, setupOtel } from "@graphql-debugger/opentelemetry";
 import { traceDirective } from "@graphql-debugger/trace-directive";
+import { hashSchema } from "@graphql-debugger/utils";
 
 import { makeExecutableSchema } from "@graphql-tools/schema";
 import { getResolversFromSchema } from "@graphql-tools/utils";
@@ -27,7 +28,7 @@ export function traceSchema({
   instrumentations,
   shouldExportSchema = true,
   shouldExcludeTypeFields = false,
-}: TraceSchemaInput): GraphQLSchema {
+}: TraceSchemaInput): { schema: GraphQLSchema; schemaHash: string } {
   debug("Tracing schema");
 
   setupOtel({ exporterConfig, instrumentations });
@@ -97,5 +98,8 @@ export function traceSchema({
 
   debug("Traced schema");
 
-  return tracedSchema;
+  return {
+    schema: tracedSchema,
+    schemaHash: hashSchema(tracedSchema),
+  };
 }

packages/trace-schema/tests/trace-schema.test.ts

@@ -35,7 +35,7 @@ describe("tracedSchema", () => {
       shouldExportSchema: false,
     });
 
-    const outputTypedefs = printSchemaWithDirectives(tracedSchema);
+    const outputTypedefs = printSchemaWithDirectives(tracedSchema.schema);
 
     expect(outputTypedefs).toMatchInlineSnapshot(`
 "schema {
@@ -99,7 +99,7 @@ type Query {
       shouldExcludeTypeFields: true,
     });
 
-    const outputTypedefs = printSchemaWithDirectives(tracedSchema);
+    const outputTypedefs = printSchemaWithDirectives(tracedSchema.schema);
 
     expect(outputTypedefs).toMatchInlineSnapshot(`
 "schema {

plugins/apollo/src/index.ts

@@ -14,6 +14,7 @@ import {
   GraphQLDebuggerContext,
   SchemaExporer,
 } from "@graphql-debugger/trace-schema";
+import { hashSchema } from "@graphql-debugger/utils";
 
 import { ApolloServerPlugin } from "@apollo/server";
 import { Path } from "graphql/jsutils/Path";
@@ -48,6 +49,8 @@ export const graphqlDebuggerPlugin = ({
   exporterConfig?: SetupOtelInput["exporterConfig"];
   instrumentations?: SetupOtelInput["instrumentations"];
 } = {}): ApolloServerPlugin<GraphQLContext> => {
+  let schemaHash: string;
+
   return {
     serverWillStart: async (service) => {
       const schema = service.schema;
@@ -59,16 +62,20 @@ export const graphqlDebuggerPlugin = ({
         schemaExporter.start();
       }
 
+      schemaHash = hashSchema(schema);
       setupOtel({ exporterConfig, instrumentations });
     },
     requestDidStart: async ({ schema }) => {
       const spanMap = new Map<string, ApiSpan>();
 
       return {
-        async executionDidStart() {
-          const internalCtx = new GraphQLDebuggerContext({
-            schema,
-          });
+        async executionDidStart(context) {
+          const internalCtx =
+            context.contextValue.GraphQLDebuggerContext ||
+            new GraphQLDebuggerContext({
+              schema,
+              schemaHash,
+            });
 
           return {
             willResolveField(fieldCtx) {

plugins/yoga/src/create-yoga.ts

@@ -38,12 +38,36 @@ export function createYoga<
     throw new Error("Schema is required when using GraphQL Debugger");
   }
 
+  let adapter = options?.debugger?.adapter;
+  if (!adapter) {
+    adapter = new ProxyAdapter();
+  }
+
+  let schema = options.schema;
+  let schemaHash = "";
+
+  if (options.debugger?.shouldDisable) {
+    schema = options.schema;
+  } else {
+    const tracedSchema = traceSchema({
+      schema,
+      adapter: adapter as BaseAdapter,
+      ...options.debugger?.traceSchemaOptions,
+    });
+
+    schema = tracedSchema.schema;
+    schemaHash = tracedSchema.schemaHash;
+  }
+
+  const preComputedContext = {
+    schema,
+    schemaHash,
+  };
+
   if (!options.context) {
     const contextOverride = async (): Promise<TUserContext> => {
       return {
-        GraphQLDebuggerContext: new GraphQLDebuggerContext({
-          schema: options.schema,
-        }),
+        GraphQLDebuggerContext: new GraphQLDebuggerContext(preComputedContext),
       } as unknown as TUserContext;
     };
 
@@ -55,27 +79,14 @@ export function createYoga<
     options.context = async function newContextFunction(...args) {
       const contextObject = await originalContextFunction(...args);
 
-      contextObject.GraphQLDebuggerContext = new GraphQLDebuggerContext({
-        schema: options.schema,
-      });
+      contextObject.GraphQLDebuggerContext = new GraphQLDebuggerContext(
+        preComputedContext,
+      );
 
       return contextObject;
     };
   }
 
-  let adapter = options?.debugger?.adapter;
-  if (!adapter) {
-    adapter = new ProxyAdapter();
-  }
-
-  const schema = options.debugger?.shouldDisable
-    ? options.schema
-    : traceSchema({
-        schema: options.schema,
-        adapter: adapter as BaseAdapter,
-        ...options.debugger?.traceSchemaOptions,
-      });
-
   const yoga = originalCreateYoga<TServerContext, TUserContext>({
     ...options,
     schema,