@graphitation/supermassive 0.1.2 → 0.4.0

package/lib/executeWithoutSchema.js

@@ -0,0 +1,376 @@
+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, {
+  assertValidExecutionArguments: () => assertValidExecutionArguments,
+  buildExecutionContext: () => buildExecutionContext,
+  buildResolveInfo: () => buildResolveInfo,
+  defaultFieldResolver: () => defaultFieldResolver,
+  defaultTypeResolver: () => defaultTypeResolver,
+  executeWithoutSchema: () => executeWithoutSchema
+});
+var import_graphql = __toModule(require("graphql"));
+var import_collectFields = __toModule(require("./collectFields"));
+var import_devAssert = __toModule(require("./jsutils/devAssert"));
+var import_inspect = __toModule(require("./jsutils/inspect"));
+var import_invariant = __toModule(require("./jsutils/invariant"));
+var import_isIterableObject = __toModule(require("./jsutils/isIterableObject"));
+var import_isObjectLike = __toModule(require("./jsutils/isObjectLike"));
+var import_isPromise = __toModule(require("./jsutils/isPromise"));
+var import_Path = __toModule(require("./jsutils/Path"));
+var import_promiseForObject = __toModule(require("./jsutils/promiseForObject"));
+var import_promiseReduce = __toModule(require("./jsutils/promiseReduce"));
+var import_typeNameFromAST = __toModule(require("./utilities/typeNameFromAST"));
+var import_values = __toModule(require("./values"));
+function executeWithoutSchema(args) {
+  const {
+    resolvers,
+    document,
+    rootValue,
+    contextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver
+  } = args;
+  assertValidExecutionArguments(document, variableValues);
+  const exeContext = buildExecutionContext(resolvers, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver);
+  if (!("resolvers" in exeContext)) {
+    return {errors: exeContext};
+  } else {
+    const data = executeOperation(exeContext, exeContext.operation, rootValue);
+    return buildResponse(exeContext, data);
+  }
+}
+function buildResponse(exeContext, data) {
+  if ((0, import_isPromise.isPromise)(data)) {
+    return data.then((resolved) => buildResponse(exeContext, resolved));
+  }
+  return exeContext.errors.length === 0 ? {data} : {errors: exeContext.errors, data};
+}
+function assertValidExecutionArguments(document, rawVariableValues) {
+  (0, import_devAssert.devAssert)(document, "Must provide document.");
+  (0, import_devAssert.devAssert)(rawVariableValues == null || (0, import_isObjectLike.isObjectLike)(rawVariableValues), "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided.");
+}
+function buildExecutionContext(resolvers, document, rootValue, contextValue, rawVariableValues, operationName, fieldResolver, typeResolver) {
+  var _a, _b;
+  let operation;
+  const fragments = Object.create(null);
+  for (const definition of document.definitions) {
+    switch (definition.kind) {
+      case import_graphql.Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== void 0) {
+            return [
+              new import_graphql.GraphQLError("Must provide operation name if query contains multiple operations.")
+            ];
+          }
+          operation = definition;
+        } else if (((_a = definition.name) == null ? void 0 : _a.value) === operationName) {
+          operation = definition;
+        }
+        break;
+      case import_graphql.Kind.FRAGMENT_DEFINITION:
+        fragments[definition.name.value] = definition;
+        break;
+    }
+  }
+  if (!operation) {
+    if (operationName != null) {
+      return [new import_graphql.GraphQLError(`Unknown operation named "${operationName}".`)];
+    }
+    return [new import_graphql.GraphQLError("Must provide an operation.")];
+  }
+  const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const coercedVariableValues = (0, import_values.getVariableValues)(resolvers, variableDefinitions, rawVariableValues != null ? rawVariableValues : {}, {maxErrors: 50});
+  if (coercedVariableValues.errors) {
+    return coercedVariableValues.errors;
+  }
+  return {
+    resolvers,
+    fragments,
+    rootValue,
+    contextValue,
+    operation,
+    variableValues: coercedVariableValues.coerced,
+    fieldResolver: fieldResolver != null ? fieldResolver : defaultFieldResolver,
+    typeResolver: typeResolver != null ? typeResolver : defaultTypeResolver,
+    errors: []
+  };
+}
+function executeOperation(exeContext, operation, rootValue) {
+  const typeName = getOperationRootTypeName(operation);
+  const fields = (0, import_collectFields.collectFields)(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, typeName, operation.selectionSet, new Map(), new Set());
+  const path = void 0;
+  try {
+    const result = operation.operation === "mutation" ? executeFieldsSerially(exeContext, typeName, rootValue, path, fields) : executeFields(exeContext, typeName, rootValue, path, fields);
+    if ((0, import_isPromise.isPromise)(result)) {
+      return result.then(void 0, (error) => {
+        exeContext.errors.push(error);
+        return Promise.resolve(null);
+      });
+    }
+    return result;
+  } catch (error) {
+    exeContext.errors.push(error);
+    return null;
+  }
+}
+function executeFieldsSerially(exeContext, parentTypeName, sourceValue, path, fields) {
+  return (0, import_promiseReduce.promiseReduce)(fields.entries(), (results, [responseName, fieldNodes]) => {
+    const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
+    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
+    if (result === void 0) {
+      return results;
+    }
+    if ((0, import_isPromise.isPromise)(result)) {
+      return result.then((resolvedResult) => {
+        results[responseName] = resolvedResult;
+        return results;
+      });
+    }
+    results[responseName] = result;
+    return results;
+  }, Object.create(null));
+}
+function executeFields(exeContext, parentTypeName, sourceValue, path, fields) {
+  const results = Object.create(null);
+  let containsPromise = false;
+  for (const [responseName, fieldNodes] of fields.entries()) {
+    const fieldPath = (0, import_Path.addPath)(path, responseName, parentTypeName);
+    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
+    if (result !== void 0) {
+      results[responseName] = result;
+      if ((0, import_isPromise.isPromise)(result)) {
+        containsPromise = true;
+      }
+    }
+  }
+  if (!containsPromise) {
+    return results;
+  }
+  return (0, import_promiseForObject.promiseForObject)(results);
+}
+function executeField(exeContext, parentTypeName, source, fieldNodes, path) {
+  const fieldName = fieldNodes[0].name.value;
+  let resolveFn;
+  let returnTypeName;
+  let returnTypeNode;
+  if (fieldName === "__typename" && !resolveFn) {
+    resolveFn = () => parentTypeName;
+    returnTypeName = "String";
+    returnTypeNode = {
+      kind: import_graphql.Kind.NAMED_TYPE,
+      name: {
+        kind: import_graphql.Kind.NAME,
+        value: "String"
+      }
+    };
+  } else {
+    returnTypeNode = fieldNodes[0].__type;
+    returnTypeName = (0, import_typeNameFromAST.typeNameFromAST)(returnTypeNode);
+    const typeResolvers = exeContext.resolvers[parentTypeName];
+    resolveFn = typeResolvers == null ? void 0 : typeResolvers[fieldName];
+  }
+  if (!resolveFn) {
+    resolveFn = exeContext.fieldResolver;
+  }
+  const info = buildResolveInfo(exeContext, fieldName, fieldNodes, parentTypeName, returnTypeName, returnTypeNode, path);
+  try {
+    const args = (0, import_values.getArgumentValues)(exeContext.resolvers, fieldNodes[0], exeContext.variableValues);
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(source, args, contextValue, info);
+    let completed;
+    if ((0, import_isPromise.isPromise)(result)) {
+      completed = result.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resolved));
+    } else {
+      completed = completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result);
+    }
+    if ((0, import_isPromise.isPromise)(completed)) {
+      return completed.then(void 0, (rawError) => {
+        const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(path));
+        return handleFieldError(error, returnTypeNode, exeContext);
+      });
+    }
+    return completed;
+  } catch (rawError) {
+    const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(path));
+    return handleFieldError(error, returnTypeNode, exeContext);
+  }
+}
+function buildResolveInfo(exeContext, fieldName, fieldNodes, parentTypeName, returnTypeName, returnTypeNode, path) {
+  return {
+    fieldName,
+    fieldNodes,
+    returnTypeName,
+    parentTypeName,
+    returnTypeNode,
+    path,
+    fragments: exeContext.fragments,
+    rootValue: exeContext.rootValue,
+    operation: exeContext.operation,
+    variableValues: exeContext.variableValues
+  };
+}
+function handleFieldError(error, returnTypeNode, exeContext) {
+  if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
+    throw error;
+  }
+  exeContext.errors.push(error);
+  return null;
+}
+function completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+  if (result instanceof Error) {
+    throw result;
+  }
+  if (returnTypeNode.kind === import_graphql.Kind.NON_NULL_TYPE) {
+    const completed = completeValue(exeContext, returnTypeNode.type, fieldNodes, info, path, result);
+    if (completed === null) {
+      throw new Error(`Cannot return null for non-nullable field ${info.parentTypeName}.${info.fieldName}.`);
+    }
+    return completed;
+  }
+  if (result == null) {
+    return null;
+  }
+  if (returnTypeNode.kind === import_graphql.Kind.LIST_TYPE) {
+    return completeListValue(exeContext, returnTypeNode.type, fieldNodes, info, path, result);
+  }
+  const returnTypeName = returnTypeNode.name.value;
+  let returnType = exeContext.resolvers[returnTypeName];
+  if (!returnType) {
+    returnType = import_values.specifiedScalars[returnTypeName];
+  }
+  if ((0, import_graphql.isLeafType)(returnType)) {
+    return completeLeafValue(returnType, result);
+  }
+  if (returnType instanceof import_graphql.GraphQLInputObjectType) {
+  }
+  if ("__resolveType" in returnType) {
+    return completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result);
+  }
+  if (typeof returnType === "object") {
+    return completeObjectValue(exeContext, returnTypeName, fieldNodes, info, path, result);
+  }
+  (0, import_invariant.invariant)(false, "Cannot complete value of unexpected output type: " + (0, import_inspect.inspect)(returnType));
+}
+function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+  if (!(0, import_isIterableObject.isIterableObject)(result)) {
+    throw new import_graphql.GraphQLError(`Expected Iterable, but did not find one for field "${info.parentTypeName}.${info.fieldName}".`);
+  }
+  let containsPromise = false;
+  const completedResults = Array.from(result, (item, index) => {
+    const itemPath = (0, import_Path.addPath)(path, index, void 0);
+    try {
+      let completedItem;
+      if ((0, import_isPromise.isPromise)(item)) {
+        completedItem = item.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, resolved));
+      } else {
+        completedItem = completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, item);
+      }
+      if ((0, import_isPromise.isPromise)(completedItem)) {
+        containsPromise = true;
+        return completedItem.then(void 0, (rawError) => {
+          const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(itemPath));
+          return handleFieldError(error, returnTypeNode, exeContext);
+        });
+      }
+      return completedItem;
+    } catch (rawError) {
+      const error = (0, import_graphql.locatedError)(rawError, fieldNodes, (0, import_Path.pathToArray)(itemPath));
+      return handleFieldError(error, returnTypeNode, exeContext);
+    }
+  });
+  return containsPromise ? Promise.all(completedResults) : completedResults;
+}
+function completeLeafValue(returnType, result) {
+  const serializedResult = returnType.serialize(result);
+  if (serializedResult === void 0) {
+    throw new Error(`Expected a value of type "${(0, import_inspect.inspect)(returnType)}" but received: ${(0, import_inspect.inspect)(result)}`);
+  }
+  return serializedResult;
+}
+function completeAbstractValue(exeContext, returnType, fieldNodes, info, path, result) {
+  var _a;
+  const resolveTypeFn = (_a = returnType.__resolveType) != null ? _a : exeContext.typeResolver;
+  const contextValue = exeContext.contextValue;
+  const runtimeTypeName = resolveTypeFn(result, contextValue, info);
+  if ((0, import_isPromise.isPromise)(runtimeTypeName)) {
+    return runtimeTypeName.then((resolvedRuntimeTypeName) => completeObjectValue(exeContext, ensureValidRuntimeType(resolvedRuntimeTypeName, exeContext), fieldNodes, info, path, result));
+  }
+  return completeObjectValue(exeContext, ensureValidRuntimeType(runtimeTypeName, exeContext), fieldNodes, info, path, result);
+}
+function ensureValidRuntimeType(runtimeTypeName, exeContext) {
+  if (typeof runtimeTypeName === "string") {
+    const runtimeType = exeContext.resolvers[runtimeTypeName];
+    if (!runtimeType) {
+      throw new Error("TODO - no such type");
+    } else if (runtimeType instanceof import_graphql.GraphQLScalarType || runtimeType instanceof import_graphql.GraphQLEnumType || runtimeType instanceof import_graphql.GraphQLInputObjectType || runtimeType.__resolveType) {
+      throw new Error("TODO - invalid runtime type");
+    } else {
+      return runtimeTypeName;
+    }
+  }
+  throw new Error("TODO - Could not determine runtime type for abstract type");
+}
+function completeObjectValue(exeContext, returnTypeName, fieldNodes, info, path, result) {
+  const subFieldNodes = collectSubfields(exeContext, returnTypeName, fieldNodes);
+  return executeFields(exeContext, returnTypeName, result, path, subFieldNodes);
+}
+function invalidReturnTypeError(returnType, result, fieldNodes) {
+  return new import_graphql.GraphQLError(`Expected value of type "${returnType.name}" but got: ${(0, import_inspect.inspect)(result)}.`, fieldNodes);
+}
+function collectSubfields(exeContext, returnTypeName, fieldNodes) {
+  let subFieldNodes = new Map();
+  const visitedFragmentNames = new Set();
+  for (const node of fieldNodes) {
+    if (node.selectionSet) {
+      subFieldNodes = (0, import_collectFields.collectFields)(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, returnTypeName, node.selectionSet, subFieldNodes, visitedFragmentNames);
+    }
+  }
+  return subFieldNodes;
+}
+const defaultTypeResolver = function(value) {
+  if ((0, import_isObjectLike.isObjectLike)(value) && typeof value.__typename === "string") {
+    return value.__typename;
+  }
+};
+const defaultFieldResolver = function(source, args, contextValue, info) {
+  if ((0, import_isObjectLike.isObjectLike)(source) || typeof source === "function") {
+    const property = source[info.fieldName];
+    if (typeof property === "function") {
+      return source[info.fieldName](args, contextValue, info);
+    }
+    return property;
+  }
+};
+function getOperationRootTypeName(operation) {
+  switch (operation.operation) {
+    case "query":
+      return "Query";
+    case "mutation":
+      return "Mutation";
+    case "subscription":
+      return "Subscription";
+  }
+}