@graphitation/supermassive 0.1.3 → 0.4.1

package/lib/benchmarks/index.mjs

@@ -0,0 +1,111 @@
+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/benchmarks/index.ts
+import fs from "fs";
+import path from "path";
+import NiceBenchmark from "./nice-benchmark.mjs";
+import schema from "./swapi-schema.mjs";
+import resolvers from "./swapi-schema/resolvers.mjs";
+import models from "./swapi-schema/models.mjs";
+import {graphql, execute as graphqlExecute, parse} from "graphql";
+import {compileQuery, isCompiledQuery} from "graphql-jit";
+import {executeWithoutSchema as supermassiveExecute} from "../executeWithoutSchema.mjs";
+import {addTypesToRequestDocument} from "../ast/addTypesToRequestDocument.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* () {
+  const result = yield supermassiveExecute({
+    resolvers,
+    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(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();

package/lib/benchmarks/nice-benchmark.d.ts

@@ -2,7 +2,7 @@ export default class NiceBenchmark {
     private name;
     private suite;
     constructor(name: string);
-    add(name: string, fn: () => Promise<any>): void;
+    add(name: string, fn: () => Promise<void> | void): void;
     run(options?: any): Promise<any>;
 }
 //# sourceMappingURL=nice-benchmark.d.ts.map

package/lib/benchmarks/nice-benchmark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nice-benchmark.d.ts","sourceRoot":"","sources":["../../benchmarks/nice-benchmark.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAQ;gBAET,IAAI,EAAE,MAAM;IAQxB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC;IAUxC,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAOjC"}
+{"version":3,"file":"nice-benchmark.d.ts","sourceRoot":"","sources":["../../src/benchmarks/nice-benchmark.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAQ;gBAET,IAAI,EAAE,MAAM;IAQxB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAUhD,GAAG,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAOjC"}

package/lib/benchmarks/nice-benchmark.js

@@ -0,0 +1,72 @@
+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, {
+  default: () => NiceBenchmark
+});
+var import_benchmark = __toModule(require("benchmark"));
+class NiceBenchmark {
+  constructor(name) {
+    this.name = name;
+    this.suite = new import_benchmark.Suite(name);
+    this.suite.on("cycle", function(event) {
+      console.log(String(event.target));
+    });
+  }
+  add(name, fn) {
+    this.suite.add(name, {
+      defer: true,
+      fn: (deferred) => __async(this, null, function* () {
+        yield fn();
+        deferred.resolve();
+      })
+    });
+  }
+  run(options) {
+    return new Promise((resolve) => {
+      this.suite.on("complete", resolve);
+      console.log(this.name);
+      this.suite.run(options);
+    });
+  }
+}

package/lib/benchmarks/nice-benchmark.mjs

@@ -0,0 +1,52 @@
+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/benchmarks/nice-benchmark.ts
+import {Suite} from "benchmark";
+var NiceBenchmark = class {
+  constructor(name) {
+    this.name = name;
+    this.suite = new Suite(name);
+    this.suite.on("cycle", function(event) {
+      console.log(String(event.target));
+    });
+  }
+  add(name, fn) {
+    this.suite.add(name, {
+      defer: true,
+      fn: (deferred) => __async(this, null, function* () {
+        yield fn();
+        deferred.resolve();
+      })
+    });
+  }
+  run(options) {
+    return new Promise((resolve) => {
+      this.suite.on("complete", resolve);
+      console.log(this.name);
+      this.suite.run(options);
+    });
+  }
+};
+var nice_benchmark_default = NiceBenchmark;
+export {
+  nice_benchmark_default as default
+};

package/lib/benchmarks/swapi-schema/index.d.ts

@@ -1,3 +1,4 @@
+export declare const typeDefs: import("graphql").DocumentNode;
 declare const _default: import("graphql").GraphQLSchema;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/lib/benchmarks/swapi-schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../benchmarks/swapi-schema/index.ts"],"names":[],"mappings":";AASA,wBAGG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/benchmarks/swapi-schema/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,gCAIpB,CAAC;;AAEF,wBAGG"}

package/lib/benchmarks/swapi-schema/index.js

@@ -0,0 +1,39 @@
+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, {
+  default: () => swapi_schema_default,
+  typeDefs: () => typeDefs
+});
+var import_schema = __toModule(require("@graphql-tools/schema"));
+var import_graphql = __toModule(require("graphql"));
+var import_path = __toModule(require("path"));
+var import_fs = __toModule(require("fs"));
+var import_resolvers = __toModule(require("./resolvers"));
+const typeDefs = (0, import_graphql.parse)((0, import_fs.readFileSync)((0, import_path.join)(__dirname, "./schema.graphql"), {
+  encoding: "utf-8"
+}));
+var swapi_schema_default = (0, import_schema.makeExecutableSchema)({
+  typeDefs,
+  resolvers: import_resolvers.default
+});

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

@@ -0,0 +1,17 @@
+// src/benchmarks/swapi-schema/index.ts
+import {makeExecutableSchema} from "@graphql-tools/schema";
+import {parse} from "graphql";
+import {join} from "path";
+import {readFileSync} from "fs";
+import resolvers from "./resolvers.mjs";
+var typeDefs = parse(readFileSync(join(__dirname, "./schema.graphql"), {
+  encoding: "utf-8"
+}));
+var swapi_schema_default = makeExecutableSchema({
+  typeDefs,
+  resolvers
+});
+export {
+  swapi_schema_default as default,
+  typeDefs
+};

package/lib/benchmarks/swapi-schema/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../benchmarks/swapi-schema/models.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;;AAEtC,wBAA8D"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/benchmarks/swapi-schema/models.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;;AAEtC,wBAA8D"}

package/lib/benchmarks/swapi-schema/models.js

@@ -0,0 +1,29 @@
+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, {
+  default: () => models_default
+});
+var import_path = __toModule(require("path"));
+var import_node_json_db = __toModule(require("node-json-db"));
+var models_default = new import_node_json_db.JsonDB(import_path.default.join(__dirname, "./starwars"));

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

