@graphitation/supermassive 0.1.3 → 0.2.0

package/lib/values.js

@@ -0,0 +1,145 @@
+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, {
+  getArgumentValues: () => getArgumentValues,
+  getDirectiveValues: () => getDirectiveValues,
+  getVariableValues: () => getVariableValues,
+  specifiedScalars: () => specifiedScalars
+});
+var import_graphql = __toModule(require("graphql"));
+var import_inspect = __toModule(require("./jsutils/inspect"));
+var import_keyMap = __toModule(require("./jsutils/keyMap"));
+var import_printPathArray = __toModule(require("./jsutils/printPathArray"));
+function getVariableValues(resolvers, varDefNodes, inputs, options) {
+  const errors = [];
+  const maxErrors = options == null ? void 0 : options.maxErrors;
+  try {
+    const coerced = coerceVariableValues(resolvers, varDefNodes, inputs, (error) => {
+      if (maxErrors != null && errors.length >= maxErrors) {
+        throw new import_graphql.GraphQLError("Too many errors processing variables, error limit reached. Execution aborted.");
+      }
+      errors.push(error);
+    });
+    if (errors.length === 0) {
+      return {coerced};
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+  return {errors};
+}
+function coerceVariableValues(resolvers, varDefNodes, inputs, onError) {
+  const coercedValues = {};
+  for (const varDefNode of varDefNodes) {
+    const varName = varDefNode.variable.name.value;
+    const varTypeAst = varDefNode.type;
+    const varType = graphqlTypeFromTypeAst(resolvers, varTypeAst);
+    if (!(0, import_graphql.isInputType)(varType)) {
+      const varTypeStr = (0, import_inspect.inspect)(varType);
+      onError(new import_graphql.GraphQLError(`Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`, varDefNode.type));
+      continue;
+    }
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
+        coercedValues[varName] = (0, import_graphql.valueFromAST)(varDefNode.defaultValue, varType);
+      } else if ((0, import_graphql.isNonNullType)(varType)) {
+        const varTypeStr = (0, import_graphql.print)(varDefNode.type);
+        onError(new import_graphql.GraphQLError(`Variable "$${varName}" of required type "${varTypeStr}" was not provided.`, varDefNode));
+      }
+      continue;
+    }
+    const value = inputs[varName];
+    if (value === null && (0, import_graphql.isNonNullType)(varType)) {
+      const varTypeStr = (0, import_inspect.inspect)(varType);
+      onError(new import_graphql.GraphQLError(`Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`, varDefNode));
+      continue;
+    }
+    coercedValues[varName] = (0, import_graphql.coerceInputValue)(value, varType, (path, invalidValue, error) => {
+      let prefix = `Variable "$${varName}" got invalid value ` + (0, import_inspect.inspect)(invalidValue);
+      if (path.length > 0) {
+        prefix += ` at "${varName}${(0, import_printPathArray.printPathArray)(path)}"`;
+      }
+      onError(new import_graphql.GraphQLError(prefix + "; " + error.message, varDefNode, void 0, void 0, void 0, error.originalError));
+    });
+  }
+  return coercedValues;
+}
+function getArgumentValues(resolvers, node, variableValues) {
+  var _a;
+  const coercedValues = {};
+  const argumentNodes = (_a = node.arguments) != null ? _a : [];
+  const argNodeMap = (0, import_keyMap.keyMap)(argumentNodes, (arg) => arg.name.value);
+  for (const argumentNode of argumentNodes) {
+    const name = argumentNode.name.value;
+    const argTypeNode = argumentNode.__type;
+    const argType = graphqlTypeFromTypeAst(resolvers, argTypeNode);
+    if (!(0, import_graphql.isInputType)(argType)) {
+      console.log(argType, (0, import_graphql.isInputType)(argType));
+      throw new import_graphql.GraphQLError(`Argument "$${name}" expected value of type "${(0, import_inspect.inspect)(argType)}" which cannot be used as an input type.`, argumentNode);
+    }
+    let valueNode = argumentNode.value;
+    let isNull = valueNode.kind === import_graphql.Kind.NULL;
+    if (valueNode.kind === import_graphql.Kind.VARIABLE) {
+      const variableName = valueNode.name.value;
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (argumentNode.__defaultValue != void 0) {
+          valueNode = argumentNode.__defaultValue;
+        } else if ((0, import_graphql.isNonNullType)(argType)) {
+          throw new import_graphql.GraphQLError(`Argument "${name}" of required type "${(0, import_inspect.inspect)(argType)}" was provided the variable "$${variableName}" which was not provided a runtime value.`, valueNode);
+        }
+      }
+      isNull = !variableValues || variableValues[variableName] == null;
+    }
+    const coercedValue = (0, import_graphql.valueFromAST)(valueNode, argType, variableValues);
+    if (coercedValue === void 0) {
+      throw new import_graphql.GraphQLError(`Argument "${name}" has invalid value ${(0, import_graphql.print)(valueNode)}.`, valueNode);
+    }
+    coercedValues[name] = coercedValue;
+  }
+  return coercedValues;
+}
+function getDirectiveValues(resolvers, node, variableValues) {
+  throw new Error("Todo");
+}
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+const specifiedScalars = {
+  ID: import_graphql.GraphQLID,
+  String: import_graphql.GraphQLString,
+  Int: import_graphql.GraphQLInt,
+  Float: import_graphql.GraphQLFloat,
+  Boolean: import_graphql.GraphQLBoolean
+};
+function graphqlTypeFromTypeAst(resolvers, node) {
+  if (node.kind === import_graphql.Kind.NON_NULL_TYPE) {
+    return new import_graphql.GraphQLNonNull(graphqlTypeFromTypeAst(resolvers, node.type));
+  } else if (node.kind === import_graphql.Kind.LIST_TYPE) {
+    return new import_graphql.GraphQLList(graphqlTypeFromTypeAst(resolvers, node.type));
+  } else {
+    const typeName = node.name.value;
+    const type = specifiedScalars[typeName] || resolvers[typeName];
+    return type;
+  }
+}

