@graphitation/supermassive 3.0.0-alpha.6 → 3.0.0-alpha.8

package/CHANGELOG.md

@@ -1,12 +1,28 @@
 # Change Log - @graphitation/supermassive
 
-This log was last generated on Mon, 11 Sep 2023 19:24:16 GMT and should not be manually modified.
+This log was last generated on Thu, 14 Sep 2023 19:05:21 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 3.0.0-alpha.8
+
+Thu, 14 Sep 2023 19:05:21 GMT
+
+### Changes
+
+- change signature of executeWithSchema and subscribeWithSchema functions (vladimir.razuvaev@gmail.com)
+
+## 3.0.0-alpha.7
+
+Tue, 12 Sep 2023 23:58:31 GMT
+
+### Changes
+
+- refactor: replace PartialSchema class with ES module functions (vladimir.razuvaev@gmail.com)
+
 ## 3.0.0-alpha.6
 
-Mon, 11 Sep 2023 19:24:16 GMT
+Mon, 11 Sep 2023 19:24:32 GMT
 
 ### Changes
 

package/README.md

@@ -27,22 +27,38 @@ Similarly, the GraphQL operations themselves, described using e.g. [GraphQL SDL]
 
 ### Current
 
-Currently, supermassive expects inlined types in normal GraphQL documents that are sent to it. It doesn't require having a schema, only the query document and resolver functions. We achieve this by running a pre-processing step on queries using the schema, in a same stage where `graphql` tags would normally be extracted and pre-parsed. Schema is often a very big part of the bundle and memory volume, so this drastically improves that and removes the need of creating a schema in runtime, which can also be very costly.
+Starting with version 3.0, supermassive expects a compact fragment of the schema alongside documents that are sent to it.
+It doesn't require having a full schema, only a small fragment necessary for a specific operation.
 
-In this initial phase, we will achieve the goal of tree-shaking the schema definitions. We do this by inlining required metadata into the documents that describe the operations, after which they can be executed with the need of the entire schema. This means overall bundle size will be decreased when only a subset of the schema is actually used, which pays off significantly when a host application introduces its first component(s) leveraging GraphQL.
+Schema fragment format is much more compact than the graphql-js AST. It is optimized for fast merging and serializing,
+so you can incrementally load and merge schema fragments as different operations are requested.
 
-### Possible future 1 - Relay IR
+Different strategies of "fragmentizing" the schema are possible, it is up to your specific case which strategy to choose.
+Below you can find some strategies that we found useful.
 
-Current implementation has some bundle size / memory cost because GraphQL AST format isn't super optimized and adding types to it makes it even worse. However there is an already type annotated AST format that is more compact - Relay IR. As Relay anyway needs IR to do it's store operations, this wouldn't incur additional bundle cost to include them. Relay IR Printer would need to be modified to include more type information, but Relay IR is otherwise already typed and has all type information we
-need.
+#### 1. Schema fragment by operation
 
-Relay IR is more efficient because it allows aliasing common elements of the document, like types or selections, thus reducing the total document size.
+We can extract schema fragments by running a pre-processing step on queries, in the same stage where `graphql` tags would normally be extracted and pre-parsed.
+Supermassive package contains several handy utilities for this strategy.
 
