@graphitation/supermassive 0.8.3 → 1.0.0

package/CHANGELOG.md

@@ -1,12 +1,36 @@
 # Change Log - @graphitation/supermassive
 
-This log was last generated on Tue, 03 May 2022 17:45:06 GMT and should not be manually modified.
+This log was last generated on Wed, 20 Jul 2022 16:31:49 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 1.0.0
+
+Wed, 20 Jul 2022 16:31:49 GMT
+
+### Major changes
+
+- extractImplicitTypesToTypescript exported separately from supermassive (jakubvejr@microsoft.com)
+
+## 0.8.5
+
+Fri, 24 Jun 2022 11:59:47 GMT
+
+### Patches
+
+- Hotfix: re-export extractImplicitTypesToTypescript (jakubvejr@microsoft.com)
+
+## 0.8.4
+
+Thu, 23 Jun 2022 14:40:50 GMT
+
+### Patches
+
+- Schem extraction function exported (jakubvejr@microsoft.com)
+
 ## 0.8.3
 
-Tue, 03 May 2022 17:45:06 GMT
+Tue, 03 May 2022 17:45:10 GMT
 
 ### Patches
 

package/README.md

@@ -23,12 +23,29 @@ Consider a GraphQL schema. It is typically a sizeable chunk of data, both in ter
 
 Similarly, the GraphQL operations themselves, described using e.g. [GraphQL SDL](https://graphql.org/learn/schema/) or [`graphql-js` AST](https://github.com/graphql/graphql-js/blob/main/src/language/ast.ts), can incur quite some overhead as operations and number of operations grow. Eliminating these from the bundles can save size as well as runtime processing.
 
-## Roadmap
+## Implementation details and plans
 
-### Phase 1
+### 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.
 
 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.
 
+### Possible future 1 - Relay IR
+
+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.
+
+Relay IR is more efficient because it allows aliasing common elements of the document, like types or selections, thus reducing the total document size.
+
+### Possible future 2 - 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
+
+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.
+
 Consider a GraphQL operation like the following:
 
 ```graphql
@@ -39,30 +56,8 @@ query CurrentUserNameQuery {
 }
 ```
 
-This would lead to the following [conceptual] tree-shaking after compilation of the schema:
-
-```diff
- type Query {
-   me: User!
- }
-
- type User {
-   name: String!
--  presence: Presence!
- }
-
--type Presence {
--  availability: PresenceAvailability!
--}
--
--enum PresenceAvailability {
--  AVAILABLE
--  BUSY
--  OFFLINE
--}
-```
 
-...and the field-resolver map:
+This would lead to the following [conceptual] tree-shaking after compilation of the field-resolver map:
 
 ```diff
  import { getUser } from "user-service";
@@ -79,9 +74,9 @@ This would lead to the following [conceptual] tree-shaking after compilation of
  };
 ```
 
-### Phase 2
+### Possible future 4 - GraphQL-to-JS
 
-In this phase, we will 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.
+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.
 
 Consider the GraphQL operation shown in the previous phase, typical generic execution (as [described in the specification](https://spec.graphql.org/June2018/#sec-Execution)) would look something like the following recursive pseudo-code:
 
@@ -148,9 +143,9 @@ function CurrentUserNameQuery(rootSource = {}) {
 CurrentUserNameQuery();
 ```
 
-### Phase 3
+### Possible future 5 - persisted queries
 
-In this final phase, we will 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.
+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.
 
 Again, considering the above GraphQL operation, a React component needing that data would include the GraphQL document in its bundle and look something like the following:
 

package/lib/ast/TypedAST.js

@@ -1,3 +1,15 @@
 var __defProp = Object.defineProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
-__markAsModule(exports);
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TypedAST_exports = {};
+module.exports = __toCommonJS(TypedAST_exports);

package/lib/ast/addTypesToRequestDocument.js

@@ -1,13 +1,13 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 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 __objSpread = (a, b) => {
+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]);
@@ -18,28 +18,28 @@ var __objSpread = (a, b) => {
     }
   return a;
 };
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+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});
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __reExport = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
-__markAsModule(exports);
-__export(exports, {
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var addTypesToRequestDocument_exports = {};
+__export(addTypesToRequestDocument_exports, {
   addTypesToRequestDocument: () => addTypesToRequestDocument
 });
-var import_graphql = __toModule(require("graphql"));
-__reExport(exports, __toModule(require("./TypedAST")));
+module.exports = __toCommonJS(addTypesToRequestDocument_exports);
+var import_graphql = require("graphql");
+__reExport(addTypesToRequestDocument_exports, require("./TypedAST"), module.exports);
 function addTypesToRequestDocument(schema, document) {
   const typeInfo = new import_graphql.TypeInfo(schema);
   return (0, import_graphql.visit)(document, (0, import_graphql.visitWithTypeInfo)(typeInfo, {
@@ -47,7 +47,7 @@ function addTypesToRequestDocument(schema, document) {
       const argument = typeInfo.getArgument();
       if (argument) {
         const typeNode = generateTypeNode(argument.type);
-        const newNode = __objSpread(__objSpread({}, node), {
+        const newNode = __spreadProps(__spreadValues({}, node), {
           __type: typeNode,
           __defaultValue: argument.defaultValue ? (0, import_graphql.parseValue)(JSON.stringify(argument.defaultValue)) : void 0
         });
@@ -58,7 +58,7 @@ function addTypesToRequestDocument(schema, document) {
       const type = typeInfo.getType();
       if (type) {
         const typeNode = generateTypeNode(type);
-        const newNode = __objSpread(__objSpread({}, node), {
+        const newNode = __spreadProps(__spreadValues({}, node), {
           __type: typeNode
         });
         return newNode;

package/lib/ast/addTypesToRequestDocument.mjs

@@ -1,9 +1,11 @@
 var __defProp = Object.defineProperty;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __objSpread = (a, b) => {
+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]);
@@ -14,6 +16,7 @@ var __objSpread = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
 // src/ast/addTypesToRequestDocument.ts
 import {
@@ -33,7 +36,7 @@ function addTypesToRequestDocument(schema, document) {
       const argument = typeInfo.getArgument();
       if (argument) {
         const typeNode = generateTypeNode(argument.type);
-        const newNode = __objSpread(__objSpread({}, node), {
+        const newNode = __spreadProps(__spreadValues({}, node), {
           __type: typeNode,
           __defaultValue: argument.defaultValue ? parseValue(JSON.stringify(argument.defaultValue)) : void 0
         });
@@ -44,7 +47,7 @@ function addTypesToRequestDocument(schema, document) {
       const type = typeInfo.getType();
       if (type) {
         const typeNode = generateTypeNode(type);
-        const newNode = __objSpread(__objSpread({}, node), {
+        const newNode = __spreadProps(__spreadValues({}, node), {
           __type: typeNode
         });
         return newNode;

package/lib/benchmarks/index.js

@@ -1,21 +1,18 @@
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
-var __reExport = (target, module2, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && key !== "default")
-        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+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 target;
-};
-var __toModule = (module2) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+  return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -36,18 +33,18 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var import_fs = __toModule(require("fs"));
-var import_path = __toModule(require("path"));
-var import_nice_benchmark = __toModule(require("./nice-benchmark"));
-var import_swapi_schema = __toModule(require("./swapi-schema"));
-var import_resolvers = __toModule(require("./swapi-schema/resolvers"));
-var import_models = __toModule(require("./swapi-schema/models"));
-var import_graphql = __toModule(require("graphql"));
-var import_graphql_jit = __toModule(require("graphql-jit"));
-var import_executeWithoutSchema = __toModule(require("../executeWithoutSchema"));
-var import_addTypesToRequestDocument = __toModule(require("../ast/addTypesToRequestDocument"));
-var import_extractImplicitTypesRuntime = __toModule(require("../extractImplicitTypesRuntime"));
-var import_values = __toModule(require("../values"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_nice_benchmark = __toESM(require("./nice-benchmark"));
+var import_swapi_schema = __toESM(require("./swapi-schema"));
+var import_resolvers = __toESM(require("./swapi-schema/resolvers"));
+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_addTypesToRequestDocument = require("../ast/addTypesToRequestDocument");
+var import_extractImplicitTypesRuntime = require("../extractImplicitTypesRuntime");
+var import_values = require("../values");
 const query = import_fs.default.readFileSync(import_path.default.join(__dirname, "./fixtures/query1.graphql"), {
   encoding: "utf-8"
 });
@@ -55,30 +52,30 @@ const parsedQuery = (0, import_graphql.parse)(query);
 const compiledQuery = (0, import_graphql_jit.compileQuery)(import_swapi_schema.default, parsedQuery);
 const typeAnnotatedQuery = (0, import_addTypesToRequestDocument.addTypesToRequestDocument)(import_swapi_schema.default, parsedQuery);
 const queryRunningSuite = new import_nice_benchmark.default("Query Running");
-queryRunningSuite.add("graphql-js - string queries", () => __async(void 0, null, function* () {
+queryRunningSuite.add("graphql-js - string queries", () => __async(exports, null, function* () {
   const result = yield (0, import_graphql.graphql)({
     schema: import_swapi_schema.default,
     source: query,
-    contextValue: {models: import_models.default}
+    contextValue: { models: import_models.default }
   });
   if (result.errors || !result.data) {
     throw new Error("Stuff ain't executing");
   }
 }));
-queryRunningSuite.add("graphql-js - parsed queries", () => __async(void 0, null, function* () {
+queryRunningSuite.add("graphql-js - parsed queries", () => __async(exports, null, function* () {
   const result = yield (0, import_graphql.execute)({
     schema: import_swapi_schema.default,
     document: parsedQuery,
-    contextValue: {models: import_models.default}
+    contextValue: { models: import_models.default }
   });
   if (result.errors || !result.data) {
     throw new Error("Stuff ain't executing");
   }
 }));
-queryRunningSuite.add("graphql-jit - uncompiled", () => __async(void 0, null, function* () {
+queryRunningSuite.add("graphql-jit - uncompiled", () => __async(exports, null, function* () {
   const freshCompiledQuery = (0, import_graphql_jit.compileQuery)(import_swapi_schema.default, parsedQuery);
   if ((0, import_graphql_jit.isCompiledQuery)(freshCompiledQuery)) {
-    const result = yield freshCompiledQuery.query({}, {models: import_models.default}, {});
+    const result = yield freshCompiledQuery.query({}, { models: import_models.default }, {});
     if (result.errors || !result.data) {
       throw new Error("Stuff ain't executing");
     }
@@ -86,9 +83,9 @@ queryRunningSuite.add("graphql-jit - uncompiled", () => __async(void 0, null, fu
     throw new Error("Wrong query");
   }
 }));
-queryRunningSuite.add("graphql-jit - precompiled", () => __async(void 0, null, function* () {
+queryRunningSuite.add("graphql-jit - precompiled", () => __async(exports, null, function* () {
   if ((0, import_graphql_jit.isCompiledQuery)(compiledQuery)) {
-    const result = yield compiledQuery.query({}, {models: import_models.default}, {});
+    const result = yield compiledQuery.query({}, { models: import_models.default }, {});
     if (result.errors || !result.data) {
       throw new Error("Stuff ain't executing");
     }
@@ -96,7 +93,7 @@ queryRunningSuite.add("graphql-jit - precompiled", () => __async(void 0, null, f
     throw new Error("Wrong query");
   }
 }));
-queryRunningSuite.add("supermassive - runtime schemaless", () => __async(void 0, null, function* () {
+queryRunningSuite.add("supermassive - runtime schemaless", () => __async(exports, null, function* () {
   let extractedResolvers = {};
   const getTypeByName = (name) => {
     const type = import_values.specifiedScalars[name] || extractedResolvers[name];
@@ -111,18 +108,18 @@ queryRunningSuite.add("supermassive - runtime schemaless", () => __async(void 0,
     resolvers: import_resolvers.default,
     schemaResolvers: extractedResolvers,
     document: typeAnnotatedQuery,
-    contextValue: {models: import_models.default}
+    contextValue: { models: import_models.default }
   });
   if (result.errors || !result.data) {
     throw new Error("Stuff ain't executing");
   }
 }));
 const queryParsingSuite = new import_nice_benchmark.default("Query parsing");
-queryParsingSuite.add("graphql-js", () => __async(void 0, null, function* () {
+queryParsingSuite.add("graphql-js", () => __async(exports, null, function* () {
   (0, import_graphql.parse)(query);
 }));
 const queryCompilingSuite = new import_nice_benchmark.default("Query compiling");
-queryCompilingSuite.add("graphql-jit", () => __async(void 0, null, function* () {
+queryCompilingSuite.add("graphql-jit", () => __async(exports, null, function* () {
   yield (0, import_graphql_jit.compileQuery)(import_swapi_schema.default, parsedQuery);
 }));
 const queryAnnotationSuite = new import_nice_benchmark.default("Query annotation");

package/lib/benchmarks/index.mjs

@@ -1,3 +1,7 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -32,98 +36,103 @@ import {
   parse,
   isInputType
 } from "graphql";
-import {compileQuery, isCompiledQuery} from "graphql-jit";
-import {executeWithoutSchema as supermassiveExecute} from "../executeWithoutSchema.mjs";
-import {addTypesToRequestDocument} from "../ast/addTypesToRequestDocument.mjs";
-import {extractImplicitTypes} from "../extractImplicitTypesRuntime.mjs";
-import {specifiedScalars} from "../values.mjs";
-var query = fs.readFileSync(path.join(__dirname, "./fixtures/query1.graphql"), {
-  encoding: "utf-8"
-});
-var parsedQuery = parse(query);
-var compiledQuery = compileQuery(schema, parsedQuery);
-var typeAnnotatedQuery = addTypesToRequestDocument(schema, parsedQuery);
-var queryRunningSuite = new NiceBenchmark("Query Running");
-queryRunningSuite.add("graphql-js - string queries", () => __async(void 0, null, function* () {
-  const result = yield graphql({
-    schema,
-    source: query,
-    contextValue: {models}
-  });
-  if (result.errors || !result.data) {
-    throw new Error("Stuff ain't executing");
-  }
-}));
-queryRunningSuite.add("graphql-js - parsed queries", () => __async(void 0, null, function* () {
-  const result = yield graphqlExecute({
-    schema,
-    document: parsedQuery,
-    contextValue: {models}
-  });
-  if (result.errors || !result.data) {
-    throw new Error("Stuff ain't executing");
-  }
-}));
-queryRunningSuite.add("graphql-jit - uncompiled", () => __async(void 0, null, function* () {
-  const freshCompiledQuery = compileQuery(schema, parsedQuery);
-  if (isCompiledQuery(freshCompiledQuery)) {
-    const result = yield freshCompiledQuery.query({}, {models}, {});
-    if (result.errors || !result.data) {
-      throw new Error("Stuff ain't executing");
-    }
-  } else {
-    throw new Error("Wrong query");
-  }
-}));
-queryRunningSuite.add("graphql-jit - precompiled", () => __async(void 0, null, function* () {
-  if (isCompiledQuery(compiledQuery)) {
-    const result = yield compiledQuery.query({}, {models}, {});
-    if (result.errors || !result.data) {
-      throw new Error("Stuff ain't executing");
-    }
-  } else {
-    throw new Error("Wrong query");
-  }
-}));
-queryRunningSuite.add("supermassive - runtime schemaless", () => __async(void 0, null, function* () {
-  let extractedResolvers = {};
-  const getTypeByName = (name) => {
-    const type = specifiedScalars[name] || extractedResolvers[name];
-    if (isInputType(type)) {
-      return type;
-    } else {
-      throw new Error("Invalid type");
+import { compileQuery, isCompiledQuery } from "graphql-jit";
+import { executeWithoutSchema as supermassiveExecute } from "../executeWithoutSchema.mjs";
+import { addTypesToRequestDocument } from "../ast/addTypesToRequestDocument.mjs";
+import { extractImplicitTypes } from "../extractImplicitTypesRuntime.mjs";
+import { specifiedScalars } from "../values.mjs";
+var require_benchmarks = __commonJS({
+  "src/benchmarks/index.ts"(exports) {
+    var query = fs.readFileSync(path.join(__dirname, "./fixtures/query1.graphql"), {
+      encoding: "utf-8"
+    });
+    var parsedQuery = parse(query);
+    var compiledQuery = compileQuery(schema, parsedQuery);
+    var typeAnnotatedQuery = addTypesToRequestDocument(schema, parsedQuery);
+    var queryRunningSuite = new NiceBenchmark("Query Running");
+    queryRunningSuite.add("graphql-js - string queries", () => __async(exports, null, function* () {
+      const result = yield graphql({
+        schema,
+        source: query,
+        contextValue: { models }
+      });
+      if (result.errors || !result.data) {
+        throw new Error("Stuff ain't executing");
+      }
+    }));
+    queryRunningSuite.add("graphql-js - parsed queries", () => __async(exports, null, function* () {
+      const result = yield graphqlExecute({
+        schema,
+        document: parsedQuery,
+        contextValue: { models }
+      });
+      if (result.errors || !result.data) {
+        throw new Error("Stuff ain't executing");
+      }
+    }));
+    queryRunningSuite.add("graphql-jit - uncompiled", () => __async(exports, null, function* () {
+      const freshCompiledQuery = compileQuery(schema, parsedQuery);
+      if (isCompiledQuery(freshCompiledQuery)) {
+        const result = yield freshCompiledQuery.query({}, { models }, {});
+        if (result.errors || !result.data) {
+          throw new Error("Stuff ain't executing");
+        }
+      } else {
+        throw new Error("Wrong query");
+      }
+    }));
+    queryRunningSuite.add("graphql-jit - precompiled", () => __async(exports, null, function* () {
+      if (isCompiledQuery(compiledQuery)) {
+        const result = yield compiledQuery.query({}, { models }, {});
+        if (result.errors || !result.data) {
+          throw new Error("Stuff ain't executing");
+        }
+      } else {
+        throw new Error("Wrong query");
+      }
+    }));
+    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,
+        contextValue: { models }
+      });
+      if (result.errors || !result.data) {
+        throw new Error("Stuff ain't executing");
+      }
+    }));
+    var queryParsingSuite = new NiceBenchmark("Query parsing");
+    queryParsingSuite.add("graphql-js", () => __async(exports, null, function* () {
+      parse(query);
+    }));
+    var queryCompilingSuite = new NiceBenchmark("Query compiling");
+    queryCompilingSuite.add("graphql-jit", () => __async(exports, null, function* () {
+      yield compileQuery(schema, parsedQuery);
+    }));
+    var queryAnnotationSuite = new NiceBenchmark("Query annotation");
+    queryAnnotationSuite.add("supermassive", () => {
+      addTypesToRequestDocument(schema, parsedQuery);
+    });
+    function main() {
+      return __async(this, null, function* () {
+        yield queryCompilingSuite.run();
+        yield queryParsingSuite.run();
+        yield queryAnnotationSuite.run();
+        yield queryRunningSuite.run();
+      });
     }
-  };
-  extractedResolvers = extractImplicitTypes(parsedQuery, getTypeByName);
-  const result = yield supermassiveExecute({
-    resolvers,
-    schemaResolvers: extractedResolvers,
-    document: typeAnnotatedQuery,
-    contextValue: {models}
-  });
-  if (result.errors || !result.data) {
-    throw new Error("Stuff ain't executing");
+    main();
   }
-}));
-var queryParsingSuite = new NiceBenchmark("Query parsing");
-queryParsingSuite.add("graphql-js", () => __async(void 0, null, function* () {
-  parse(query);
-}));
-var queryCompilingSuite = new NiceBenchmark("Query compiling");
-queryCompilingSuite.add("graphql-jit", () => __async(void 0, null, function* () {
-  yield compileQuery(schema, parsedQuery);
-}));
-var queryAnnotationSuite = new NiceBenchmark("Query annotation");
-queryAnnotationSuite.add("supermassive", () => {
-  addTypesToRequestDocument(schema, parsedQuery);
 });
-function main() {
-  return __async(this, null, function* () {
-    yield queryCompilingSuite.run();
-    yield queryParsingSuite.run();
-    yield queryAnnotationSuite.run();
-    yield queryRunningSuite.run();
-  });
-}
-main();
+export default require_benchmarks();