package/lib/values.mjs

@@ -0,0 +1,137 @@
+import {
+  GraphQLBoolean,
+  GraphQLError,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLString,
+  isInputType,
+  isNonNullType,
+  Kind,
+  print,
+  valueFromAST,
+  coerceInputValue
+} from "graphql";
+import {inspect} from "./jsutils/inspect";
+import {keyMap} from "./jsutils/keyMap";
+import {printPathArray} from "./jsutils/printPathArray";
+function getVariableValues(resolvers, varDefNodes, inputs, options) {
+  const errors = [];
+  const maxErrors = options == null ? void 0 : options.maxErrors;
+  try {
+    const coerced = coerceVariableValues(resolvers, varDefNodes, inputs, (error) => {
+      if (maxErrors != null && errors.length >= maxErrors) {
+        throw new GraphQLError("Too many errors processing variables, error limit reached. Execution aborted.");
+      }
+      errors.push(error);
+    });
+    if (errors.length === 0) {
+      return {coerced};
+    }
+  } catch (error) {
+    errors.push(error);
+  }
+  return {errors};
+}
+function coerceVariableValues(resolvers, varDefNodes, inputs, onError) {
+  const coercedValues = {};
+  for (const varDefNode of varDefNodes) {
+    const varName = varDefNode.variable.name.value;
+    const varTypeAst = varDefNode.type;
+    const varType = graphqlTypeFromTypeAst(resolvers, varTypeAst);
+    if (!isInputType(varType)) {
+      const varTypeStr = inspect(varType);
+      onError(new GraphQLError(`Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`, varDefNode.type));
+      continue;
+    }
+    if (!hasOwnProperty(inputs, varName)) {
+      if (varDefNode.defaultValue) {
+        coercedValues[varName] = valueFromAST(varDefNode.defaultValue, varType);
+      } else if (isNonNullType(varType)) {
+        const varTypeStr = print(varDefNode.type);
+        onError(new GraphQLError(`Variable "$${varName}" of required type "${varTypeStr}" was not provided.`, varDefNode));
+      }
+      continue;
+    }
+    const value = inputs[varName];
+    if (value === null && isNonNullType(varType)) {
+      const varTypeStr = inspect(varType);
+      onError(new GraphQLError(`Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`, varDefNode));
+      continue;
+    }
+    coercedValues[varName] = coerceInputValue(value, varType, (path, invalidValue, error) => {
+      let prefix = `Variable "$${varName}" got invalid value ` + inspect(invalidValue);
+      if (path.length > 0) {
+        prefix += ` at "${varName}${printPathArray(path)}"`;
+      }
+      onError(new GraphQLError(prefix + "; " + error.message, varDefNode, void 0, void 0, void 0, error.originalError));
+    });
+  }
+  return coercedValues;
+}
+function getArgumentValues(resolvers, node, variableValues) {
+  var _a;
+  const coercedValues = {};
+  const argumentNodes = (_a = node.arguments) != null ? _a : [];
+  const argNodeMap = keyMap(argumentNodes, (arg) => arg.name.value);
+  for (const argumentNode of argumentNodes) {
+    const name = argumentNode.name.value;
+    const argTypeNode = argumentNode.__type;
+    const argType = graphqlTypeFromTypeAst(resolvers, argTypeNode);
+    if (!isInputType(argType)) {
+      console.log(argType, isInputType(argType));
+      throw new GraphQLError(`Argument "$${name}" expected value of type "${inspect(argType)}" which cannot be used as an input type.`, argumentNode);
+    }
+    let valueNode = argumentNode.value;
+    let isNull = valueNode.kind === Kind.NULL;
+    if (valueNode.kind === Kind.VARIABLE) {
+      const variableName = valueNode.name.value;
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (argumentNode.__defaultValue != void 0) {
+          valueNode = argumentNode.__defaultValue;
+        } else if (isNonNullType(argType)) {
+          throw new GraphQLError(`Argument "${name}" of required type "${inspect(argType)}" was provided the variable "$${variableName}" which was not provided a runtime value.`, valueNode);
+        }
+      }
+      isNull = !variableValues || variableValues[variableName] == null;
+    }
+    const coercedValue = valueFromAST(valueNode, argType, variableValues);
+    if (coercedValue === void 0) {
+      throw new GraphQLError(`Argument "${name}" has invalid value ${print(valueNode)}.`, valueNode);
+    }
+    coercedValues[name] = coercedValue;
+  }
+  return coercedValues;
+}
+function getDirectiveValues(resolvers, node, variableValues) {
+  throw new Error("Todo");
+}
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+const specifiedScalars = {
+  ID: GraphQLID,
+  String: GraphQLString,
+  Int: GraphQLInt,
+  Float: GraphQLFloat,
+  Boolean: GraphQLBoolean
+};
+function graphqlTypeFromTypeAst(resolvers, node) {
+  if (node.kind === Kind.NON_NULL_TYPE) {
+    return new GraphQLNonNull(graphqlTypeFromTypeAst(resolvers, node.type));
+  } else if (node.kind === Kind.LIST_TYPE) {
+    return new GraphQLList(graphqlTypeFromTypeAst(resolvers, node.type));
+  } else {
+    const typeName = node.name.value;
+    const type = specifiedScalars[typeName] || resolvers[typeName];
+    return type;
+  }
+}
+export {
+  getArgumentValues,
+  getDirectiveValues,
+  getVariableValues,
+  specifiedScalars
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graphitation/supermassive",
   "license": "MIT",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "main": "./lib/index",
   "scripts": {
     "build": "monorepo-scripts build",
@@ -9,16 +9,15 @@
     "test": "monorepo-scripts test",
     "types": "monorepo-scripts types",
     "just": "monorepo-scripts",
-    "benchmark": "ts-node -T -O '{\"module\":\"commonjs\"}' ./benchmarks/index.ts"
+    "benchmark": "ts-node -T -O '{\"module\":\"commonjs\"}' ./src/benchmarks/index.ts"
   },
   "devDependencies": {
     "@graphitation/graphql-js-tag": "*",
-    "@graphql-tools/schema": "^7.1.5",
+    "@ts-morph/bootstrap": "^0.11.0",
     "@types/benchmark": "^2.1.0",
     "@types/jest": "^26.0.22",
     "@types/node-json-db": "^0.9.3",
     "benchmark": "^2.1.4",
-    "graphql": "^15.0.0",
     "graphql-jit": "^0.5.1",
     "monorepo-scripts": "*",
     "node-json-db": "^1.3.0",
@@ -27,5 +26,11 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@graphql-tools/schema": "^7.1.5",
+    "commander": "^8.3.0",
+    "graphql": "^15.6.1",
+    "typescript": "4.4.3"
+  },
   "types": "./lib/index.d.ts"
 }