-### Possible future 2 - pre-normalized executor
+#### 2. Schema modules
+
+If the schema is big enough, it is a common practice to split it into [multiple modules](https://the-guild.dev/graphql/modules/docs).
+In this case the natural strategy is to generate a single fragment per module. Supermassive supports custom fragment loader,
+so when an operation contains an unknown field or type, supermassive will request a fragment for it.
+This strategy implies "schema map" to properly map operations or individual types to appropriate schema modules
+(schema map generation is out of scope for supermassive itself).
+
+#### 3. Variation of the two
+
+Other strategies usually represent a variation of those two. E.g. a fragment per specific group of operations, group of modules,
+or mix of modules and operations. Supermassive is agnostic to your "fragmentizing" strategy.
+
+### Possible future - pre-normalized executor
 
 In a scenario where executor is running close to the client (sometimes even in same process or at least in same browser), it might be worth exploring removing some of the requirements imposed by the usual GraphQL transport - for example serialization. Not only GraphQL executors do the JSON serialization, but also they return the data that is optimized for transport and that matches the query tree. This means clients need to perform often expensive normazilation. As traffic and message size might be less important in same process / same browser scenarios, it might be worthwhile exploring return pre-normalized data from supermassive. This offers massive speedups for some clients like Apollo ([see benchmarks](https://github.com/vladar/graphql-normalized)).
 
-### Possible future 3 - Tree-shaking based on documents
+### Possible future - Tree-shaking based on documents
 
 Current implementation is more efficient in terms of bundles than one requiring full schema, but resolvers are also not always needed. By going through fields being selected in the documents, resolvers can be split or tree-shook to only load ones that are required for certain frontend bundle.
 
@@ -73,7 +89,7 @@ This would lead to the following [conceptual] tree-shaking after compilation of
  };
 ```
 
-### Possible future 4 - GraphQL-to-JS
+### Possible future - GraphQL-to-JS
 
 We can expand on the previous phase by ahead-of-time compiling the resolution of the operations, their field-resolvers, and invocation thereof into JavaScript code. This essentially does away with any need for AST of the operation during execution. This means execution will be faster as no more generic lookups and checks need to be performed.
 
@@ -142,7 +158,7 @@ function CurrentUserNameQuery(rootSource = {}) {
 CurrentUserNameQuery();
 ```
 
-### Possible future 5 - persisted queries
+### Possible future - persisted queries
 
 we can make it possible to replace the operations at runtime using a simple identifier, thus allowing GraphQL clients to execute their operations using these identifiers that they obtain through a concept known as ["persisted queries"](https://relay.dev/docs/guides/persisted-queries/). This means that GraphQL clients that do not require graphql-js AST _themselves_ to operate, such as Relay, will be able to greatly reduce the size of the User-Experience bundles by entirely eliminating the document in favour of a short identifier.
 
@@ -176,15 +192,28 @@ function CurrentUser() {
 
 ## Usage
 
-There are 3 main parts of Supermassive - the executor, query annotator and implicit resolver extractor. Executor is the part that actually runs the queries. It takes resolvers object instead of schema and annotated documents instead of normal documents. Query annotator processes query to include type information inside them. It can be ran as part of query extraction stage in Relay Compiler or eg in `@graphitation/graphql-js-tag`. Implicit resolver extractor writes out resolvers for types that are only implicitly defined in GraphQL SDL, like Unions or Input Objects. It generates typescript file with extracted object that can be merged with the rest of the resolvers.
+There are 3 main parts of Supermassive:
+
+1. The executor
+2. Minimal viable schema fragment extractor and query annotator (for [schema fragment by operation](#1-schema-fragment-by-operation) strategy)
+3. Schema fragment encoder from/to graphql-js AST (for [schema modules](#2-schema-modules) strategy) + utilities for fragment merging
+
+Executor is the part that actually runs the queries. It takes operation document and schema fragment (composed of resolvers and compact type definitions) and optionally, schema fragment loader.
+
+Schema fragment extractor process query to extract type definitions necessary to execute this query.
+Query annotator could be used to inline those type definitions into query itself (e.g. as a directive).
+Annotator can be run as part of query extraction stage in Relay Compiler or eg in `@graphitation/graphql-js-tag`.
+
+Schema fragment encoder is necessary to produce schema fragments based on [schema modules](#2-schema-modules).
+It takes graphql-js AST of the individual schema module and converts it to the compact schema fragment format.
 
 ### Executor
 
-Two functions are provided - `executeWithSchema` and `executeWithoutSchema`. They attempt to match `graphql-js`'s `execute` function parameters. `executeWithSchema` fully matches it and is meant for development or testing. It does the transform and resolver extraction in runtime. `executeWithoutSchema` relies on those being done during compile/bundling time.
+Two functions are provided - `executeWithSchema` and `executeWithoutSchema`. They attempt to match `graphql-js`'s `execute` function parameters. `executeWithSchema` fully matches it and is meant for development or testing. It does the schema fragment extraction for operation in runtime. `executeWithoutSchema` expects schema fragment extracted at build/compile-time, as a required argument.
 
-```graphql
+```ts
 interface CommonExecutionArgs {
-  resolvers: Resolvers;
+  document: DocumentNode;
   rootValue?: unknown;
   contextValue?: unknown;
   variableValues?: Maybe<{ [variable: string]: unknown }>;
@@ -193,29 +222,111 @@ interface CommonExecutionArgs {
   typeResolver?: Maybe<TypeResolver<any, any>>;
 }
 type ExecutionWithoutSchemaArgs = CommonExecutionArgs & {
-  document: DocumentNode;
+  schemaFragment: SchemaFragment;
+  schemaFragmentLoader?: SchemaFragmentLoader;
 };
 
 type ExecutionWithSchemaArgs = CommonExecutionArgs & {
-  document: UntypedDocumentNode;
-  typeDefs: UntypedDocumentNode;
+  definitions: DocumentNode;
+  resolvers: UserResolvers;
 };
 
-function executeWithoutSchema(args: ExecutionWithoutSchemaArgs): PromiseOrValue<ExecutionResult>
+function executeWithoutSchema(
+  args: ExecutionWithoutSchemaArgs,
+): PromiseOrValue<ExecutionResult>;
+
+function executeWithSchema(
+  args: ExecutionWithSchemaArgs,
+): PromiseOrValue<ExecutionResult>;
+```
+
+### Minimal viable schema extractor
 
-function executeWithSchema(args: ExecutionWithSchemaArgs): PromiseOrValue<ExecutionResult>
+Extracts minimal schema fragment necessary for operation execution with supermassive.
+
+```ts
+export function extractMinimalViableSchemaForRequestDocument(
+  schema: GraphQLSchema,
+  requestDocument: DocumentNode,
+): { definitions: SchemaDefinitions; unknownDirectives: DirectiveNode[] };
+```
+
+### Webpack Transform
+
+Inlines schema definitions extracted with `extractMinimalViableSchemaForRequestDocument` into the `@schema` directive of each operation / fragment node.
+
+With `@graphitation/graphql-js-tag` and `@graphitation/ts-transform-graphql-js-tag` (in webpack config)
+
+```js
+import { buildASTSchema } from 'graphql'
+import { getTransformer } from "@graphitation/ts-transform-graphql-js-tag";
+import { annotateDocumentGraphQLTransform } from "@graphitation/supermassive";
+
+// ...
+
+{
+  test: /\.tsx?$/,
+  loader: "ts-loader",
+  options: {
+    getCustomTransformers: () => ({
+       before: [
+          getTransformer({
+            graphqlTagModuleExport: "graphql",
+            transformer: annotateDocumentGraphQLTransform(
+              buildASTSchema({
+                fs.readFileSync(
+                  "PATH_TO_SCHEMA_TYPEDEFS.graphql",
+                  { encoding: "utf-8" }
+                ),
+              )
+            ),
+          }),
+        ],
+      }),
+    },
+  },
+}
 ```
 
-### Transform
+### Schema definitions encoder
 
-Supermassive requires annotated GraphQL documents. See [`@graphitation/supermassive-ast`](../supermassive-ast/).
+Encodes SDL type definitions represented by graphql-js AST to compact format, necessary for execution with supermassive.
 
-### Resolver extractor
+```ts
+export function encodeASTSchema(
+  schemaFragment: DocumentNode,
+): SchemaDefinitions[];
+export function decodeASTSchema(
+  encodedSchemaFragments: SchemaDefinitions[],
+): DocumentNode;
+```
 
-Supermassive provides a bin command to extract implicit resolvers. See [`@graphitation/supermassive-extractors`](../supermassive-extractors/) and [`@graphitation/cli`](../cli).
+Usage example:
 
-```sh
-supermassive extract-schema PATH_TO_TYPEDEFS.graphql
+```js
+import { prase } from "graphql";
+import { encodeASTSchema, decodeASTSchema } from "@graphitation/supermassive";
+
+const typeDefs = parse(
+  fs.readFileSync("PATH_TO_SCHEMA_TYPEDEFS.graphql", { encoding: "utf-8" }),
+);
+
+const encodedTypeDefs = encodeASTSchema(typeDefs);
+const decodedTypeDefs = decodeASTSchema(encodedTypeDefs); // decodedTypeDefs are same as typeDefs
 ```
 
-It generates `__generated__/NAME_OF_TYPEDEFS.ts` file, on top of which user provided resolvers can be merged when executing.
+### Utilities for definitions and resolvers merging
+
+Utilities are useful when it is necessary to produce a single schema fragment from multiple schema fragments.
+
+```ts
+export function mergeSchemaDefinitions(
+  accumulator: SchemaDefinitions,
+  definitions: SchemaDefinitions[],
+): SchemaDefinitions;
+
+export function mergeResolvers(
+  accumulator: Resolvers,
+  resolvers: (Resolvers | Resolvers[])[],
+): Resolvers;
+```

package/lib/__testUtils__/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/__testUtils__/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAKb,aAAa,EACb,aAAa,IAAI,oBAAoB,EACrC,eAAe,IAAI,sBAAsB,EAC1C,MAAM,SAAS,CAAC;AAIjB,OAAO,EAAE,eAAe,EAAiB,MAAM,UAAU,CAAC;AAI1D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,KAAK,aAAa,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,IACrE,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,GAC1C,cAAc,CAAC,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAE3E,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,cAAc,CAAC,eAAe,CAAC,EACxE,gBAAgB,EAAE,CAChB,IAAI,EAAE,aAAa,KAChB,cAAc,CACjB,cAAc,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,eAAe,CAC9D;oEAqCS,aAAa,SACd,MAAM,cACF,OAAO,MAAM,EAAE,OAAO,CAAC;iDApC1B,aAAa,SACd,MAAM,cACD,OAAO,MAAM,EAAE,OAAO,CAAC;6BAqG3B,eAAe,GAAG,aAAa,KACtC,QAAQ,OAAO,CAAC;sCAhCX,oBAAoB,KACzB,eAAe,aAAa,CAAC;EA8DjC"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/__testUtils__/execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,aAAa,EAKb,aAAa,EACb,aAAa,IAAI,oBAAoB,EACrC,eAAe,IAAI,sBAAsB,EAC1C,MAAM,SAAS,CAAC;AAIjB,OAAO,EAAE,eAAe,EAAiB,MAAM,UAAU,CAAC;AAI1D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,KAAK,aAAa,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,IACrE,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,GAC1C,cAAc,CAAC,sBAAsB,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAE3E,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,cAAc,CAAC,eAAe,CAAC,EACxE,gBAAgB,EAAE,CAChB,IAAI,EAAE,aAAa,KAChB,cAAc,CACjB,cAAc,CAAC,eAAe,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,eAAe,CAC9D;oEAkCS,aAAa,SACd,MAAM,cACF,OAAO,MAAM,EAAE,OAAO,CAAC;iDAjC1B,aAAa,SACd,MAAM,cACD,OAAO,MAAM,EAAE,OAAO,CAAC;6BAkG3B,eAAe,GAAG,aAAa,KACtC,QAAQ,OAAO,CAAC;sCAhCX,oBAAoB,KACzB,eAAe,aAAa,CAAC;EA8DjC"}

package/lib/__testUtils__/execute.js

@@ -84,11 +84,8 @@ function createExecutionUtils(graphqlExecute, graphqlSubscribe) {
       const result = yield drainExecution(
         yield (0, import_executeWithSchema.executeWithSchema)({
           document,
-          schema: {
-            schemaId: "test",
-            definitions: import_swapi_schema.typeDefs,
-            resolvers: import_resolvers.default
-          },
+          definitions: import_swapi_schema.typeDefs,
+          resolvers: import_resolvers.default,
           contextValue: {
             models: import_models.default
           },

package/lib/__testUtils__/execute.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/__testUtils__/execute.ts"],
-  "sourcesContent": ["import {\n  DocumentNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n  OperationTypeNode,\n  parse,\n  ExecutionArgs,\n  ExecutionArgs as GraphQLExecutionArgs,\n  ExecutionResult as GraphQLExecutionResult,\n} from \"graphql\";\nimport { executeWithSchema } from \"../executeWithSchema\";\nimport { typeDefs } from \"../benchmarks/swapi-schema\";\nimport resolvers from \"../benchmarks/swapi-schema/resolvers\";\nimport { ExecutionResult, UserResolvers } from \"../types\";\nimport models from \"../benchmarks/swapi-schema/models\";\nimport { executeWithoutSchema } from \"../executeWithoutSchema\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { PromiseOrValue } from \"graphql/jsutils/PromiseOrValue\";\nimport { ObjMap } from \"../jsutils/ObjMap\";\nimport { forAwaitEach, isAsyncIterable } from \"iterall\";\n\ntype GraphQLResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> =\n  | GraphQLExecutionResult<TData, TExtensions>\n  | AsyncGenerator<GraphQLExecutionResult<TData, TExtensions>, void, void>;\n\nexport function createExecutionUtils(\n  graphqlExecute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>,\n  graphqlSubscribe: (\n    args: ExecutionArgs,\n  ) => PromiseOrValue<\n    AsyncGenerator<ExecutionResult, void, void> | ExecutionResult\n  >,\n) {\n  async function compareResultsForExecuteWithSchema(\n    schema: GraphQLSchema,\n    query: string,\n    variables?: Record<string, unknown>,\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const result = await drainExecution(\n      await executeWithSchema({\n        document,\n        schema: {\n          schemaId: \"test\",\n          definitions: typeDefs,\n          resolvers: resolvers as UserResolvers<unknown, unknown>,\n        },\n        contextValue: {\n          models,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  async function compareResultForExecuteWithoutSchemaWithMVSAnnotation(\n    schema: GraphQLSchema,\n    query: string,\n    variables: Record<string, unknown> = {},\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const { definitions } = extractMinimalViableSchemaForRequestDocument(\n      schema,\n      document,\n    );\n    const result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        schemaFragment: {\n          schemaId: \"test\",\n          definitions,\n          resolvers: resolvers as UserResolvers,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  function graphqlExecuteOrSubscribe(\n    args: GraphQLExecutionArgs,\n  ): PromiseOrValue<GraphQLResult> {\n    const operationName = args.operationName;\n    let operation: OperationDefinitionNode | undefined;\n    for (const definition of (args.document as unknown as DocumentNode)\n      .definitions) {\n      switch (definition.kind) {\n        case Kind.OPERATION_DEFINITION:\n          if (operationName == null) {\n            if (operation !== undefined) {\n              throw new Error(\"Bad operation in test\");\n            }\n            operation = definition;\n          } else if (definition.name?.value === operationName) {\n            operation = definition;\n          }\n          break;\n      }\n    }\n    if (!operation) {\n      throw new Error(\"Bad operation in test\");\n    }\n\n    if (operation.operation === OperationTypeNode.SUBSCRIPTION) {\n      return graphqlSubscribe(args) as GraphQLResult;\n    } else {\n      return graphqlExecute(args) as GraphQLResult;\n    }\n  }\n\n  async function drainExecution(\n    result: ExecutionResult | GraphQLResult,\n  ): Promise<unknown> {\n    let processedResult;\n    if (isAsyncIterable(result)) {\n      processedResult = await drainAsyncGeneratorToArray(result);\n    } else if (\"subsequentResults\" in result) {\n      processedResult = {\n        ...result,\n        subsequentResults: await drainAsyncGeneratorToArray(\n          result.subsequentResults,\n        ),\n      };\n    } else {\n      processedResult = result;\n    }\n    return processedResult;\n  }\n\n  async function drainAsyncGeneratorToArray<T>(\n    collection: AsyncGenerator<T, void, void>,\n  ): Promise<T[]> {\n    const result: T[] = [];\n    await forAwaitEach(collection, (item) => result.push(item));\n    return result;\n  }\n\n  return {\n    compareResultForExecuteWithoutSchemaWithMVSAnnotation,\n    compareResultsForExecuteWithSchema,\n    drainExecution,\n    graphqlExecuteOrSubscribe,\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  DocumentNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n  OperationTypeNode,\n  parse,\n  ExecutionArgs,\n  ExecutionArgs as GraphQLExecutionArgs,\n  ExecutionResult as GraphQLExecutionResult,\n} from \"graphql\";\nimport { executeWithSchema } from \"../executeWithSchema\";\nimport { typeDefs } from \"../benchmarks/swapi-schema\";\nimport resolvers from \"../benchmarks/swapi-schema/resolvers\";\nimport { ExecutionResult, UserResolvers } from \"../types\";\nimport models from \"../benchmarks/swapi-schema/models\";\nimport { executeWithoutSchema } from \"../executeWithoutSchema\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { PromiseOrValue } from \"graphql/jsutils/PromiseOrValue\";\nimport { ObjMap } from \"../jsutils/ObjMap\";\nimport { forAwaitEach, isAsyncIterable } from \"iterall\";\n\ntype GraphQLResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> =\n  | GraphQLExecutionResult<TData, TExtensions>\n  | AsyncGenerator<GraphQLExecutionResult<TData, TExtensions>, void, void>;\n\nexport function createExecutionUtils(\n  graphqlExecute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>,\n  graphqlSubscribe: (\n    args: ExecutionArgs,\n  ) => PromiseOrValue<\n    AsyncGenerator<ExecutionResult, void, void> | ExecutionResult\n  >,\n) {\n  async function compareResultsForExecuteWithSchema(\n    schema: GraphQLSchema,\n    query: string,\n    variables?: Record<string, unknown>,\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const result = await drainExecution(\n      await executeWithSchema({\n        document,\n        definitions: typeDefs,\n        resolvers: resolvers as UserResolvers<unknown, unknown>,\n        contextValue: {\n          models,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  async function compareResultForExecuteWithoutSchemaWithMVSAnnotation(\n    schema: GraphQLSchema,\n    query: string,\n    variables: Record<string, unknown> = {},\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const { definitions } = extractMinimalViableSchemaForRequestDocument(\n      schema,\n      document,\n    );\n    const result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        schemaFragment: {\n          schemaId: \"test\",\n          definitions,\n          resolvers: resolvers as UserResolvers,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  function graphqlExecuteOrSubscribe(\n    args: GraphQLExecutionArgs,\n  ): PromiseOrValue<GraphQLResult> {\n    const operationName = args.operationName;\n    let operation: OperationDefinitionNode | undefined;\n    for (const definition of (args.document as unknown as DocumentNode)\n      .definitions) {\n      switch (definition.kind) {\n        case Kind.OPERATION_DEFINITION:\n          if (operationName == null) {\n            if (operation !== undefined) {\n              throw new Error(\"Bad operation in test\");\n            }\n            operation = definition;\n          } else if (definition.name?.value === operationName) {\n            operation = definition;\n          }\n          break;\n      }\n    }\n    if (!operation) {\n      throw new Error(\"Bad operation in test\");\n    }\n\n    if (operation.operation === OperationTypeNode.SUBSCRIPTION) {\n      return graphqlSubscribe(args) as GraphQLResult;\n    } else {\n      return graphqlExecute(args) as GraphQLResult;\n    }\n  }\n\n  async function drainExecution(\n    result: ExecutionResult | GraphQLResult,\n  ): Promise<unknown> {\n    let processedResult;\n    if (isAsyncIterable(result)) {\n      processedResult = await drainAsyncGeneratorToArray(result);\n    } else if (\"subsequentResults\" in result) {\n      processedResult = {\n        ...result,\n        subsequentResults: await drainAsyncGeneratorToArray(\n          result.subsequentResults,\n        ),\n      };\n    } else {\n      processedResult = result;\n    }\n    return processedResult;\n  }\n\n  async function drainAsyncGeneratorToArray<T>(\n    collection: AsyncGenerator<T, void, void>,\n  ): Promise<T[]> {\n    const result: T[] = [];\n    await forAwaitEach(collection, (item) => result.push(item));\n    return result;\n  }\n\n  return {\n    compareResultForExecuteWithoutSchemaWithMVSAnnotation,\n    compareResultsForExecuteWithSchema,\n    drainExecution,\n    graphqlExecuteOrSubscribe,\n  };\n}\n"],
+  "mappings": "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",
   "names": ["resolvers", "models"]
 }

package/lib/__testUtils__/execute.mjs

@@ -59,11 +59,8 @@ function createExecutionUtils(graphqlExecute, graphqlSubscribe) {
       const result = yield drainExecution(
         yield executeWithSchema({
           document,
-          schema: {
-            schemaId: "test",
-            definitions: typeDefs,
-            resolvers
-          },
+          definitions: typeDefs,
+          resolvers,
           contextValue: {
             models
           },

package/lib/__testUtils__/execute.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/__testUtils__/execute.ts"],
-  "sourcesContent": ["import {\n  DocumentNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n  OperationTypeNode,\n  parse,\n  ExecutionArgs,\n  ExecutionArgs as GraphQLExecutionArgs,\n  ExecutionResult as GraphQLExecutionResult,\n} from \"graphql\";\nimport { executeWithSchema } from \"../executeWithSchema\";\nimport { typeDefs } from \"../benchmarks/swapi-schema\";\nimport resolvers from \"../benchmarks/swapi-schema/resolvers\";\nimport { ExecutionResult, UserResolvers } from \"../types\";\nimport models from \"../benchmarks/swapi-schema/models\";\nimport { executeWithoutSchema } from \"../executeWithoutSchema\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { PromiseOrValue } from \"graphql/jsutils/PromiseOrValue\";\nimport { ObjMap } from \"../jsutils/ObjMap\";\nimport { forAwaitEach, isAsyncIterable } from \"iterall\";\n\ntype GraphQLResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> =\n  | GraphQLExecutionResult<TData, TExtensions>\n  | AsyncGenerator<GraphQLExecutionResult<TData, TExtensions>, void, void>;\n\nexport function createExecutionUtils(\n  graphqlExecute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>,\n  graphqlSubscribe: (\n    args: ExecutionArgs,\n  ) => PromiseOrValue<\n    AsyncGenerator<ExecutionResult, void, void> | ExecutionResult\n  >,\n) {\n  async function compareResultsForExecuteWithSchema(\n    schema: GraphQLSchema,\n    query: string,\n    variables?: Record<string, unknown>,\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const result = await drainExecution(\n      await executeWithSchema({\n        document,\n        schema: {\n          schemaId: \"test\",\n          definitions: typeDefs,\n          resolvers: resolvers as UserResolvers<unknown, unknown>,\n        },\n        contextValue: {\n          models,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  async function compareResultForExecuteWithoutSchemaWithMVSAnnotation(\n    schema: GraphQLSchema,\n    query: string,\n    variables: Record<string, unknown> = {},\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const { definitions } = extractMinimalViableSchemaForRequestDocument(\n      schema,\n      document,\n    );\n    const result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        schemaFragment: {\n          schemaId: \"test\",\n          definitions,\n          resolvers: resolvers as UserResolvers,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  function graphqlExecuteOrSubscribe(\n    args: GraphQLExecutionArgs,\n  ): PromiseOrValue<GraphQLResult> {\n    const operationName = args.operationName;\n    let operation: OperationDefinitionNode | undefined;\n    for (const definition of (args.document as unknown as DocumentNode)\n      .definitions) {\n      switch (definition.kind) {\n        case Kind.OPERATION_DEFINITION:\n          if (operationName == null) {\n            if (operation !== undefined) {\n              throw new Error(\"Bad operation in test\");\n            }\n            operation = definition;\n          } else if (definition.name?.value === operationName) {\n            operation = definition;\n          }\n          break;\n      }\n    }\n    if (!operation) {\n      throw new Error(\"Bad operation in test\");\n    }\n\n    if (operation.operation === OperationTypeNode.SUBSCRIPTION) {\n      return graphqlSubscribe(args) as GraphQLResult;\n    } else {\n      return graphqlExecute(args) as GraphQLResult;\n    }\n  }\n\n  async function drainExecution(\n    result: ExecutionResult | GraphQLResult,\n  ): Promise<unknown> {\n    let processedResult;\n    if (isAsyncIterable(result)) {\n      processedResult = await drainAsyncGeneratorToArray(result);\n    } else if (\"subsequentResults\" in result) {\n      processedResult = {\n        ...result,\n        subsequentResults: await drainAsyncGeneratorToArray(\n          result.subsequentResults,\n        ),\n      };\n    } else {\n      processedResult = result;\n    }\n    return processedResult;\n  }\n\n  async function drainAsyncGeneratorToArray<T>(\n    collection: AsyncGenerator<T, void, void>,\n  ): Promise<T[]> {\n    const result: T[] = [];\n    await forAwaitEach(collection, (item) => result.push(item));\n    return result;\n  }\n\n  return {\n    compareResultForExecuteWithoutSchemaWithMVSAnnotation,\n    compareResultsForExecuteWithSchema,\n    drainExecution,\n    graphqlExecuteOrSubscribe,\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  DocumentNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n  OperationTypeNode,\n  parse,\n  ExecutionArgs,\n  ExecutionArgs as GraphQLExecutionArgs,\n  ExecutionResult as GraphQLExecutionResult,\n} from \"graphql\";\nimport { executeWithSchema } from \"../executeWithSchema\";\nimport { typeDefs } from \"../benchmarks/swapi-schema\";\nimport resolvers from \"../benchmarks/swapi-schema/resolvers\";\nimport { ExecutionResult, UserResolvers } from \"../types\";\nimport models from \"../benchmarks/swapi-schema/models\";\nimport { executeWithoutSchema } from \"../executeWithoutSchema\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { PromiseOrValue } from \"graphql/jsutils/PromiseOrValue\";\nimport { ObjMap } from \"../jsutils/ObjMap\";\nimport { forAwaitEach, isAsyncIterable } from \"iterall\";\n\ntype GraphQLResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> =\n  | GraphQLExecutionResult<TData, TExtensions>\n  | AsyncGenerator<GraphQLExecutionResult<TData, TExtensions>, void, void>;\n\nexport function createExecutionUtils(\n  graphqlExecute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>,\n  graphqlSubscribe: (\n    args: ExecutionArgs,\n  ) => PromiseOrValue<\n    AsyncGenerator<ExecutionResult, void, void> | ExecutionResult\n  >,\n) {\n  async function compareResultsForExecuteWithSchema(\n    schema: GraphQLSchema,\n    query: string,\n    variables?: Record<string, unknown>,\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const result = await drainExecution(\n      await executeWithSchema({\n        document,\n        definitions: typeDefs,\n        resolvers: resolvers as UserResolvers<unknown, unknown>,\n        contextValue: {\n          models,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  async function compareResultForExecuteWithoutSchemaWithMVSAnnotation(\n    schema: GraphQLSchema,\n    query: string,\n    variables: Record<string, unknown> = {},\n  ) {\n    expect.assertions(1);\n    const document = parse(query);\n    const { definitions } = extractMinimalViableSchemaForRequestDocument(\n      schema,\n      document,\n    );\n    const result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        schemaFragment: {\n          schemaId: \"test\",\n          definitions,\n          resolvers: resolvers as UserResolvers,\n        },\n        variableValues: variables,\n      }),\n    );\n    const validResult = await drainExecution(\n      await graphqlExecuteOrSubscribe({\n        document,\n        contextValue: {\n          models,\n        },\n        schema,\n        variableValues: variables,\n      }),\n    );\n    expect(result).toEqual(validResult);\n  }\n\n  function graphqlExecuteOrSubscribe(\n    args: GraphQLExecutionArgs,\n  ): PromiseOrValue<GraphQLResult> {\n    const operationName = args.operationName;\n    let operation: OperationDefinitionNode | undefined;\n    for (const definition of (args.document as unknown as DocumentNode)\n      .definitions) {\n      switch (definition.kind) {\n        case Kind.OPERATION_DEFINITION:\n          if (operationName == null) {\n            if (operation !== undefined) {\n              throw new Error(\"Bad operation in test\");\n            }\n            operation = definition;\n          } else if (definition.name?.value === operationName) {\n            operation = definition;\n          }\n          break;\n      }\n    }\n    if (!operation) {\n      throw new Error(\"Bad operation in test\");\n    }\n\n    if (operation.operation === OperationTypeNode.SUBSCRIPTION) {\n      return graphqlSubscribe(args) as GraphQLResult;\n    } else {\n      return graphqlExecute(args) as GraphQLResult;\n    }\n  }\n\n  async function drainExecution(\n    result: ExecutionResult | GraphQLResult,\n  ): Promise<unknown> {\n    let processedResult;\n    if (isAsyncIterable(result)) {\n      processedResult = await drainAsyncGeneratorToArray(result);\n    } else if (\"subsequentResults\" in result) {\n      processedResult = {\n        ...result,\n        subsequentResults: await drainAsyncGeneratorToArray(\n          result.subsequentResults,\n        ),\n      };\n    } else {\n      processedResult = result;\n    }\n    return processedResult;\n  }\n\n  async function drainAsyncGeneratorToArray<T>(\n    collection: AsyncGenerator<T, void, void>,\n  ): Promise<T[]> {\n    const result: T[] = [];\n    await forAwaitEach(collection, (item) => result.push(item));\n    return result;\n  }\n\n  return {\n    compareResultForExecuteWithoutSchemaWithMVSAnnotation,\n    compareResultsForExecuteWithSchema,\n    drainExecution,\n    graphqlExecuteOrSubscribe,\n  };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA,EAGE;AAAA,EAEA;AAAA,EACA;AAAA,OAIK;AACP,SAAS,yBAAyB;AAClC,SAAS,gBAAgB;AACzB,OAAO,eAAe;AAEtB,OAAO,YAAY;AACnB,SAAS,4BAA4B;AACrC,SAAS,oDAAoD;AAG7D,SAAS,cAAc,uBAAuB;AAMvC,SAAS,qBACd,gBACA,kBAKA;AACA,WAAe,mCACb,QACA,OACA,WACA;AAAA;AACA,aAAO,WAAW,CAAC;AACnB,YAAM,WAAW,MAAM,KAAK;AAC5B,YAAM,SAAS,MAAM;AAAA,QACnB,MAAM,kBAAkB;AAAA,UACtB;AAAA,UACA,aAAa;AAAA,UACb;AAAA,UACA,cAAc;AAAA,YACZ;AAAA,UACF;AAAA,UACA,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH;AACA,YAAM,cAAc,MAAM;AAAA,QACxB,MAAM,0BAA0B;AAAA,UAC9B;AAAA,UACA,cAAc;AAAA,YACZ;AAAA,UACF;AAAA,UACA;AAAA,UACA,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH;AACA,aAAO,MAAM,EAAE,QAAQ,WAAW;AAAA,IACpC;AAAA;AAEA,WAAe,sDACb,IACA,IAEA;AAAA,+CAHA,QACA,OACA,YAAqC,CAAC,GACtC;AACA,aAAO,WAAW,CAAC;AACnB,YAAM,WAAW,MAAM,KAAK;AAC5B,YAAM,EAAE,YAAY,IAAI;AAAA,QACtB;AAAA,QACA;AAAA,MACF;AACA,YAAM,SAAS,MAAM;AAAA,QACnB,MAAM,qBAAqB;AAAA,UACzB;AAAA,UACA,cAAc;AAAA,YACZ;AAAA,UACF;AAAA,UACA,gBAAgB;AAAA,YACd,UAAU;AAAA,YACV;AAAA,YACA;AAAA,UACF;AAAA,UACA,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH;AACA,YAAM,cAAc,MAAM;AAAA,QACxB,MAAM,0BAA0B;AAAA,UAC9B;AAAA,UACA,cAAc;AAAA,YACZ;AAAA,UACF;AAAA,UACA;AAAA,UACA,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH;AACA,aAAO,MAAM,EAAE,QAAQ,WAAW;AAAA,IACpC;AAAA;AAEA,WAAS,0BACP,MAC+B;AAzGnC;AA0GI,UAAM,gBAAgB,KAAK;AAC3B,QAAI;AACJ,eAAW,cAAe,KAAK,SAC5B,aAAa;AACd,cAAQ,WAAW,MAAM;AAAA,QACvB,KAAK,KAAK;AACR,cAAI,iBAAiB,MAAM;AACzB,gBAAI,cAAc,QAAW;AAC3B,oBAAM,IAAI,MAAM,uBAAuB;AAAA,YACzC;AACA,wBAAY;AAAA,UACd,aAAW,gBAAW,SAAX,mBAAiB,WAAU,eAAe;AACnD,wBAAY;AAAA,UACd;AACA;AAAA,MACJ;AAAA,IACF;AACA,QAAI,CAAC,WAAW;AACd,YAAM,IAAI,MAAM,uBAAuB;AAAA,IACzC;AAEA,QAAI,UAAU,cAAc,kBAAkB,cAAc;AAC1D,aAAO,iBAAiB,IAAI;AAAA,IAC9B,OAAO;AACL,aAAO,eAAe,IAAI;AAAA,IAC5B;AAAA,EACF;AAEA,WAAe,eACb,QACkB;AAAA;AAClB,UAAI;AACJ,UAAI,gBAAgB,MAAM,GAAG;AAC3B,0BAAkB,MAAM,2BAA2B,MAAM;AAAA,MAC3D,WAAW,uBAAuB,QAAQ;AACxC,0BAAkB,iCACb,SADa;AAAA,UAEhB,mBAAmB,MAAM;AAAA,YACvB,OAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF,OAAO;AACL,0BAAkB;AAAA,MACpB;AACA,aAAO;AAAA,IACT;AAAA;AAEA,WAAe,2BACb,YACc;AAAA;AACd,YAAM,SAAc,CAAC;AACrB,YAAM,aAAa,YAAY,CAAC,SAAS,OAAO,KAAK,IAAI,CAAC;AAC1D,aAAO;AAAA,IACT;AAAA;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
   "names": []
 }

package/lib/benchmarks/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/benchmarks/index.ts"],
-  "sourcesContent": ["import fs from \"fs\";\nimport path from \"path\";\nimport NiceBenchmark from \"./nice-benchmark\";\nimport schema from \"./swapi-schema\";\nimport resolvers from \"./swapi-schema/resolvers\";\nimport models from \"./swapi-schema/models\";\nimport {\n  execute as graphqlExecute,\n  parse,\n  // experimentalExecuteIncrementally as graphqlExecute,\n} from \"graphql\";\nimport { compileQuery, isCompiledQuery } from \"graphql-jit\";\nimport { executeWithoutSchema as supermassiveExecute } from \"../executeWithoutSchema\";\nimport { UserResolvers } from \"../types\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { SchemaFragment } from \"../schema/fragment\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst { definitions } = extractMinimalViableSchemaForRequestDocument(\n  schema,\n  parsedQuery,\n);\n\nconst schemaFragment: SchemaFragment = {\n  schemaId: \"benchmark\",\n  definitions,\n  resolvers: resolvers as UserResolvers,\n};\n\nconst queryRunningSuite = new NiceBenchmark(\"Query Running\");\nqueryRunningSuite.add(\"graphql-js - string queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parse(query),\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-js - parsed queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - uncompiled\", async () => {\n  const freshCompiledQuery = compileQuery(schema, parsedQuery);\n  if (isCompiledQuery(freshCompiledQuery)) {\n    const result = await freshCompiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - precompiled\", async () => {\n  if (isCompiledQuery(compiledQuery)) {\n    const result = await compiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"supermassive - runtime schemaless\", async () => {\n  const result = await supermassiveExecute({\n    schemaFragment,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (\"data\" in result && (result.errors || !result.data)) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\n\nconst queryParsingSuite = new NiceBenchmark(\"Query parsing\");\nqueryParsingSuite.add(\"graphql-js\", async () => {\n  parse(query);\n});\n\nconst queryCompilingSuite = new NiceBenchmark(\"Query compiling\");\nqueryCompilingSuite.add(\"graphql-jit\", async () => {\n  await compileQuery(schema, parsedQuery);\n});\n\nconst queryAnnotationSuite = new NiceBenchmark(\"Query annotation\");\nqueryAnnotationSuite.add(\"supermassive\", () => {\n  extractMinimalViableSchemaForRequestDocument(schema, parsedQuery);\n});\n\nasync function main() {\n  await queryCompilingSuite.run();\n  await queryParsingSuite.run();\n  await queryAnnotationSuite.run();\n  await queryRunningSuite.run();\n}\n\nmain();\n"],
-  "mappings": "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",
+  "sourcesContent": ["import fs from \"fs\";\nimport path from \"path\";\nimport NiceBenchmark from \"./nice-benchmark\";\nimport schema from \"./swapi-schema\";\nimport resolvers from \"./swapi-schema/resolvers\";\nimport models from \"./swapi-schema/models\";\nimport {\n  execute as graphqlExecute,\n  parse,\n  // experimentalExecuteIncrementally as graphqlExecute,\n} from \"graphql\";\nimport { compileQuery, isCompiledQuery } from \"graphql-jit\";\nimport { executeWithoutSchema as supermassiveExecute } from \"../executeWithoutSchema\";\nimport { UserResolvers, SchemaFragment } from \"../types\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst { definitions } = extractMinimalViableSchemaForRequestDocument(\n  schema,\n  parsedQuery,\n);\n\nconst schemaFragment: SchemaFragment = {\n  schemaId: \"benchmark\",\n  definitions,\n  resolvers: resolvers as UserResolvers,\n};\n\nconst queryRunningSuite = new NiceBenchmark(\"Query Running\");\nqueryRunningSuite.add(\"graphql-js - string queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parse(query),\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-js - parsed queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - uncompiled\", async () => {\n  const freshCompiledQuery = compileQuery(schema, parsedQuery);\n  if (isCompiledQuery(freshCompiledQuery)) {\n    const result = await freshCompiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - precompiled\", async () => {\n  if (isCompiledQuery(compiledQuery)) {\n    const result = await compiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"supermassive - runtime schemaless\", async () => {\n  const result = await supermassiveExecute({\n    schemaFragment,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (\"data\" in result && (result.errors || !result.data)) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\n\nconst queryParsingSuite = new NiceBenchmark(\"Query parsing\");\nqueryParsingSuite.add(\"graphql-js\", async () => {\n  parse(query);\n});\n\nconst queryCompilingSuite = new NiceBenchmark(\"Query compiling\");\nqueryCompilingSuite.add(\"graphql-jit\", async () => {\n  await compileQuery(schema, parsedQuery);\n});\n\nconst queryAnnotationSuite = new NiceBenchmark(\"Query annotation\");\nqueryAnnotationSuite.add(\"supermassive\", () => {\n  extractMinimalViableSchemaForRequestDocument(schema, parsedQuery);\n});\n\nasync function main() {\n  await queryCompilingSuite.run();\n  await queryParsingSuite.run();\n  await queryAnnotationSuite.run();\n  await queryRunningSuite.run();\n}\n\nmain();\n"],
+  "mappings": "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",
   "names": ["fs", "path", "schema", "resolvers", "NiceBenchmark", "graphqlExecute", "models", "supermassiveExecute"]
 }

package/lib/benchmarks/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/benchmarks/index.ts"],
-  "sourcesContent": ["import fs from \"fs\";\nimport path from \"path\";\nimport NiceBenchmark from \"./nice-benchmark\";\nimport schema from \"./swapi-schema\";\nimport resolvers from \"./swapi-schema/resolvers\";\nimport models from \"./swapi-schema/models\";\nimport {\n  execute as graphqlExecute,\n  parse,\n  // experimentalExecuteIncrementally as graphqlExecute,\n} from \"graphql\";\nimport { compileQuery, isCompiledQuery } from \"graphql-jit\";\nimport { executeWithoutSchema as supermassiveExecute } from \"../executeWithoutSchema\";\nimport { UserResolvers } from \"../types\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\nimport { SchemaFragment } from \"../schema/fragment\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst { definitions } = extractMinimalViableSchemaForRequestDocument(\n  schema,\n  parsedQuery,\n);\n\nconst schemaFragment: SchemaFragment = {\n  schemaId: \"benchmark\",\n  definitions,\n  resolvers: resolvers as UserResolvers,\n};\n\nconst queryRunningSuite = new NiceBenchmark(\"Query Running\");\nqueryRunningSuite.add(\"graphql-js - string queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parse(query),\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-js - parsed queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - uncompiled\", async () => {\n  const freshCompiledQuery = compileQuery(schema, parsedQuery);\n  if (isCompiledQuery(freshCompiledQuery)) {\n    const result = await freshCompiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - precompiled\", async () => {\n  if (isCompiledQuery(compiledQuery)) {\n    const result = await compiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"supermassive - runtime schemaless\", async () => {\n  const result = await supermassiveExecute({\n    schemaFragment,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (\"data\" in result && (result.errors || !result.data)) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\n\nconst queryParsingSuite = new NiceBenchmark(\"Query parsing\");\nqueryParsingSuite.add(\"graphql-js\", async () => {\n  parse(query);\n});\n\nconst queryCompilingSuite = new NiceBenchmark(\"Query compiling\");\nqueryCompilingSuite.add(\"graphql-jit\", async () => {\n  await compileQuery(schema, parsedQuery);\n});\n\nconst queryAnnotationSuite = new NiceBenchmark(\"Query annotation\");\nqueryAnnotationSuite.add(\"supermassive\", () => {\n  extractMinimalViableSchemaForRequestDocument(schema, parsedQuery);\n});\n\nasync function main() {\n  await queryCompilingSuite.run();\n  await queryParsingSuite.run();\n  await queryAnnotationSuite.run();\n  await queryRunningSuite.run();\n}\n\nmain();\n"],
-  "mappings": "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",
+  "sourcesContent": ["import fs from \"fs\";\nimport path from \"path\";\nimport NiceBenchmark from \"./nice-benchmark\";\nimport schema from \"./swapi-schema\";\nimport resolvers from \"./swapi-schema/resolvers\";\nimport models from \"./swapi-schema/models\";\nimport {\n  execute as graphqlExecute,\n  parse,\n  // experimentalExecuteIncrementally as graphqlExecute,\n} from \"graphql\";\nimport { compileQuery, isCompiledQuery } from \"graphql-jit\";\nimport { executeWithoutSchema as supermassiveExecute } from \"../executeWithoutSchema\";\nimport { UserResolvers, SchemaFragment } from \"../types\";\nimport { extractMinimalViableSchemaForRequestDocument } from \"../utilities/extractMinimalViableSchemaForRequestDocument\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst { definitions } = extractMinimalViableSchemaForRequestDocument(\n  schema,\n  parsedQuery,\n);\n\nconst schemaFragment: SchemaFragment = {\n  schemaId: \"benchmark\",\n  definitions,\n  resolvers: resolvers as UserResolvers,\n};\n\nconst queryRunningSuite = new NiceBenchmark(\"Query Running\");\nqueryRunningSuite.add(\"graphql-js - string queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parse(query),\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-js - parsed queries\", async () => {\n  const result = await graphqlExecute({\n    schema,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (result.errors || !result.data) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - uncompiled\", async () => {\n  const freshCompiledQuery = compileQuery(schema, parsedQuery);\n  if (isCompiledQuery(freshCompiledQuery)) {\n    const result = await freshCompiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"graphql-jit - precompiled\", async () => {\n  if (isCompiledQuery(compiledQuery)) {\n    const result = await compiledQuery.query({}, { models }, {});\n    if (result.errors || !result.data) {\n      throw new Error(\"Stuff ain't executing\");\n    }\n  } else {\n    throw new Error(\"Wrong query\");\n  }\n});\nqueryRunningSuite.add(\"supermassive - runtime schemaless\", async () => {\n  const result = await supermassiveExecute({\n    schemaFragment,\n    document: parsedQuery,\n    contextValue: { models },\n  });\n  if (\"data\" in result && (result.errors || !result.data)) {\n    throw new Error(\"Stuff ain't executing\");\n  }\n});\n\nconst queryParsingSuite = new NiceBenchmark(\"Query parsing\");\nqueryParsingSuite.add(\"graphql-js\", async () => {\n  parse(query);\n});\n\nconst queryCompilingSuite = new NiceBenchmark(\"Query compiling\");\nqueryCompilingSuite.add(\"graphql-jit\", async () => {\n  await compileQuery(schema, parsedQuery);\n});\n\nconst queryAnnotationSuite = new NiceBenchmark(\"Query annotation\");\nqueryAnnotationSuite.add(\"supermassive\", () => {\n  extractMinimalViableSchemaForRequestDocument(schema, parsedQuery);\n});\n\nasync function main() {\n  await queryCompilingSuite.run();\n  await queryParsingSuite.run();\n  await queryAnnotationSuite.run();\n  await queryRunningSuite.run();\n}\n\nmain();\n"],
+  "mappings": "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",
   "names": []
 }

package/lib/collectFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collectFields.d.ts","sourceRoot":"","sources":["../src/collectFields.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAMV,MAAM,SAAS,CAAC;AAUjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,eAAe,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,gBAAgB,EAC5B,eAAe,EAAE,MAAM,GACtB,gBAAgB,CAalB;AAED;;;;;;;;;GASG;AAEH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,UAAU,GACrB,gBAAgB,CAuBlB"}
+{"version":3,"file":"collectFields.d.ts","sourceRoot":"","sources":["../src/collectFields.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAMV,MAAM,SAAS,CAAC;AAUjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI1D,MAAM,MAAM,UAAU,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,eAAe,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,gBAAgB,EAC5B,eAAe,EAAE,MAAM,GACtB,gBAAgB,CAalB;AAED;;;;;;;;;GASG;AAEH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,UAAU,GACrB,gBAAgB,CAuBlB"}

package/lib/collectFields.js

@@ -37,6 +37,7 @@ var import_values = require("./values");
 var import_directives = require("./schema/directives");
 var import_AccumulatorMap = require("./jsutils/AccumulatorMap");
 var import_invariant = __toESM(require("invariant"));
+var import_definition = require("./schema/definition");
 function collectFields(exeContext, runtimeTypeName) {
   const { operation } = exeContext;
   const groupedFieldSet = new import_AccumulatorMap.AccumulatorMap();
@@ -87,7 +88,7 @@ function collectFieldsImpl(exeContext, runtimeTypeName, selectionSet, groupedFie
         if (!shouldIncludeNode(exeContext, selection) || !doesFragmentConditionMatch(
           selection,
           runtimeTypeName,
-          exeContext.partialSchema
+          exeContext.schemaFragment
         )) {
           continue;
         }
@@ -131,7 +132,7 @@ function collectFieldsImpl(exeContext, runtimeTypeName, selectionSet, groupedFie
         if (fragment == null || !doesFragmentConditionMatch(
           fragment,
           runtimeTypeName,
-          exeContext.partialSchema
+          exeContext.schemaFragment
         )) {
           continue;
         }
@@ -182,7 +183,7 @@ function shouldIncludeNode(exeContext, node) {
   }
   return true;
 }
-function doesFragmentConditionMatch(fragment, typeName, schemaFragment) {
+function doesFragmentConditionMatch(fragment, typeName, { definitions }) {
   const typeConditionNode = fragment.typeCondition;
   if (!typeConditionNode) {
     return true;
@@ -191,8 +192,8 @@ function doesFragmentConditionMatch(fragment, typeName, schemaFragment) {
   if (conditionalTypeName === typeName) {
     return true;
   }
-  if (schemaFragment.isAbstractType(conditionalTypeName)) {
-    return schemaFragment.isSubType(conditionalTypeName, typeName);
+  if ((0, import_definition.isAbstractType)(definitions, conditionalTypeName)) {
+    return (0, import_definition.isSubType)(definitions, conditionalTypeName, typeName);
   }
   return false;
 }

package/lib/collectFields.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/collectFields.ts"],
-  "sourcesContent": ["import {\n  Kind,\n  FieldNode,\n  FragmentDefinitionNode,\n  FragmentSpreadNode,\n  InlineFragmentNode,\n  SelectionNode,\n  SelectionSetNode,\n} from \"graphql\";\nimport { getDirectiveValues } from \"./values\";\nimport {\n  GraphQLSkipDirective,\n  GraphQLIncludeDirective,\n  GraphQLDeferDirective,\n} from \"./schema/directives\";\n\nimport { AccumulatorMap } from \"./jsutils/AccumulatorMap\";\nimport invariant from \"invariant\";\nimport { ExecutionContext } from \"./executeWithoutSchema\";\nimport { PartialSchema } from \"./schema/fragment\";\n\nexport type FieldGroup = ReadonlyArray<FieldNode>;\n\nexport type GroupedFieldSet = Map<string, FieldGroup>;\n\nexport interface PatchFields {\n  label: string | undefined;\n  groupedFieldSet: GroupedFieldSet;\n}\n\nexport interface FieldsAndPatches {\n  groupedFieldSet: GroupedFieldSet;\n  patches: Array<PatchFields>;\n}\n\n/**\n * Given a selectionSet, collects all of the fields and returns them.\n *\n * CollectFields requires the \"runtime type\" of an object. For a field that\n * returns an Interface or Union type, the \"runtime type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\nexport function collectFields(\n  exeContext: ExecutionContext,\n  runtimeTypeName: string,\n): FieldsAndPatches {\n  const { operation } = exeContext;\n  const groupedFieldSet = new AccumulatorMap<string, FieldNode>();\n  const patches: Array<PatchFields> = [];\n  collectFieldsImpl(\n    exeContext,\n    runtimeTypeName,\n    operation.selectionSet,\n    groupedFieldSet,\n    patches,\n    new Set(),\n  );\n  return { groupedFieldSet, patches };\n}\n\n/**\n * Given an array of field nodes, collects all of the subfields of the passed\n * in fields, and returns them at the end.\n *\n * CollectSubFields requires the \"return type\" of an object. For a field that\n * returns an Interface or Union type, the \"return type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\n// eslint-disable-next-line max-params\nexport function collectSubfields(\n  exeContext: ExecutionContext,\n  returnTypeName: string,\n  fieldGroup: FieldGroup,\n): FieldsAndPatches {\n  const subGroupedFieldSet = new AccumulatorMap<string, FieldNode>();\n  const visitedFragmentNames = new Set<string>();\n\n  const subPatches: Array<PatchFields> = [];\n  const subFieldsAndPatches = {\n    groupedFieldSet: subGroupedFieldSet,\n    patches: subPatches,\n  };\n\n  for (const node of fieldGroup) {\n    if (node.selectionSet) {\n      collectFieldsImpl(\n        exeContext,\n        returnTypeName,\n        node.selectionSet,\n        subGroupedFieldSet,\n        subPatches,\n        visitedFragmentNames,\n      );\n    }\n  }\n  return subFieldsAndPatches;\n}\n\n// eslint-disable-next-line max-params\nfunction collectFieldsImpl(\n  exeContext: ExecutionContext,\n  runtimeTypeName: string,\n  selectionSet: SelectionSetNode,\n  groupedFieldSet: AccumulatorMap<string, FieldNode>,\n  patches: Array<PatchFields>,\n  visitedFragmentNames: Set<string>,\n): void {\n  for (const selection of selectionSet.selections) {\n    switch (selection.kind) {\n      case Kind.FIELD: {\n        if (!shouldIncludeNode(exeContext, selection)) {\n          continue;\n        }\n        groupedFieldSet.add(getFieldEntryKey(selection), selection);\n        break;\n      }\n      case Kind.INLINE_FRAGMENT: {\n        if (\n          !shouldIncludeNode(exeContext, selection) ||\n          !doesFragmentConditionMatch(\n            selection,\n            runtimeTypeName,\n            exeContext.partialSchema,\n          )\n        ) {\n          continue;\n        }\n\n        const defer = getDeferValues(exeContext, selection);\n\n        if (defer) {\n          const patchFields = new AccumulatorMap<string, FieldNode>();\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            selection.selectionSet,\n            patchFields,\n            patches,\n            visitedFragmentNames,\n          );\n          patches.push({\n            label: defer.label,\n            groupedFieldSet: patchFields,\n          });\n        } else {\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            selection.selectionSet,\n            groupedFieldSet,\n            patches,\n            visitedFragmentNames,\n          );\n        }\n        break;\n      }\n      case Kind.FRAGMENT_SPREAD: {\n        const fragName = selection.name.value;\n\n        if (!shouldIncludeNode(exeContext, selection)) {\n          continue;\n        }\n\n        const defer = getDeferValues(exeContext, selection);\n        if (visitedFragmentNames.has(fragName) && !defer) {\n          continue;\n        }\n\n        const fragment = exeContext.fragments[fragName];\n        if (\n          fragment == null ||\n          !doesFragmentConditionMatch(\n            fragment,\n            runtimeTypeName,\n            exeContext.partialSchema,\n          )\n        ) {\n          continue;\n        }\n\n        if (!defer) {\n          visitedFragmentNames.add(fragName);\n        }\n\n        if (defer) {\n          const patchFields = new AccumulatorMap<string, FieldNode>();\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            fragment.selectionSet,\n            patchFields,\n            patches,\n            visitedFragmentNames,\n          );\n          patches.push({\n            label: defer.label,\n            groupedFieldSet: patchFields,\n          });\n        } else {\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            fragment.selectionSet,\n            groupedFieldSet,\n            patches,\n            visitedFragmentNames,\n          );\n        }\n        break;\n      }\n    }\n  }\n}\n\n/**\n * Determines if a field should be included based on the @include and @skip\n * directives, where @skip has higher precedence than @include.\n */\nfunction shouldIncludeNode(\n  exeContext: ExecutionContext,\n  node: SelectionNode,\n): boolean {\n  if (!node.directives?.length) {\n    return true;\n  }\n\n  const skip = getDirectiveValues(exeContext, GraphQLSkipDirective, node);\n  if (skip?.if === true) {\n    return false;\n  }\n\n  const include = getDirectiveValues(exeContext, GraphQLIncludeDirective, node);\n  if (include?.if === false) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a fragment is applicable to the given type.\n */\nfunction doesFragmentConditionMatch(\n  fragment: FragmentDefinitionNode | InlineFragmentNode,\n  typeName: string,\n  // resolvers: Resolvers,\n  schemaFragment: PartialSchema,\n): boolean {\n  const typeConditionNode = fragment.typeCondition;\n  if (!typeConditionNode) {\n    return true;\n  }\n\n  const conditionalTypeName = typeConditionNode.name.value;\n\n  if (conditionalTypeName === typeName) {\n    return true;\n  }\n  if (schemaFragment.isAbstractType(conditionalTypeName)) {\n    return schemaFragment.isSubType(conditionalTypeName, typeName);\n  }\n  return false;\n}\n\n/**\n * Implements the logic to compute the key of a given field's entry\n */\nfunction getFieldEntryKey(node: FieldNode): string {\n  return node.alias ? node.alias.value : node.name.value;\n}\n\n/**\n * Returns an object containing the `@defer` arguments if a field should be\n * deferred based on the experimental flag, defer directive present and\n * not disabled by the \"if\" argument.\n */\nfunction getDeferValues(\n  exeContext: ExecutionContext,\n  node: FragmentSpreadNode | InlineFragmentNode,\n): undefined | { label: string | undefined } {\n  const defer = getDirectiveValues(exeContext, GraphQLDeferDirective, node);\n\n  if (!defer) {\n    return;\n  }\n\n  if (defer.if === false) {\n    return;\n  }\n\n  invariant(\n    exeContext.operation.operation !== \"subscription\",\n    \"`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.\",\n  );\n\n  return {\n    label: typeof defer.label === \"string\" ? defer.label : undefined,\n  };\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import {\n  Kind,\n  FieldNode,\n  FragmentDefinitionNode,\n  FragmentSpreadNode,\n  InlineFragmentNode,\n  SelectionNode,\n  SelectionSetNode,\n} from \"graphql\";\nimport { getDirectiveValues } from \"./values\";\nimport {\n  GraphQLSkipDirective,\n  GraphQLIncludeDirective,\n  GraphQLDeferDirective,\n} from \"./schema/directives\";\n\nimport { AccumulatorMap } from \"./jsutils/AccumulatorMap\";\nimport invariant from \"invariant\";\nimport { ExecutionContext } from \"./executeWithoutSchema\";\nimport { isAbstractType, isSubType } from \"./schema/definition\";\nimport { SchemaFragment } from \"./types\";\n\nexport type FieldGroup = ReadonlyArray<FieldNode>;\n\nexport type GroupedFieldSet = Map<string, FieldGroup>;\n\nexport interface PatchFields {\n  label: string | undefined;\n  groupedFieldSet: GroupedFieldSet;\n}\n\nexport interface FieldsAndPatches {\n  groupedFieldSet: GroupedFieldSet;\n  patches: Array<PatchFields>;\n}\n\n/**\n * Given a selectionSet, collects all of the fields and returns them.\n *\n * CollectFields requires the \"runtime type\" of an object. For a field that\n * returns an Interface or Union type, the \"runtime type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\nexport function collectFields(\n  exeContext: ExecutionContext,\n  runtimeTypeName: string,\n): FieldsAndPatches {\n  const { operation } = exeContext;\n  const groupedFieldSet = new AccumulatorMap<string, FieldNode>();\n  const patches: Array<PatchFields> = [];\n  collectFieldsImpl(\n    exeContext,\n    runtimeTypeName,\n    operation.selectionSet,\n    groupedFieldSet,\n    patches,\n    new Set(),\n  );\n  return { groupedFieldSet, patches };\n}\n\n/**\n * Given an array of field nodes, collects all of the subfields of the passed\n * in fields, and returns them at the end.\n *\n * CollectSubFields requires the \"return type\" of an object. For a field that\n * returns an Interface or Union type, the \"return type\" will be the actual\n * object type returned by that field.\n *\n * @internal\n */\n// eslint-disable-next-line max-params\nexport function collectSubfields(\n  exeContext: ExecutionContext,\n  returnTypeName: string,\n  fieldGroup: FieldGroup,\n): FieldsAndPatches {\n  const subGroupedFieldSet = new AccumulatorMap<string, FieldNode>();\n  const visitedFragmentNames = new Set<string>();\n\n  const subPatches: Array<PatchFields> = [];\n  const subFieldsAndPatches = {\n    groupedFieldSet: subGroupedFieldSet,\n    patches: subPatches,\n  };\n\n  for (const node of fieldGroup) {\n    if (node.selectionSet) {\n      collectFieldsImpl(\n        exeContext,\n        returnTypeName,\n        node.selectionSet,\n        subGroupedFieldSet,\n        subPatches,\n        visitedFragmentNames,\n      );\n    }\n  }\n  return subFieldsAndPatches;\n}\n\n// eslint-disable-next-line max-params\nfunction collectFieldsImpl(\n  exeContext: ExecutionContext,\n  runtimeTypeName: string,\n  selectionSet: SelectionSetNode,\n  groupedFieldSet: AccumulatorMap<string, FieldNode>,\n  patches: Array<PatchFields>,\n  visitedFragmentNames: Set<string>,\n): void {\n  for (const selection of selectionSet.selections) {\n    switch (selection.kind) {\n      case Kind.FIELD: {\n        if (!shouldIncludeNode(exeContext, selection)) {\n          continue;\n        }\n        groupedFieldSet.add(getFieldEntryKey(selection), selection);\n        break;\n      }\n      case Kind.INLINE_FRAGMENT: {\n        if (\n          !shouldIncludeNode(exeContext, selection) ||\n          !doesFragmentConditionMatch(\n            selection,\n            runtimeTypeName,\n            exeContext.schemaFragment,\n          )\n        ) {\n          continue;\n        }\n\n        const defer = getDeferValues(exeContext, selection);\n\n        if (defer) {\n          const patchFields = new AccumulatorMap<string, FieldNode>();\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            selection.selectionSet,\n            patchFields,\n            patches,\n            visitedFragmentNames,\n          );\n          patches.push({\n            label: defer.label,\n            groupedFieldSet: patchFields,\n          });\n        } else {\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            selection.selectionSet,\n            groupedFieldSet,\n            patches,\n            visitedFragmentNames,\n          );\n        }\n        break;\n      }\n      case Kind.FRAGMENT_SPREAD: {\n        const fragName = selection.name.value;\n\n        if (!shouldIncludeNode(exeContext, selection)) {\n          continue;\n        }\n\n        const defer = getDeferValues(exeContext, selection);\n        if (visitedFragmentNames.has(fragName) && !defer) {\n          continue;\n        }\n\n        const fragment = exeContext.fragments[fragName];\n        if (\n          fragment == null ||\n          !doesFragmentConditionMatch(\n            fragment,\n            runtimeTypeName,\n            exeContext.schemaFragment,\n          )\n        ) {\n          continue;\n        }\n\n        if (!defer) {\n          visitedFragmentNames.add(fragName);\n        }\n\n        if (defer) {\n          const patchFields = new AccumulatorMap<string, FieldNode>();\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            fragment.selectionSet,\n            patchFields,\n            patches,\n            visitedFragmentNames,\n          );\n          patches.push({\n            label: defer.label,\n            groupedFieldSet: patchFields,\n          });\n        } else {\n          collectFieldsImpl(\n            exeContext,\n            runtimeTypeName,\n            fragment.selectionSet,\n            groupedFieldSet,\n            patches,\n            visitedFragmentNames,\n          );\n        }\n        break;\n      }\n    }\n  }\n}\n\n/**\n * Determines if a field should be included based on the @include and @skip\n * directives, where @skip has higher precedence than @include.\n */\nfunction shouldIncludeNode(\n  exeContext: ExecutionContext,\n  node: SelectionNode,\n): boolean {\n  if (!node.directives?.length) {\n    return true;\n  }\n\n  const skip = getDirectiveValues(exeContext, GraphQLSkipDirective, node);\n  if (skip?.if === true) {\n    return false;\n  }\n\n  const include = getDirectiveValues(exeContext, GraphQLIncludeDirective, node);\n  if (include?.if === false) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a fragment is applicable to the given type.\n */\nfunction doesFragmentConditionMatch(\n  fragment: FragmentDefinitionNode | InlineFragmentNode,\n  typeName: string,\n  { definitions }: SchemaFragment,\n): boolean {\n  const typeConditionNode = fragment.typeCondition;\n  if (!typeConditionNode) {\n    return true;\n  }\n\n  const conditionalTypeName = typeConditionNode.name.value;\n\n  if (conditionalTypeName === typeName) {\n    return true;\n  }\n  if (isAbstractType(definitions, conditionalTypeName)) {\n    return isSubType(definitions, conditionalTypeName, typeName);\n  }\n  return false;\n}\n\n/**\n * Implements the logic to compute the key of a given field's entry\n */\nfunction getFieldEntryKey(node: FieldNode): string {\n  return node.alias ? node.alias.value : node.name.value;\n}\n\n/**\n * Returns an object containing the `@defer` arguments if a field should be\n * deferred based on the experimental flag, defer directive present and\n * not disabled by the \"if\" argument.\n */\nfunction getDeferValues(\n  exeContext: ExecutionContext,\n  node: FragmentSpreadNode | InlineFragmentNode,\n): undefined | { label: string | undefined } {\n  const defer = getDirectiveValues(exeContext, GraphQLDeferDirective, node);\n\n  if (!defer) {\n    return;\n  }\n\n  if (defer.if === false) {\n    return;\n  }\n\n  invariant(\n    exeContext.operation.operation !== \"subscription\",\n    \"`@defer` directive not supported on subscription operations. Disable `@defer` by setting the `if` argument to `false`.\",\n  );\n\n  return {\n    label: typeof defer.label === \"string\" ? defer.label : undefined,\n  };\n}\n"],
+  "mappings": "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",
   "names": ["invariant"]
 }

package/lib/collectFields.mjs

@@ -10,6 +10,7 @@ import {
 } from "./schema/directives.mjs";
 import { AccumulatorMap } from "./jsutils/AccumulatorMap.mjs";
 import invariant from "invariant";
+import { isAbstractType, isSubType } from "./schema/definition.mjs";
 function collectFields(exeContext, runtimeTypeName) {
   const { operation } = exeContext;
   const groupedFieldSet = new AccumulatorMap();
@@ -60,7 +61,7 @@ function collectFieldsImpl(exeContext, runtimeTypeName, selectionSet, groupedFie
         if (!shouldIncludeNode(exeContext, selection) || !doesFragmentConditionMatch(
           selection,
           runtimeTypeName,
-          exeContext.partialSchema
+          exeContext.schemaFragment
         )) {
           continue;
         }
@@ -104,7 +105,7 @@ function collectFieldsImpl(exeContext, runtimeTypeName, selectionSet, groupedFie
         if (fragment == null || !doesFragmentConditionMatch(
           fragment,
           runtimeTypeName,
-          exeContext.partialSchema
+          exeContext.schemaFragment
         )) {
           continue;
         }
@@ -155,7 +156,7 @@ function shouldIncludeNode(exeContext, node) {
   }
   return true;
 }
-function doesFragmentConditionMatch(fragment, typeName, schemaFragment) {
+function doesFragmentConditionMatch(fragment, typeName, { definitions }) {
   const typeConditionNode = fragment.typeCondition;
   if (!typeConditionNode) {
     return true;
@@ -164,8 +165,8 @@ function doesFragmentConditionMatch(fragment, typeName, schemaFragment) {
   if (conditionalTypeName === typeName) {
     return true;
   }
-  if (schemaFragment.isAbstractType(conditionalTypeName)) {
-    return schemaFragment.isSubType(conditionalTypeName, typeName);
+  if (isAbstractType(definitions, conditionalTypeName)) {
+    return isSubType(definitions, conditionalTypeName, typeName);
   }
   return false;
 }