@@ -0,0 +1,7 @@
+// src/benchmarks/swapi-schema/models.ts
+import path from "path";
+import {JsonDB} from "node-json-db";
+var models_default = new JsonDB(path.join(__dirname, "./starwars"));
+export {
+  models_default as default
+};

package/lib/benchmarks/swapi-schema/resolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../benchmarks/swapi-schema/resolvers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAyMpE,QAAA,MAAM,SAAS,EAAE,2BAA2B,CAAC,WAAW,CA2HvD,CAAC;AAKF,eAAe,SAAS,CAAC"}
+{"version":3,"file":"resolvers.d.ts","sourceRoot":"","sources":["../../../src/benchmarks/swapi-schema/resolvers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAyMpE,QAAA,MAAM,SAAS,EAAE,2BAA2B,CAAC,WAAW,CAmKvD,CAAC;AAKF,eAAe,SAAS,CAAC"}

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

@@ -0,0 +1,237 @@
+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;
+};
+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});
+};
+__markAsModule(exports);
+__export(exports, {
+  default: () => resolvers_default
+});
+const films = (parent, args, {models}) => {
+  return models.getData("/films").filter(({id}) => parent.films.includes(id));
+};
+const 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));
+  };
+}
+const vehicles = (parent, args, {models}) => {
+  return models.getData("/vehicles").filter(({id}) => parent.vehicles.includes(id));
+};
+const transports = (parent, args, {models}) => {
+  return models.getData("/transport").filter(({id}) => parent.starships.includes(id));
+};
+const planets = (parent, args, {models}) => {
+  return models.getData("/planets").filter(({id}) => parent.planets.includes(id));
+};
+const species = (parent, args, {models}) => {
+  return models.getData("/species").filter(({id}) => parent.species.includes(id));
+};
+const homeworld = (parent, args, {models}) => {
+  return models.getData("/planets").find((planet2) => planet2.id === parent.homeworld);
+};
+const person = (parent, {id}, {models}) => {
+  return models.getData("/people").find((person2) => person2.id === id);
+};
+const planet = (parent, {id}, {models}) => {
+  return models.getData("/planets").find((planet2) => planet2.id === id);
+};
+const film = (parent, {id}, {models}) => {
+  return models.getData("/films").find((film2) => film2.id === id);
+};
+const starship = (parent, {id}, {models}) => {
+  return models.getData("/starships").find((starship2) => starship2.id === id);
+};
+const transport = (parent, {id}, {models}) => {
+  return models.getData("/transport").find((transport2) => transport2.id === id);
+};
+const vehicle = (parent, {id}, {models}) => {
+  return models.getData("/vehicles").find((vehicle2) => vehicle2.id === id);
+};
+const searchPeopleByName = (parent, {search}, {models}) => {
+  return models.getData("/people").filter((person2) => new RegExp(search, "i").test(person2.name));
+};
+const searchPlanetsByName = (parent, {search}, {models}) => {
+  return models.getData("/planets").filter((planet2) => new RegExp(search, "i").test(planet2.name));
+};
+const searchFilmsByTitle = (parent, {search}, {models}) => {
+  return models.getData("/films").filter((film2) => new RegExp(search, "i").test(film2.title));
+};
+const searchSpeciesByName = (parent, {search}, {models}) => {
+  return models.getData("/species").filter((species2) => new RegExp(search, "i").test(species2.name));
+};
+const searchStarshipsByName = (parent, {search}, {models}) => {
+  return models.getData("/starships").filter((starship2) => new RegExp(search, "i").test(starship2.name));
+};
+const searchVehiclesByName = (parent, {search}, {models}) => {
+  return models.getData("/vehicles").filter((vehicle2) => new RegExp(search, "i").test(vehicle2.name));
+};
+const searchTransportsByName = (parent, {search}, {models}) => {
+  return models.getData("/transport").filter((transport2) => new RegExp(search, "i").test(transport2.name));
+};
+const 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
+  }
+};
+const forceNumber = (i) => Number(i.split(",").join("").split("-")[0]) || -1;
+var resolvers_default = resolvers;