package/CHANGELOG.json

@@ -1,65 +0,0 @@
-{
-  "name": "@graphitation/supermassive",
-  "entries": [
-    {
-      "date": "Tue, 26 Oct 2021 21:09:16 GMT",
-      "tag": "@graphitation/supermassive_v0.1.3",
-      "version": "0.1.3",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Bump @graphitation/graphql-js-tag to v0.5.5",
-            "author": "modevold@microsoft.com",
-            "commit": "6fbd717cb21f2e9f49ddca58e0365b5381358b46",
-            "package": "@graphitation/supermassive"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Tue, 26 Oct 2021 12:46:12 GMT",
-      "tag": "@graphitation/supermassive_v0.1.2",
-      "version": "0.1.2",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Align graphql dependency to version ^15.0.0 across packages",
-            "author": "modevold@microsoft.com",
-            "commit": "d8b94fe7725a968abfac81953b97a879b2bdaeb3",
-            "package": "@graphitation/supermassive"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Mon, 04 Oct 2021 13:48:04 GMT",
-      "tag": "@graphitation/supermassive_v0.1.1",
-      "version": "0.1.1",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Bump @graphitation/graphql-js-tag to v0.5.4",
-            "author": "eloy.de.enige@gmail.com",
-            "commit": "ceb24aa25210090e38251be53d010d75abdad9ba",
-            "package": "@graphitation/supermassive"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Thu, 24 Jun 2021 12:32:15 GMT",
-      "tag": "@graphitation/supermassive_v0.1.0",
-      "version": "0.1.0",
-      "comments": {
-        "none": [
-          {
-            "comment": "Test and benchmark setup for supermassive",
-            "author": "eloy.de.enige@gmail.com",
-            "commit": "ebbad29ec11dae814bbe8c2e492d1baf5382c138",
-            "package": "@graphitation/supermassive"
-          }
-        ]
-      }
-    }
-  ]
-}

