@graphitation/supermassive 0.1.3 → 0.4.1

package/lib/benchmarks/swapi-schema/resolvers.mjs

@@ -0,0 +1,230 @@
+var __defProp = Object.defineProperty;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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) => {
+  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;
+};
+
+// src/benchmarks/swapi-schema/resolvers.ts
+var films = (parent, args, {models}) => {
+  return models.getData("/films").filter(({id}) => parent.films.includes(id));
+};
+var starships = (parent, {id}, {models}) => {
+  return models.getData("/starships").filter(({id: id2}) => parent.starships.includes(id2));
+};
+function people(key) {
+  return (parent, args, {models}) => {
+    return models.getData("/people").filter(({id}) => parent[key].includes(id));
+  };
+}
+var vehicles = (parent, args, {models}) => {
+  return models.getData("/vehicles").filter(({id}) => parent.vehicles.includes(id));
+};
+var planets = (parent, args, {models}) => {
+  return models.getData("/planets").filter(({id}) => parent.planets.includes(id));
+};
+var species = (parent, args, {models}) => {
+  return models.getData("/species").filter(({id}) => parent.species.includes(id));
+};
+var homeworld = (parent, args, {models}) => {
+  return models.getData("/planets").find((planet2) => planet2.id === parent.homeworld);
+};
+var person = (parent, {id}, {models}) => {
+  return models.getData("/people").find((person2) => person2.id === id);
+};
+var planet = (parent, {id}, {models}) => {
+  return models.getData("/planets").find((planet2) => planet2.id === id);
+};
+var film = (parent, {id}, {models}) => {
+  return models.getData("/films").find((film2) => film2.id === id);
+};
+var starship = (parent, {id}, {models}) => {
+  return models.getData("/starships").find((starship2) => starship2.id === id);
+};
+var transport = (parent, {id}, {models}) => {
+  return models.getData("/transport").find((transport2) => transport2.id === id);
+};
+var vehicle = (parent, {id}, {models}) => {
+  return models.getData("/vehicles").find((vehicle2) => vehicle2.id === id);
+};
+var searchPeopleByName = (parent, {search}, {models}) => {
+  return models.getData("/people").filter((person2) => new RegExp(search, "i").test(person2.name));
+};
+var searchPlanetsByName = (parent, {search}, {models}) => {
+  return models.getData("/planets").filter((planet2) => new RegExp(search, "i").test(planet2.name));
+};
+var searchFilmsByTitle = (parent, {search}, {models}) => {
+  return models.getData("/films").filter((film2) => new RegExp(search, "i").test(film2.title));
+};
+var searchSpeciesByName = (parent, {search}, {models}) => {
+  return models.getData("/species").filter((species2) => new RegExp(search, "i").test(species2.name));
+};
+var searchStarshipsByName = (parent, {search}, {models}) => {
+  return models.getData("/starships").filter((starship2) => new RegExp(search, "i").test(starship2.name));
+};
+var searchVehiclesByName = (parent, {search}, {models}) => {
+  return models.getData("/vehicles").filter((vehicle2) => new RegExp(search, "i").test(vehicle2.name));
+};
+var searchTransportsByName = (parent, {search}, {models}) => {
+  return models.getData("/transport").filter((transport2) => new RegExp(search, "i").test(transport2.name));
+};
+var resolvers = {
+  SearchResult: {
+    __resolveType(parent) {
+      return parent.__typename;
+    }
+  },
+  Query: {
+    search(parent, {search}, {models}, info) {
+      const result = [
+        ...searchFilmsByTitle(parent, {search}, {models}, info).map((r) => (r.__typename = "Film") && r),
+        ...searchPeopleByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Person") && r),
+        ...searchPlanetsByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Planet") && r),
+        ...searchSpeciesByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Species") && r),
+        ...searchStarshipsByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Starship") && r),
+        ...searchTransportsByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Transport") && r),
+        ...searchVehiclesByName(parent, {search}, {models}, info).map((r) => (r.__typename = "Vehicle") && r)
+      ];
+      return result;
+    },
+    node(parent, args, context, info) {
+      let result;
+      switch (args.nodeType) {
+        case "Person": {
+          result = person(parent, args, context, info);
+          break;
+        }
+        case "Starship": {
+          result = starship(parent, args, context, info);
+          break;
+        }
+        case "Transport": {
+          result = transport(parent, args, context, info);
+          break;
+        }
+        case "Species": {
+          result = species(parent, args, context, info);
+          break;
+        }
+        case "Vehicle": {
+          result = vehicle(parent, args, context, info);
+          break;
+        }
+        case "Planet": {
+          result = planet(parent, args, context, info);
+          break;
+        }
+        case "Film": {
+          result = film(parent, args, context, info);
+          break;
+        }
+        default:
+          throw new Error(`Invalid node type ${args.nodeType}`);
+      }
+      return __objSpread(__objSpread({}, result), {
+        __typename: args.nodeType
+      });
+    },
+    person,
+    planet,
+    film,
+    transport,
+    starship,
+    vehicle,
+    searchPeopleByName,
+    searchStarshipsByName,
+    searchTransportsByName,
+    searchSpeciesByName,
+    searchVehiclesByName,
+    searchPlanetsByName,
+    searchFilmsByTitle,
+    allStarships(parent, args, {models}) {
+      return models.getData("/starships");
+    },
+    allFilms(parent, args, {models}) {
+      return models.getData("/films");
+    },
+    allPeople(parent, args, {models}) {
+      return models.getData("/people");
+    },
+    allPlanets(parent, args, {models}) {
+      return models.getData("/planets");
+    },
+    allSpecies(parent, args, {models}) {
+      return models.getData("/species");
+    },
+    allTransports(parent, args, {models}) {
+      return models.getData("/transport");
+    }
+  },
+  Film: {
+    starships,
+    vehicles,
+    planets,
+    characters: people("characters"),
+    species
+  },
+  Starship: {
+    MGLT: (starship2) => +starship2.MGLT,
+    hyperdrive_rating: (starship2) => +starship2.hyperdrive_rating,
+    cargo_capacity: (starship2) => +starship2.cargo_capacity,
+    passengers: (starship2) => +starship2.passengers,
+    max_atmosphering_speed: (starship2) => +starship2.max_atmosphering_speed,
+    length: (starship2) => +starship2.length,
+    cost_in_credits: (starship2) => +starship2.cost_in_credits,
+    pilots: people("pilots"),
+    films
+  },
+  Person: {
+    height: (pilot) => +pilot.height,
+    mass: (pilot) => +pilot.mass,
+    starships,
+    homeworld
+  },
+  Vehicle: {
+    cargo_capacity: (vehicle2) => +vehicle2.cargo_capacity,
+    passengers: (vehicle2) => +vehicle2.passengers,
+    max_atmosphering_speed: (vehicle2) => +vehicle2.max_atmosphering_speed,
+    crew: (vehicle2) => forceNumber(vehicle2.crew),
+    length: (vehicle2) => +vehicle2.length,
+    cost_in_credits: (vehicle2) => +vehicle2.cost_in_credits,
+    pilots: people("pilots")
+  },
+  Planet: {
+    diameter: (planet2) => +planet2.diameter,
+    rotation_period: (planet2) => +planet2.rotation_period,
+    orbital_period: (planet2) => +planet2.orbital_period,
+    population: (planet2) => +planet2.population,
+    residents: people("residents"),
+    films
+  },
+  Species: {
+    average_lifespan: (species2) => +species2.average_lifespan,
+    average_height: (species2) => +species2.average_height,
+    homeworld,
+    people: people("people")
+  },
+  Transport: {
+    cargo_capacity: (vehicle2) => +vehicle2.cargo_capacity,
+    passengers: (vehicle2) => +vehicle2.passengers,
+    max_atmosphering_speed: (vehicle2) => +vehicle2.max_atmosphering_speed,
+    crew: (vehicle2) => forceNumber(vehicle2.crew),
+    length: (vehicle2) => +vehicle2.length,
+    cost_in_credits: (vehicle2) => +vehicle2.cost_in_credits
+  }
+};
+var forceNumber = (i) => Number(i.split(",").join("").split("-")[0]) || -1;
+var resolvers_default = resolvers;
+export {
+  resolvers_default as default
+};

