@graphitation/supermassive 2.6.1 → 3.0.0-alpha.3

package/CHANGELOG.md

@@ -1,9 +1,25 @@
 # Change Log - @graphitation/supermassive
 
-This log was last generated on Tue, 20 Jun 2023 11:38:47 GMT and should not be manually modified.
+This log was last generated on Tue, 29 Aug 2023 15:06:31 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 3.0.0-alpha.3
+
+Tue, 29 Aug 2023 15:06:31 GMT
+
+### Changes
+
+- New type annotation strategy (vladimir.razuvaev@gmail.com)
+
+## 3.0.0-alpha.1
+
+Tue, 27 Jun 2023 11:47:30 GMT
+
+### Changes
+
+- Supermassive v3 alpha - defer and stream stuff (mnovikov@microsoft.com)
+
 ## 2.6.0
 
 Tue, 20 Jun 2023 11:38:47 GMT

package/lib/__testUtils__/execute.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLSchema, ExecutionArgs, ExecutionArgs as GraphQLExecutionArgs, ExecutionResult as GraphQLExecutionResult } from "graphql";
+import { ExecutionResult } from "../types";
+import { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
+import { ObjMap } from "../jsutils/ObjMap";
+type GraphQLResult<TData = ObjMap<unknown>, TExtensions = ObjMap<unknown>> = GraphQLExecutionResult<TData, TExtensions> | AsyncGenerator<GraphQLExecutionResult<TData, TExtensions>, void, void>;
+export declare function createExecutionUtils(graphqlExecute: (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>, graphqlSubscribe: (args: ExecutionArgs) => PromiseOrValue<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult>): {
+    compareResultForExecuteWithoutSchemaWithMVSAnnotation: (schema: GraphQLSchema, query: string, variables?: Record<string, unknown>) => Promise<void>;
+    compareResultsForExecuteWithSchema: (schema: GraphQLSchema, query: string, variables?: Record<string, unknown>) => Promise<void>;
+    drainExecution: (result: ExecutionResult | GraphQLResult) => Promise<unknown>;
+    graphqlExecuteOrSubscribe: (args: GraphQLExecutionArgs) => PromiseOrValue<GraphQLResult>;
+};
+export {};
+//# sourceMappingURL=execute.d.ts.map

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

@@ -0,0 +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;AAK1D,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;6BA8F3B,eAAe,GAAG,aAAa,KACtC,QAAQ,OAAO,CAAC;sCAhCX,oBAAoB,KACzB,eAAe,aAAa,CAAC;EA8DjC"}

package/lib/__testUtils__/execute.js

@@ -0,0 +1,196 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var execute_exports = {};
+__export(execute_exports, {
+  createExecutionUtils: () => createExecutionUtils
+});
+module.exports = __toCommonJS(execute_exports);
+var import_graphql = require("graphql");
+var import_executeWithSchema = require("../executeWithSchema");
+var import_swapi_schema = require("../benchmarks/swapi-schema");
+var import_resolvers = __toESM(require("../benchmarks/swapi-schema/resolvers"));
+var import_models = __toESM(require("../benchmarks/swapi-schema/models"));
+var import_executeWithoutSchema = require("../executeWithoutSchema");
+var import_addMinimalViableSchemaToRequestDocument = require("../utilities/addMinimalViableSchemaToRequestDocument");
+var import_iterall = require("iterall");
+function createExecutionUtils(graphqlExecute, graphqlSubscribe) {
+  function compareResultsForExecuteWithSchema(schema, query, variables) {
+    return __async(this, null, function* () {
+      expect.assertions(1);
+      const document = (0, import_graphql.parse)(query);
+      const result = yield drainExecution(
+        yield (0, import_executeWithSchema.executeWithSchema)({
+          typeDefs: import_swapi_schema.typeDefs,
+          resolvers: import_resolvers.default,
+          document,
+          contextValue: {
+            models: import_models.default
+          },
+          variableValues: variables
+        })
+      );
+      const validResult = yield drainExecution(
+        yield graphqlExecuteOrSubscribe({
+          document,
+          contextValue: {
+            models: import_models.default
+          },
+          schema,
+          variableValues: variables
+        })
+      );
+      expect(result).toEqual(validResult);
+    });
+  }
+  function compareResultForExecuteWithoutSchemaWithMVSAnnotation(_0, _1) {
+    return __async(this, arguments, function* (schema, query, variables = {}) {
+      expect.assertions(1);
+      const document = (0, import_graphql.parse)(query);
+      const result = yield drainExecution(
+        yield (0, import_executeWithoutSchema.executeWithoutSchema)({
+          document,
+          contextValue: {
+            models: import_models.default
+          },
+          resolvers: import_resolvers.default,
+          schemaFragment: (0, import_addMinimalViableSchemaToRequestDocument.extractMinimalViableSchemaForRequestDocument)(
+            schema,
+            document
+          ),
+          variableValues: variables
+        })
+      );
+      const validResult = yield drainExecution(
+        yield graphqlExecuteOrSubscribe({
+          document,
+          contextValue: {
+            models: import_models.default
+          },
+          schema,
+          variableValues: variables
+        })
+      );
+      expect(result).toEqual(validResult);
+    });
+  }
+  function graphqlExecuteOrSubscribe(args) {
+    var _a;
+    const operationName = args.operationName;
+    let operation;
+    for (const definition of args.document.definitions) {
+      switch (definition.kind) {
+        case import_graphql.Kind.OPERATION_DEFINITION:
+          if (operationName == null) {
+            if (operation !== void 0) {
+              throw new Error("Bad operation in test");
+            }
+            operation = definition;
+          } else if (((_a = definition.name) == null ? void 0 : _a.value) === operationName) {
+            operation = definition;
+          }
+          break;
+      }
+    }
+    if (!operation) {
+      throw new Error("Bad operation in test");
+    }
+    if (operation.operation === import_graphql.OperationTypeNode.SUBSCRIPTION) {
+      return graphqlSubscribe(args);
+    } else {
+      return graphqlExecute(args);
+    }
+  }
+  function drainExecution(result) {
+    return __async(this, null, function* () {
+      let processedResult;
+      if ((0, import_iterall.isAsyncIterable)(result)) {
+        processedResult = yield drainAsyncGeneratorToArray(result);
+      } else if ("subsequentResults" in result) {
+        processedResult = __spreadProps(__spreadValues({}, result), {
+          subsequentResults: yield drainAsyncGeneratorToArray(
+            result.subsequentResults
+          )
+        });
+      } else {
+        processedResult = result;
+      }
+      return processedResult;
+    });
+  }
+  function drainAsyncGeneratorToArray(collection) {
+    return __async(this, null, function* () {
+      const result = [];
+      yield (0, import_iterall.forAwaitEach)(collection, (item) => result.push(item));
+      return result;
+    });
+  }
+  return {
+    compareResultForExecuteWithoutSchemaWithMVSAnnotation,
+    compareResultsForExecuteWithSchema,
+    drainExecution,
+    graphqlExecuteOrSubscribe
+  };
+}

package/lib/__testUtils__/execute.js.map

@@ -0,0 +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/addMinimalViableSchemaToRequestDocument\";\nimport {} from \"graphql/execution/execute\";\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        typeDefs,\n        resolvers: resolvers as UserResolvers<unknown, unknown>,\n        document,\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 result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        resolvers: resolvers as UserResolvers,\n        schemaFragment: extractMinimalViableSchemaForRequestDocument(\n          schema,\n          document,\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

@@ -0,0 +1,174 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/__testUtils__/execute.ts
+import {
+  Kind,
+  OperationTypeNode,
+  parse
+} from "graphql";
+import { executeWithSchema } from "../executeWithSchema.mjs";
+import { typeDefs } from "../benchmarks/swapi-schema/index.mjs";
+import resolvers from "../benchmarks/swapi-schema/resolvers.mjs";
+import models from "../benchmarks/swapi-schema/models.mjs";
+import { executeWithoutSchema } from "../executeWithoutSchema.mjs";
+import { extractMinimalViableSchemaForRequestDocument } from "../utilities/addMinimalViableSchemaToRequestDocument.mjs";
+import { forAwaitEach, isAsyncIterable } from "iterall";
+function createExecutionUtils(graphqlExecute, graphqlSubscribe) {
+  function compareResultsForExecuteWithSchema(schema, query, variables) {
+    return __async(this, null, function* () {
+      expect.assertions(1);
+      const document = parse(query);
+      const result = yield drainExecution(
+        yield executeWithSchema({
+          typeDefs,
+          resolvers,
+          document,
+          contextValue: {
+            models
+          },
+          variableValues: variables
+        })
+      );
+      const validResult = yield drainExecution(
+        yield graphqlExecuteOrSubscribe({
+          document,
+          contextValue: {
+            models
+          },
+          schema,
+          variableValues: variables
+        })
+      );
+      expect(result).toEqual(validResult);
+    });
+  }
+  function compareResultForExecuteWithoutSchemaWithMVSAnnotation(_0, _1) {
+    return __async(this, arguments, function* (schema, query, variables = {}) {
+      expect.assertions(1);
+      const document = parse(query);
+      const result = yield drainExecution(
+        yield executeWithoutSchema({
+          document,
+          contextValue: {
+            models
+          },
+          resolvers,
+          schemaFragment: extractMinimalViableSchemaForRequestDocument(
+            schema,
+            document
+          ),
+          variableValues: variables
+        })
+      );
+      const validResult = yield drainExecution(
+        yield graphqlExecuteOrSubscribe({
+          document,
+          contextValue: {
+            models
+          },
+          schema,
+          variableValues: variables
+        })
+      );
+      expect(result).toEqual(validResult);
+    });
+  }
+  function graphqlExecuteOrSubscribe(args) {
+    var _a;
+    const operationName = args.operationName;
+    let operation;
+    for (const definition of args.document.definitions) {
+      switch (definition.kind) {
+        case Kind.OPERATION_DEFINITION:
+          if (operationName == null) {
+            if (operation !== void 0) {
+              throw new Error("Bad operation in test");
+            }
+            operation = definition;
+          } else if (((_a = definition.name) == null ? void 0 : _a.value) === operationName) {
+            operation = definition;
+          }
+          break;
+      }
+    }
+    if (!operation) {
+      throw new Error("Bad operation in test");
+    }
+    if (operation.operation === OperationTypeNode.SUBSCRIPTION) {
+      return graphqlSubscribe(args);
+    } else {
+      return graphqlExecute(args);
+    }
+  }
+  function drainExecution(result) {
+    return __async(this, null, function* () {
+      let processedResult;
+      if (isAsyncIterable(result)) {
+        processedResult = yield drainAsyncGeneratorToArray(result);
+      } else if ("subsequentResults" in result) {
+        processedResult = __spreadProps(__spreadValues({}, result), {
+          subsequentResults: yield drainAsyncGeneratorToArray(
+            result.subsequentResults
+          )
+        });
+      } else {
+        processedResult = result;
+      }
+      return processedResult;
+    });
+  }
+  function drainAsyncGeneratorToArray(collection) {
+    return __async(this, null, function* () {
+      const result = [];
+      yield forAwaitEach(collection, (item) => result.push(item));
+      return result;
+    });
+  }
+  return {
+    compareResultForExecuteWithoutSchemaWithMVSAnnotation,
+    compareResultsForExecuteWithSchema,
+    drainExecution,
+    graphqlExecuteOrSubscribe
+  };
+}
+export {
+  createExecutionUtils
+};

package/lib/__testUtils__/execute.mjs.map

@@ -0,0 +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/addMinimalViableSchemaToRequestDocument\";\nimport {} from \"graphql/execution/execute\";\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        typeDefs,\n        resolvers: resolvers as UserResolvers<unknown, unknown>,\n        document,\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 result = await drainExecution(\n      await executeWithoutSchema({\n        document,\n        contextValue: {\n          models,\n        },\n        resolvers: resolvers as UserResolvers,\n        schemaFragment: extractMinimalViableSchemaForRequestDocument(\n          schema,\n          document,\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": []
+}

package/lib/benchmarks/index.js

@@ -50,9 +50,7 @@ var import_models = __toESM(require("./swapi-schema/models"));
 var import_graphql = require("graphql");
 var import_graphql_jit = require("graphql-jit");
 var import_executeWithoutSchema = require("../executeWithoutSchema");
-var import_supermassive_ast = require("@graphitation/supermassive-ast");
-var import_extractImplicitTypesRuntime = require("../extractImplicitTypesRuntime");
-var import_values = require("../values");
+var import_addMinimalViableSchemaToRequestDocument = require("../utilities/addMinimalViableSchemaToRequestDocument");
 const query = import_fs.default.readFileSync(
   import_path.default.join(__dirname, "./fixtures/query1.graphql"),
   {
@@ -61,12 +59,15 @@ const query = import_fs.default.readFileSync(
 );
 const parsedQuery = (0, import_graphql.parse)(query);
 const compiledQuery = (0, import_graphql_jit.compileQuery)(import_swapi_schema.default, parsedQuery);
-const typeAnnotatedQuery = (0, import_supermassive_ast.addTypesToRequestDocument)(import_swapi_schema.default, parsedQuery);
+const schemaFragment = (0, import_addMinimalViableSchemaToRequestDocument.extractMinimalViableSchemaForRequestDocument)(
+  import_swapi_schema.default,
+  parsedQuery
+);
 const queryRunningSuite = new import_nice_benchmark.default("Query Running");
 queryRunningSuite.add("graphql-js - string queries", () => __async(exports, null, function* () {
-  const result = yield (0, import_graphql.graphql)({
+  const result = yield (0, import_graphql.execute)({
     schema: import_swapi_schema.default,
-    source: query,
+    document: (0, import_graphql.parse)(query),
     contextValue: { models: import_models.default }
   });
   if (result.errors || !result.data) {
@@ -105,23 +106,13 @@ queryRunningSuite.add("graphql-jit - precompiled", () => __async(exports, null,
   }
 }));
 queryRunningSuite.add("supermassive - runtime schemaless", () => __async(exports, null, function* () {
-  let extractedResolvers = {};
-  const getTypeByName = (name) => {
-    const type = import_values.specifiedScalars[name] || extractedResolvers[name];
-    if ((0, import_graphql.isInputType)(type)) {
-      return type;
-    } else {
-      throw new Error("Invalid type");
-    }
-  };
-  extractedResolvers = (0, import_extractImplicitTypesRuntime.extractImplicitTypes)(parsedQuery, getTypeByName);
   const result = yield (0, import_executeWithoutSchema.executeWithoutSchema)({
     resolvers: import_resolvers.default,
-    schemaResolvers: extractedResolvers,
-    document: typeAnnotatedQuery,
+    schemaFragment,
+    document: parsedQuery,
     contextValue: { models: import_models.default }
   });
-  if (result.errors || !result.data) {
+  if ("data" in result && (result.errors || !result.data)) {
     throw new Error("Stuff ain't executing");
   }
 }));
@@ -135,7 +126,7 @@ queryCompilingSuite.add("graphql-jit", () => __async(exports, null, function* ()
 }));
 const queryAnnotationSuite = new import_nice_benchmark.default("Query annotation");
 queryAnnotationSuite.add("supermassive", () => {
-  (0, import_supermassive_ast.addTypesToRequestDocument)(import_swapi_schema.default, parsedQuery);
+  (0, import_addMinimalViableSchemaToRequestDocument.extractMinimalViableSchemaForRequestDocument)(import_swapi_schema.default, parsedQuery);
 });
 function main() {
   return __async(this, null, function* () {

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  graphql,\n  execute as graphqlExecute,\n  parse,\n  isInputType,\n} from \"graphql\";\nimport { compileQuery, isCompiledQuery } from \"graphql-jit\";\nimport { executeWithoutSchema as supermassiveExecute } from \"../executeWithoutSchema\";\nimport { addTypesToRequestDocument } from \"@graphitation/supermassive-ast\";\nimport { Resolvers, UserResolvers } from \"../types\";\nimport { extractImplicitTypes } from \"../extractImplicitTypesRuntime\";\nimport { specifiedScalars } from \"../values\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\n\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst typeAnnotatedQuery = addTypesToRequestDocument(schema, parsedQuery);\n\nconst queryRunningSuite = new NiceBenchmark(\"Query Running\");\nqueryRunningSuite.add(\"graphql-js - string queries\", async () => {\n  const result = await graphql({\n    schema,\n    source: 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  let extractedResolvers: Resolvers = {};\n  const getTypeByName = (name: string) => {\n    const type = specifiedScalars[name] || extractedResolvers[name];\n    if (isInputType(type)) {\n      return type;\n    } else {\n      throw new Error(\"Invalid type\");\n    }\n  };\n  extractedResolvers = extractImplicitTypes(parsedQuery, getTypeByName);\n\n  const result = await supermassiveExecute({\n    resolvers: resolvers as UserResolvers,\n    schemaResolvers: extractedResolvers,\n    document: typeAnnotatedQuery,\n    contextValue: { models },\n  });\n  if (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  addTypesToRequestDocument(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", "NiceBenchmark", "models", "graphqlExecute", "supermassiveExecute", "resolvers"]
+  "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/addMinimalViableSchemaToRequestDocument\";\n\nconst query = fs.readFileSync(\n  path.join(__dirname, \"./fixtures/query1.graphql\"),\n  {\n    encoding: \"utf-8\",\n  },\n);\n\nconst parsedQuery = parse(query);\n\nconst compiledQuery = compileQuery(schema, parsedQuery);\n\nconst schemaFragment = extractMinimalViableSchemaForRequestDocument(\n  schema,\n  parsedQuery,\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    resolvers: resolvers as UserResolvers,\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", "NiceBenchmark", "graphqlExecute", "models", "supermassiveExecute", "resolvers"]
 }

package/lib/benchmarks/index.mjs

@@ -31,16 +31,12 @@ import schema from "./swapi-schema/index.mjs";
 import resolvers from "./swapi-schema/resolvers.mjs";
 import models from "./swapi-schema/models.mjs";
 import {
-  graphql,
   execute as graphqlExecute,
-  parse,
-  isInputType
+  parse
 } from "graphql";
 import { compileQuery, isCompiledQuery } from "graphql-jit";
 import { executeWithoutSchema as supermassiveExecute } from "../executeWithoutSchema.mjs";
-import { addTypesToRequestDocument } from "@graphitation/supermassive-ast";
-import { extractImplicitTypes } from "../extractImplicitTypesRuntime.mjs";
-import { specifiedScalars } from "../values.mjs";
+import { extractMinimalViableSchemaForRequestDocument } from "../utilities/addMinimalViableSchemaToRequestDocument.mjs";
 var require_benchmarks = __commonJS({
   "src/benchmarks/index.ts"(exports) {
     var query = fs.readFileSync(
@@ -51,12 +47,15 @@ var require_benchmarks = __commonJS({
     );
     var parsedQuery = parse(query);
     var compiledQuery = compileQuery(schema, parsedQuery);
-    var typeAnnotatedQuery = addTypesToRequestDocument(schema, parsedQuery);
+    var schemaFragment = extractMinimalViableSchemaForRequestDocument(
+      schema,
+      parsedQuery
+    );
     var queryRunningSuite = new NiceBenchmark("Query Running");
     queryRunningSuite.add("graphql-js - string queries", () => __async(exports, null, function* () {
-      const result = yield graphql({
+      const result = yield graphqlExecute({
         schema,
-        source: query,
+        document: parse(query),
         contextValue: { models }
       });
       if (result.errors || !result.data) {
@@ -95,23 +94,13 @@ var require_benchmarks = __commonJS({
       }
     }));
     queryRunningSuite.add("supermassive - runtime schemaless", () => __async(exports, null, function* () {
-      let extractedResolvers = {};
-      const getTypeByName = (name) => {
-        const type = specifiedScalars[name] || extractedResolvers[name];
-        if (isInputType(type)) {
-          return type;
-        } else {
-          throw new Error("Invalid type");
-        }
-      };
-      extractedResolvers = extractImplicitTypes(parsedQuery, getTypeByName);
       const result = yield supermassiveExecute({
         resolvers,
-        schemaResolvers: extractedResolvers,
-        document: typeAnnotatedQuery,
+        schemaFragment,
+        document: parsedQuery,
         contextValue: { models }
       });
-      if (result.errors || !result.data) {
+      if ("data" in result && (result.errors || !result.data)) {
         throw new Error("Stuff ain't executing");
       }
     }));
@@ -125,7 +114,7 @@ var require_benchmarks = __commonJS({
     }));
     var queryAnnotationSuite = new NiceBenchmark("Query annotation");
     queryAnnotationSuite.add("supermassive", () => {
-      addTypesToRequestDocument(schema, parsedQuery);
+      extractMinimalViableSchemaForRequestDocument(schema, parsedQuery);
     });
     function main() {
       return __async(this, null, function* () {