@graphitation/supermassive 0.1.3 → 0.2.0

package/lib/execute.mjs

@@ -0,0 +1,365 @@
+import {
+  GraphQLEnumType,
+  GraphQLError,
+  GraphQLInputObjectType,
+  GraphQLScalarType,
+  isLeafType,
+  Kind,
+  locatedError
+} from "graphql";
+import {collectFields} from "./collectFields";
+import {devAssert} from "./jsutils/devAssert";
+import {inspect} from "./jsutils/inspect";
+import {invariant} from "./jsutils/invariant";
+import {isIterableObject} from "./jsutils/isIterableObject";
+import {isObjectLike} from "./jsutils/isObjectLike";
+import {isPromise} from "./jsutils/isPromise";
+import {addPath, pathToArray} from "./jsutils/Path";
+import {promiseForObject} from "./jsutils/promiseForObject";
+import {promiseReduce} from "./jsutils/promiseReduce";
+import {typeNameFromAST} from "./utilities/typeNameFromAST";
+import {
+  getArgumentValues,
+  getVariableValues,
+  specifiedScalars
+} from "./values";
+function execute(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 (isPromise(data)) {
+    return data.then((resolved) => buildResponse(exeContext, resolved));
+  }
+  return exeContext.errors.length === 0 ? {data} : {errors: exeContext.errors, data};
+}
+function assertValidExecutionArguments(document, rawVariableValues) {
+  devAssert(document, "Must provide document.");
+  devAssert(rawVariableValues == null || 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 Kind.OPERATION_DEFINITION:
+        if (operationName == null) {
+          if (operation !== void 0) {
+            return [
+              new 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 Kind.FRAGMENT_DEFINITION:
+        fragments[definition.name.value] = definition;
+        break;
+    }
+  }
+  if (!operation) {
+    if (operationName != null) {
+      return [new GraphQLError(`Unknown operation named "${operationName}".`)];
+    }
+    return [new GraphQLError("Must provide an operation.")];
+  }
+  const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
+  const coercedVariableValues = 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 = 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 (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 promiseReduce(fields.entries(), (results, [responseName, fieldNodes]) => {
+    const fieldPath = addPath(path, responseName, parentTypeName);
+    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
+    if (result === void 0) {
+      return results;
+    }
+    if (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 = addPath(path, responseName, parentTypeName);
+    const result = executeField(exeContext, parentTypeName, sourceValue, fieldNodes, fieldPath);
+    if (result !== void 0) {
+      results[responseName] = result;
+      if (isPromise(result)) {
+        containsPromise = true;
+      }
+    }
+  }
+  if (!containsPromise) {
+    return results;
+  }
+  return 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: Kind.NAMED_TYPE,
+      name: {
+        kind: Kind.NAME,
+        value: "String"
+      }
+    };
+  } else {
+    returnTypeNode = fieldNodes[0].__type;
+    returnTypeName = 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 = getArgumentValues(exeContext.resolvers, fieldNodes[0], exeContext.variableValues);
+    const contextValue = exeContext.contextValue;
+    const result = resolveFn(source, args, contextValue, info);
+    let completed;
+    if (isPromise(result)) {
+      completed = result.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, path, resolved));
+    } else {
+      completed = completeValue(exeContext, returnTypeNode, fieldNodes, info, path, result);
+    }
+    if (isPromise(completed)) {
+      return completed.then(void 0, (rawError) => {
+        const error = locatedError(rawError, fieldNodes, pathToArray(path));
+        return handleFieldError(error, returnTypeNode, exeContext);
+      });
+    }
+    return completed;
+  } catch (rawError) {
+    const error = locatedError(rawError, fieldNodes, 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 === 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 === 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 === 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 = specifiedScalars[returnTypeName];
+  }
+  if (isLeafType(returnType)) {
+    return completeLeafValue(returnType, result);
+  }
+  if (returnType instanceof 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);
+  }
+  invariant(false, "Cannot complete value of unexpected output type: " + inspect(returnType));
+}
+function completeListValue(exeContext, returnTypeNode, fieldNodes, info, path, result) {
+  if (!isIterableObject(result)) {
+    throw new 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 = addPath(path, index, void 0);
+    try {
+      let completedItem;
+      if (isPromise(item)) {
+        completedItem = item.then((resolved) => completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, resolved));
+      } else {
+        completedItem = completeValue(exeContext, returnTypeNode, fieldNodes, info, itemPath, item);
+      }
+      if (isPromise(completedItem)) {
+        containsPromise = true;
+        return completedItem.then(void 0, (rawError) => {
+          const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
+          return handleFieldError(error, returnTypeNode, exeContext);
+        });
+      }
+      return completedItem;
+    } catch (rawError) {
+      const error = locatedError(rawError, fieldNodes, 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 "${inspect(returnType)}" but received: ${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 (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 GraphQLScalarType || runtimeType instanceof GraphQLEnumType || runtimeType instanceof 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 GraphQLError(`Expected value of type "${returnType.name}" but got: ${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 = collectFields(exeContext.resolvers, exeContext.fragments, exeContext.variableValues, returnTypeName, node.selectionSet, subFieldNodes, visitedFragmentNames);
+    }
+  }
+  return subFieldNodes;
+}
+const defaultTypeResolver = function(value) {
+  if (isObjectLike(value) && typeof value.__typename === "string") {
+    return value.__typename;
+  }
+};
+const defaultFieldResolver = function(source, args, contextValue, info) {
+  if (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";
+  }
+}
+export {
+  assertValidExecutionArguments,
+  buildExecutionContext,
+  buildResolveInfo,
+  defaultFieldResolver,
+  defaultTypeResolver,
+  execute
+};

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":"AASA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAIL,eAAe,EACf,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAEjB,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());
-  });
-};
+__markAsModule(exports);
+__export(exports, {
+  executeWithSchema: () => executeWithSchema
+});
+var import_schema = __toModule(require("@graphql-tools/schema"));
 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);
-  }));
-});
+function executeWithSchema({
+  typeDefs,
+  resolvers: resolvers2,
+  document: rawDocument,
+  rootValue,
+  contextValue,
+  variableValues,
+  operationName,
+  fieldResolver,
+  typeResolver
+}) {
+  const schema = (0, import_schema.makeExecutableSchema)({typeDefs, resolvers: resolvers2});
+  let extractedResolvers = {};
+  const getTypeByName = (name) => {
+    const type = import__.specifiedScalars[name] || extractedResolvers[name];
+    if ((0, import_graphql.isInputType)(type)) {
+      return type;
+    } else {
+      throw new Error("Invalid type");
+    }
+  };
+  extractedResolvers = (0, import__.extractImplicitTypes)(typeDefs, getTypeByName);
+  const fullResolvers = __objSpread(__objSpread({}, extractedResolvers), resolvers2);
+  const document = (0, import__.addTypesToRequestDocument)(schema, rawDocument);
+  return (0, import__.executeWithoutSchema)({
+    document,
+    resolvers: fullResolvers,
+    rootValue,
+    contextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver
+  });
+}

package/lib/executeWithSchema.mjs

@@ -0,0 +1,62 @@
+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;
+};
+import {makeExecutableSchema} from "@graphql-tools/schema";
+import {isInputType} from "graphql";
+import {
+  addTypesToRequestDocument,
+  executeWithoutSchema,
+  extractImplicitTypes,
+  specifiedScalars
+} from ".";
+function executeWithSchema({
+  typeDefs,
+  resolvers: resolvers2,
+  document: rawDocument,
+  rootValue,
+  contextValue,
+  variableValues,
+  operationName,
+  fieldResolver,
+  typeResolver
+}) {
+  const schema = makeExecutableSchema({typeDefs, resolvers: resolvers2});
+  let extractedResolvers = {};
+  const getTypeByName = (name) => {
+    const type = specifiedScalars[name] || extractedResolvers[name];
+    if (isInputType(type)) {
+      return type;
+    } else {
+      throw new Error("Invalid type");
+    }
+  };
+  extractedResolvers = extractImplicitTypes(typeDefs, getTypeByName);
+  const fullResolvers = __objSpread(__objSpread({}, extractedResolvers), resolvers2);
+  const document = addTypesToRequestDocument(schema, rawDocument);
+  return executeWithoutSchema({
+    document,
+    resolvers: fullResolvers,
+    rootValue,
+    contextValue,
+    variableValues,
+    operationName,
+    fieldResolver,
+    typeResolver
+  });
+}
+export {
+  executeWithSchema
+};

package/lib/executeWithoutSchema.d.ts

@@ -0,0 +1,99 @@
+import { GraphQLError } from "graphql";
+import { DocumentNode, FieldNode, FragmentDefinitionNode, OperationDefinitionNode, TypeNode } from "./ast/TypedAST";
+import type { Maybe } from "./jsutils/Maybe";
+import type { ObjMap } from "./jsutils/ObjMap";
+import type { Path } from "./jsutils/Path";
+import type { PromiseOrValue } from "./jsutils/PromiseOrValue";
+import { ExecutionWithoutSchemaArgs, FieldResolver, ResolveInfo, Resolvers, TypeResolver, ExecutionResult } from "./types";
+/**
+ * Terminology
+ *
+ * "Definitions" are the generic name for top-level statements in the document.
+ * Examples of this include:
+ * 1) Operations (such as a query)
+ * 2) Fragments
+ *
+ * "Operations" are a generic name for requests in the document.
+ * Examples of this include:
+ * 1) query,
+ * 2) mutation
+ *
+ * "Selections" are the definitions that can appear legally and at
+ * single level of the query. These include:
+ * 1) field references e.g "a"
+ * 2) fragment "spreads" e.g. "...c"
+ * 3) inline fragment "spreads" e.g. "...on Type { a }"
+ */
+/**
+ * Data that must be available at all points during query execution.
+ *
+ * Namely, schema of the type system that is currently executing,
+ * and the fragments defined in the query document
+ */
+export interface ExecutionContext {
+    resolvers: Resolvers;
+    fragments: ObjMap<FragmentDefinitionNode>;
+    rootValue: unknown;
+    contextValue: unknown;
+    operation: OperationDefinitionNode;
+    variableValues: {
+        [variable: string]: unknown;
+    };
+    fieldResolver: FieldResolver<any, any>;
+    typeResolver: TypeResolver<any, any>;
+    errors: Array<GraphQLError>;
+}
+/**
+ * Implements the "Executing requests" section of the GraphQL specification.
+ *
+ * Returns either a synchronous ExecutionResult (if all encountered resolvers
+ * are synchronous), or a Promise of an ExecutionResult that will eventually be
+ * resolved and never rejected.
+ *
+ * If the arguments to this function do not result in a legal execution context,
+ * a GraphQLError will be thrown immediately explaining the invalid input.
+ */
+export declare function executeWithoutSchema(args: ExecutionWithoutSchemaArgs): PromiseOrValue<ExecutionResult>;
+/**
+ * Essential assertions before executing to provide developer feedback for
+ * improper use of the GraphQL library.
+ *
+ * @internal
+ */
+export declare function assertValidExecutionArguments(document: DocumentNode, rawVariableValues: Maybe<{
+    [variable: string]: unknown;
+}>): void;
+/**
+ * Constructs a ExecutionContext object from the arguments passed to
+ * execute, which we will pass throughout the other execution methods.
+ *
+ * Throws a GraphQLError if a valid execution context cannot be created.
+ *
+ * @internal
+ */
+export declare function buildExecutionContext(resolvers: Resolvers, document: DocumentNode, rootValue: unknown, contextValue: unknown, rawVariableValues: Maybe<{
+    [variable: string]: unknown;
+}>, operationName: Maybe<string>, fieldResolver: Maybe<FieldResolver<unknown, unknown>>, typeResolver?: Maybe<TypeResolver<unknown, unknown>>): Array<GraphQLError> | ExecutionContext;
+/**
+ * @internal
+ */
+export declare function buildResolveInfo(exeContext: ExecutionContext, fieldName: string, fieldNodes: Array<FieldNode>, parentTypeName: string, returnTypeName: string, returnTypeNode: TypeNode, path: Path): ResolveInfo;
+/**
+ * If a resolveType function is not given, then a default resolve behavior is
+ * used which attempts two strategies:
+ *
+ * First, See if the provided value has a `__typename` field defined, if so, use
+ * that value as name of the resolved type.
+ *
+ * Otherwise, test each possible type for the abstract type by calling
+ * isTypeOf for the object being coerced, returning the first type that matches.
+ */
+export declare const defaultTypeResolver: TypeResolver<unknown, unknown>;
+/**
+ * If a resolve function is not given, then a default resolve behavior is used
+ * which takes the property of the source object of the same name as the field
+ * and returns it as the result, or if it's a function, returns the result
+ * of calling that function while passing along args and context value.
+ */
+export declare const defaultFieldResolver: FieldResolver<unknown, unknown>;
+//# sourceMappingURL=executeWithoutSchema.d.ts.map

package/lib/executeWithoutSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executeWithoutSchema.d.ts","sourceRoot":"","sources":["../src/executeWithoutSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,YAAY,EASb,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,YAAY,EACZ,SAAS,EACT,sBAAsB,EACtB,uBAAuB,EAEvB,QAAQ,EACT,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EACL,0BAA0B,EAC1B,aAAa,EAGb,WAAW,EAEX,SAAS,EACT,YAAY,EAEZ,eAAe,EAChB,MAAM,SAAS,CAAC;AAQjB;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC,sBAAsB,CAAC,CAAC;IAC1C,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,uBAAuB,CAAC;IACnC,cAAc,EAAE;QAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAChD,aAAa,EAAE,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACvC,YAAY,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACrC,MAAM,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,0BAA0B,GAC/B,cAAc,CAAC,eAAe,CAAC,CA0CjC;AAoBD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,iBAAiB,EAAE,KAAK,CAAC;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,GACxD,IAAI,CAQN;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,YAAY,EACtB,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,OAAO,EACrB,iBAAiB,EAAE,KAAK,CAAC;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC,EACzD,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,EAC5B,aAAa,EAAE,KAAK,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EACrD,YAAY,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,GACnD,KAAK,CAAC,YAAY,CAAC,GAAG,gBAAgB,CAyDxC;AAgPD;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,KAAK,CAAC,SAAS,CAAC,EAC5B,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,QAAQ,EACxB,IAAI,EAAE,IAAI,GACT,WAAW,CAeb;AAoWD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAM9D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAchE,CAAC"}