package/lib/bin/supermassive.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function supermassive(): Command;
+//# sourceMappingURL=supermassive.d.ts.map

package/lib/bin/supermassive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supermassive.d.ts","sourceRoot":"","sources":["../../src/bin/supermassive.ts"],"names":[],"mappings":"AAGA,OAAO,EAAW,OAAO,EAAE,MAAM,WAAW,CAAC;AAI7C,wBAAgB,YAAY,IAAI,OAAO,CAYtC"}

package/lib/bin/supermassive.js

@@ -0,0 +1,83 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 __export = (target, all) => {
+  for (var name in all)
+    __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});
+  }
+  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);
+};
+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());
+  });
+};
+__markAsModule(exports);
+__export(exports, {
+  supermassive: () => supermassive
+});
+var import_path = __toModule(require("path"));
+var import_promises = __toModule(require("fs/promises"));
+var import_typescript = __toModule(require("typescript"));
+var import_commander = __toModule(require("commander"));
+var import_extractImplicitTypesToTypescript = __toModule(require("../extractImplicitTypesToTypescript"));
+var import_graphql = __toModule(require("graphql"));
+function supermassive() {
+  const command = new import_commander.Command();
+  command.name("extract-schema").argument("<files...>").description("extract implicit resolvers to a ts file from graphql typedefs").action((files) => __async(this, null, function* () {
+    yield typeDefsToImplicitResolversImpl(files);
+  }));
+  return import_commander.program.name("supermassive").addCommand(command);
+}
+function typeDefsToImplicitResolversImpl(files) {
+  return __async(this, null, function* () {
+    for (const file of files) {
+      let fullPath;
+      if (import_path.default.isAbsolute(file)) {
+        fullPath = file;
+      } else {
+        fullPath = import_path.default.join(process.cwd(), file);
+      }
+      const stat = yield import_promises.default.stat(fullPath);
+      if (!stat.isFile) {
+        throw new Error(`Invalid file ${file}`);
+      }
+      const content = yield import_promises.default.readFile(fullPath, {encoding: "utf-8"});
+      const document = (0, import_graphql.parse)(content);
+      const tsContents = (0, import_extractImplicitTypesToTypescript.extractImplicitTypesToTypescript)(document);
+      const tsDir = import_path.default.join(import_path.default.dirname(fullPath), "__generated__");
+      yield import_promises.default.mkdir(tsDir, {recursive: true});
+      const tsFileName = import_path.default.join(tsDir, import_path.default.basename(fullPath, import_path.default.extname(fullPath)) + ".ts");
+      const printer = import_typescript.default.createPrinter();
+      yield import_promises.default.writeFile(tsFileName, printer.printNode(import_typescript.default.EmitHint.SourceFile, tsContents, tsContents), {encoding: "utf-8"});
+    }
+  });
+}