package/benchmarks/fixtures/query1.graphql

@@ -1,20 +0,0 @@
-{
-  empireHero: person(id: 1) {
-    ...PersonFields
-    height
-    mass
-  }
-
-  jediHero: person(id: 4) {
-    ...PersonFields
-  }
-}
-
-fragment PersonFields on Person {
-  name
-  gender
-  birth_year
-  starships {
-    name
-  }
-}

package/benchmarks/index.ts

@@ -1,68 +0,0 @@
-import fs from "fs";
-import path from "path";
-import NiceBenchmark from "./nice-benchmark";
-import schema from "./swapi-schema";
-import models from "./swapi-schema/models";
-import { graphql, execute, parse } from "graphql";
-import { compileQuery, isCompiledQuery } from "graphql-jit";
-
-const query = fs.readFileSync(
-  path.join(__dirname, "./fixtures/query1.graphql"),
-  {
-    encoding: "utf-8",
-  }
-);
-
-const parsedQuery = parse(query);
-
-const compiledQuery = compileQuery(schema, parsedQuery);
-
-const queryRunningSuite = new NiceBenchmark("Query Running");
-queryRunningSuite.add("string queries graphql-js", async () => {
-  const result = await graphql({
-    schema,
-    source: query,
-    contextValue: { models },
-  });
-  if (result.errors || !result.data) {
-    throw new Error("Stuff ain't executing");
-  }
-});
-queryRunningSuite.add("parsed queries graphql-js", async () => {
-  const result = await execute({
-    schema,
-    document: parsedQuery,
-    contextValue: { models },
-  });
-  if (result.errors || !result.data) {
-    throw new Error("Stuff ain't executing");
-  }
-});
-queryRunningSuite.add("graphql-jit", async () => {
-  if (isCompiledQuery(compiledQuery)) {
-    const result = await compiledQuery.query({}, { models }, {});
-    if (result.errors || !result.data) {
-      throw new Error("Stuff ain't executing");
-    }
-  } else {
-    throw new Error("Wrong query");
-  }
-});
-
-const queryParsingSuite = new NiceBenchmark("Query parsing");
-queryParsingSuite.add("graphql-js", async () => {
-  parse(query);
-});
-
-const queryCompilingSuite = new NiceBenchmark("Query compiling");
-queryCompilingSuite.add("graphql-jit", async () => {
-  await compileQuery(schema, parsedQuery);
-});
-
-async function main() {
-  await queryParsingSuite.run();
-  await queryCompilingSuite.run();
-  await queryRunningSuite.run();
-}
-
-main();

package/benchmarks/nice-benchmark.ts

@@ -1,32 +0,0 @@
-import { Suite } from "benchmark";
-
-export default class NiceBenchmark {
-  private name: string;
-  private suite: Suite;
-
-  constructor(name: string) {
-    this.name = name;
-    this.suite = new Suite(name);
-    this.suite.on("cycle", function (event: any) {
-      console.log(String(event.target));
-    });
-  }
-
-  add(name: string, fn: () => Promise<any>) {
-    this.suite.add(name, {
-      defer: true,
-      fn: async (deferred: any) => {
-        await fn();
-        deferred.resolve();
-      },
-    });
-  }
-
-  run(options?: any): Promise<any> {
-    return new Promise((resolve) => {
-      this.suite.on("complete", resolve);
-      console.log(this.name);
-      this.suite.run(options);
-    });
-  }
-}

package/benchmarks/swapi-schema/index.ts

@@ -1,13 +0,0 @@
-import { makeExecutableSchema } from "@graphql-tools/schema";
-import { join } from "path";
-import { readFileSync } from "fs";
-import resolvers from "./resolvers";
-
-const typeDefs = readFileSync(join(__dirname, "./schema.graphql"), {
-  encoding: "utf-8",
-});
-
-export default makeExecutableSchema({
-  typeDefs,
-  resolvers,
-});

package/benchmarks/swapi-schema/models.ts

@@ -1,4 +0,0 @@
-import path from "path";
-import { JsonDB } from "node-json-db";
-
-export default new JsonDB(path.join(__dirname, "./starwars"));