package/lib/bin/supermassive.mjs

@@ -0,0 +1,62 @@
+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/bin/supermassive.ts
+import path from "path";
+import fs from "fs/promises";
+import ts from "typescript";
+import {program, Command} from "commander";
+import {extractImplicitTypesToTypescript} from "../extractImplicitTypesToTypescript.mjs";
+import {parse} from "graphql";
+function supermassive() {
+  const command = new Command();
+  command.name("extract-schema").argument("<files...>").description("extract implicit resolvers to a ts file from graphql typedefs").action((files) => __async(this, null, function* () {
+    yield typeDefsToImplicitResolversImpl(files);
+  }));
+  return program.name("supermassive").addCommand(command);
+}
+function typeDefsToImplicitResolversImpl(files) {
+  return __async(this, null, function* () {
+    for (const file of files) {
+      let fullPath;
+      if (path.isAbsolute(file)) {
+        fullPath = file;
+      } else {
+        fullPath = path.join(process.cwd(), file);
+      }
+      const stat = yield fs.stat(fullPath);
+      if (!stat.isFile) {
+        throw new Error(`Invalid file ${file}`);
+      }
+      const content = yield fs.readFile(fullPath, {encoding: "utf-8"});
+      const document = parse(content);
+      const tsContents = extractImplicitTypesToTypescript(document);
+      const tsDir = path.join(path.dirname(fullPath), "__generated__");
+      yield fs.mkdir(tsDir, {recursive: true});
+      const tsFileName = path.join(tsDir, path.basename(fullPath, path.extname(fullPath)) + ".ts");
+      const printer = ts.createPrinter();
+      yield fs.writeFile(tsFileName, printer.printNode(ts.EmitHint.SourceFile, tsContents, tsContents), {encoding: "utf-8"});
+    }
+  });
+}
+export {
+  supermassive
+};

package/lib/collectFields.d.ts

@@ -0,0 +1,17 @@
+import { FieldNode, FragmentDefinitionNode, SelectionSetNode } from "./ast/TypedAST";
+import type { ObjMap } from "./jsutils/ObjMap";
+import { Resolvers } from "./types";
+/**
+ * Given a selectionSet, adds all of the fields in that selection to
+ * the passed in map of fields, and returns it at the end.
+ *
+ * CollectFields requires the "runtime type" of an object. For a field which
+ * returns an Interface or Union type, the "runtime type" will be the actual
+ * Object type returned by that field.
+ *
+ * @internal
+ */
+export declare function collectFields(resolvers: Resolvers, fragments: ObjMap<FragmentDefinitionNode>, variableValues: {
+    [variable: string]: unknown;
+}, runtimeTypeName: string, selectionSet: SelectionSetNode, fields: Map<string, Array<FieldNode>>, visitedFragmentNames: Set<string>): Map<string, Array<FieldNode>>;
+//# sourceMappingURL=collectFields.d.ts.map

package/lib/collectFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectFields.d.ts","sourceRoot":"","sources":["../src/collectFields.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,sBAAsB,EAGtB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,MAAM,CAAC,sBAAsB,CAAC,EACzC,cAAc,EAAE;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAC/C,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,EACrC,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,GAChC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAgE/B"}

package/lib/collectFields.js

@@ -0,0 +1,83 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 __export = (target, all) => {
+  for (var name in all)
+    __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});
+  }
+  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);
+};
+__markAsModule(exports);
+__export(exports, {
+  collectFields: () => collectFields
+});
+var import_graphql = __toModule(require("graphql"));
+function collectFields(resolvers, fragments, variableValues, runtimeTypeName, selectionSet, fields, visitedFragmentNames) {
+  for (const selection of selectionSet.selections) {
+    switch (selection.kind) {
+      case import_graphql.Kind.FIELD: {
+        if (!shouldIncludeNode(variableValues, selection)) {
+          continue;
+        }
+        const name = getFieldEntryKey(selection);
+        const fieldList = fields.get(name);
+        if (fieldList !== void 0) {
+          fieldList.push(selection);
+        } else {
+          fields.set(name, [selection]);
+        }
+        break;
+      }
+      case import_graphql.Kind.INLINE_FRAGMENT: {
+        if (!shouldIncludeNode(variableValues, selection) || !doesFragmentConditionMatch(selection, runtimeTypeName)) {
+          continue;
+        }
+        collectFields(resolvers, fragments, variableValues, runtimeTypeName, selection.selectionSet, fields, visitedFragmentNames);
+        break;
+      }
+      case import_graphql.Kind.FRAGMENT_SPREAD: {
+        const fragName = selection.name.value;
+        if (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection)) {
+          continue;
+        }
+        visitedFragmentNames.add(fragName);
+        const fragment = fragments[fragName];
+        if (!fragment || !doesFragmentConditionMatch(fragment, runtimeTypeName)) {
+          continue;
+        }
+        collectFields(resolvers, fragments, variableValues, runtimeTypeName, fragment.selectionSet, fields, visitedFragmentNames);
+        break;
+      }
+    }
+  }
+  return fields;
+}
+function shouldIncludeNode(variableValues, node) {
+  return true;
+}
+function doesFragmentConditionMatch(fragment, typeName) {
+  const typeConditionNode = fragment.typeCondition;
+  if (!typeConditionNode) {
+    return true;
+  }
+  if (typeConditionNode.name.value === typeName) {
+    return true;
+  }
+  return false;
+}
+function getFieldEntryKey(node) {
+  return node.alias ? node.alias.value : node.name.value;
+}

package/lib/collectFields.mjs

@@ -0,0 +1,61 @@
+// src/collectFields.ts
+import {Kind} from "graphql";
+function collectFields(resolvers, fragments, variableValues, runtimeTypeName, selectionSet, fields, visitedFragmentNames) {
+  for (const selection of selectionSet.selections) {
+    switch (selection.kind) {
+      case Kind.FIELD: {
+        if (!shouldIncludeNode(variableValues, selection)) {
+          continue;
+        }
+        const name = getFieldEntryKey(selection);
+        const fieldList = fields.get(name);
+        if (fieldList !== void 0) {
+          fieldList.push(selection);
+        } else {
+          fields.set(name, [selection]);
+        }
+        break;
+      }
+      case Kind.INLINE_FRAGMENT: {
+        if (!shouldIncludeNode(variableValues, selection) || !doesFragmentConditionMatch(selection, runtimeTypeName)) {
+          continue;
+        }
+        collectFields(resolvers, fragments, variableValues, runtimeTypeName, selection.selectionSet, fields, visitedFragmentNames);
+        break;
+      }
+      case Kind.FRAGMENT_SPREAD: {
+        const fragName = selection.name.value;
+        if (visitedFragmentNames.has(fragName) || !shouldIncludeNode(variableValues, selection)) {
+          continue;
+        }
+        visitedFragmentNames.add(fragName);
+        const fragment = fragments[fragName];
+        if (!fragment || !doesFragmentConditionMatch(fragment, runtimeTypeName)) {
+          continue;
+        }
+        collectFields(resolvers, fragments, variableValues, runtimeTypeName, fragment.selectionSet, fields, visitedFragmentNames);
+        break;
+      }
+    }
+  }
+  return fields;
+}
+function shouldIncludeNode(variableValues, node) {
+  return true;
+}
+function doesFragmentConditionMatch(fragment, typeName) {
+  const typeConditionNode = fragment.typeCondition;
+  if (!typeConditionNode) {
+    return true;
+  }
+  if (typeConditionNode.name.value === typeName) {
+    return true;
+  }
+  return false;
+}
+function getFieldEntryKey(node) {
+  return node.alias ? node.alias.value : node.name.value;
+}
+export {
+  collectFields
+};

package/lib/compiledQuery.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=compiledQuery.d.ts.map

package/lib/compiledQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiledQuery.d.ts","sourceRoot":"","sources":["../src/compiledQuery.ts"],"names":[],"mappings":""}

package/lib/executeWithSchema.d.ts

@@ -0,0 +1,4 @@
+import { PromiseOrValue } from "./jsutils/PromiseOrValue";
+import { ExecutionResult, ExecutionWithSchemaArgs } from "./types";
+export declare function executeWithSchema({ typeDefs, resolvers, document: rawDocument, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver, }: ExecutionWithSchemaArgs): PromiseOrValue<ExecutionResult>;
+//# sourceMappingURL=executeWithSchema.d.ts.map

package/lib/executeWithSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executeWithSchema.d.ts","sourceRoot":"","sources":["../src/executeWithSchema.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAa,eAAe,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAE9E,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,SAAS,EACT,QAAQ,EAAE,WAAW,EACrB,SAAS,EACT,YAAY,EACZ,cAAc,EACd,aAAa,EACb,aAAa,EACb,YAAY,GACb,EAAE,uBAAuB,GAAG,cAAc,CAAC,eAAe,CAAC,CA2B3D"}

package/lib/{index.test.js → executeWithSchema.js}

@@ -19,6 +19,10 @@ var __objSpread = (a, b) => {
   return a;
 };
 var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __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))
@@ -30,50 +34,45 @@ var __reExport = (target, module2, desc) => {
 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);
 };
-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 import_graphql = __toModule(require("graphql"));
-var import__ = __toModule(require("."));
-var import_swapi_schema = __toModule(require("../benchmarks/swapi-schema"));
-var import_models = __toModule(require("../benchmarks/swapi-schema/models"));
-var import_resolvers = __toModule(require("../benchmarks/swapi-schema/resolvers"));
-describe("execute", () => {
-  it.skip("executes a basic query", () => __async(void 0, null, function* () {
-    const query = `
-    {
-      person(id: 1) {
-        name
-        gender
-      }
-    }`;
-    const document = (0, import_graphql.parse)(query);
-    expect.assertions(1);
-    const args = {
-      document,
-      contextValue: {
-        models: import_models.default
-      }
-    };
-    const result = yield (0, import__.execute)(__objSpread(__objSpread({}, args), {resolvers: import_resolvers.default}));
-    const validResult = yield (0, import_graphql.execute)(__objSpread(__objSpread({}, args), {schema: import_swapi_schema.default}));
-    expect(result).toEqual(validResult);
-  }));
+__markAsModule(exports);
+__export(exports, {
+  executeWithSchema: () => executeWithSchema
 });
+var import_schema = __toModule(require("@graphql-tools/schema"));
+var import_graphql = __toModule(require("graphql"));
+var import_index = __toModule(require("./index"));
+function executeWithSchema({
+  typeDefs,
+  resolvers,
+  document: rawDocument,
+  rootValue,
+  contextValue,
+  variableValues,
+  operationName,
+  fieldResolver,
+  typeResolver
+}) {
+  const schema = (0, import_schema.makeExecutableSchema)({typeDefs, resolvers});
+  let extractedResolvers = {};
+  const getTypeByName = (name) => {
+    const type = import_index.specifiedScalars[name] || extractedResolvers[name];
+    if ((0, import_graphql.isInputType)(type)) {
+      return type;
+    } else {
+      throw new Error("Invalid type");
+    }
+  };
+  extractedResolvers = (0, import_index.extractImplicitTypes)(typeDefs, getTypeByName);
+  const fullResolvers = __objSpread(__objSpread({}, extractedResolvers), resolvers);
+  const document = (0, import_index.addTypesToRequestDocument)(schema, rawDocument);
+  return (0, import_index.executeWithoutSchema)({
+    document,
+    resolvers: fullResolvers,
+    rootValue,
+    contextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver
+  });
+}