@graphitation/supermassive 3.0.0-alpha.5 → 3.0.0-alpha.7

package/lib/executeWithoutSchema.js

@@ -1,10 +1,12 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 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;
@@ -32,6 +34,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
@@ -82,14 +92,15 @@ var import_isAsyncIterable = require("./jsutils/isAsyncIterable");
 var import_mapAsyncIterator = require("./utilities/mapAsyncIterator");
 var import_directives = require("./schema/directives");
 var import_memoize3 = require("./jsutils/memoize3");
-var import_fragment = require("./schema/fragment");
 var import_reference = require("./schema/reference");
+var Definitions = __toESM(require("./schema/definition"));
+var Resolvers = __toESM(require("./schema/resolvers"));
 const collectSubfields = (0, import_memoize3.memoize3)(
   (exeContext, returnTypeName, fieldGroup) => (0, import_collectFields.collectSubfields)(exeContext, returnTypeName.name, fieldGroup)
 );
 function executeWithoutSchema(args) {
   const exeContext = buildExecutionContext(args);
-  if (!("partialSchema" in exeContext)) {
+  if (!("schemaFragment" in exeContext)) {
     return { errors: exeContext };
   } else {
     return executeOperation(exeContext);
@@ -105,7 +116,6 @@ function assertValidExecutionArguments(document, rawVariableValues) {
 function buildExecutionContext(args) {
   var _a, _b;
   const {
-    // resolvers,
     schemaFragment,
     schemaFragmentLoader,
     document,
@@ -150,9 +160,8 @@ function buildExecutionContext(args) {
     return [new import_graphql.GraphQLError("Must provide an operation.")];
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
-  const partialSchema = new import_fragment.PartialSchema(schemaFragment);
   const coercedVariableValues = (0, import_values.getVariableValues)(
-    partialSchema,
+    schemaFragment,
     variableDefinitions,
     variableValues != null ? variableValues : {},
     { maxErrors: 50 }
@@ -161,7 +170,6 @@ function buildExecutionContext(args) {
     return coercedVariableValues.errors;
   }
   return {
-    partialSchema,
     schemaFragment,
     schemaFragmentLoader,
     fragments,
@@ -325,8 +333,13 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   return (0, import_promiseForObject.promiseForObject)(results);
 }
 function executeField(exeContext, parentTypeName, source, fieldGroup, path, incrementalDataRecord) {
+  const schemaFragment = exeContext.schemaFragment;
   const fieldName = fieldGroup[0].name.value;
-  const fieldDef = exeContext.partialSchema.getField(parentTypeName, fieldName);
+  const fieldDef = Definitions.getField(
+    schemaFragment.definitions,
+    parentTypeName,
+    fieldName
+  );
   if (fieldDef !== void 0) {
     return resolveAndCompleteField(
       exeContext,
@@ -338,30 +351,50 @@ function executeField(exeContext, parentTypeName, source, fieldGroup, path, incr
       incrementalDataRecord
     );
   }
-  if (!exeContext.schemaFragmentLoader) {
-    return void 0;
-  }
-  return exeContext.schemaFragmentLoader(exeContext.schemaFragment, exeContext.contextValue, {
-    kind: "byField",
+  const loading = requestSchemaFragment(exeContext, {
+    kind: "ReturnType",
     parentTypeName,
     fieldName
-  }).then(({ mergedFragment, mergedContextValue }) => {
-    exeContext.contextValue = mergedContextValue != null ? mergedContextValue : exeContext.contextValue;
-    exeContext.schemaFragment = mergedFragment;
-    exeContext.partialSchema.updateSchemaFragment(mergedFragment);
-    const fieldDef2 = exeContext.partialSchema.getField(
+  });
+  if (!loading) {
+    return void 0;
+  }
+  return loading.then(() => {
+    const fieldDef2 = Definitions.getField(
+      exeContext.schemaFragment.definitions,
       parentTypeName,
       fieldName
     );
-    return fieldDef2 !== void 0 ? resolveAndCompleteField(
-      exeContext,
-      parentTypeName,
-      fieldDef2,
-      fieldGroup,
-      path,
-      source,
-      incrementalDataRecord
-    ) : void 0;
+    if (fieldDef2 !== void 0) {
+      return resolveAndCompleteField(
+        exeContext,
+        parentTypeName,
+        fieldDef2,
+        fieldGroup,
+        path,
+        source,
+        incrementalDataRecord
+      );
+    }
+    return void 0;
+  });
+}
+function requestSchemaFragment(exeContext, request) {
+  if (!exeContext.schemaFragmentLoader) {
+    return;
+  }
+  return exeContext.schemaFragmentLoader(
+    exeContext.schemaFragment,
+    exeContext.contextValue,
+    request
+  ).then(({ mergedFragment, mergedContextValue }) => {
+    if (exeContext.schemaFragment.schemaId !== mergedFragment.schemaId) {
+      throw new Error(
+        `Cannot use new schema fragment: old and new fragments describe different schemas: ${exeContext.schemaFragment.schemaId} vs. ${mergedFragment.schemaId}`
+      );
+    }
+    exeContext.contextValue = mergedContextValue != null ? mergedContextValue : exeContext.contextValue;
+    exeContext.schemaFragment = mergedFragment;
   });
 }
 function createSourceEventStream(exeContext) {
@@ -377,21 +410,29 @@ function createSourceEventStream(exeContext) {
 }
 function executeSubscriptionImpl(exeContext) {
   var _a;
-  const { operation, rootValue, partialSchema } = exeContext;
+  const { operation, rootValue, schemaFragment } = exeContext;
   const rootTypeName = getOperationRootTypeName(operation);
   const { groupedFieldSet } = (0, import_collectFields.collectFields)(exeContext, rootTypeName);
   const firstRootField = groupedFieldSet.entries().next().value;
   const [responseName, fieldGroup] = firstRootField;
   const fieldName = fieldGroup[0].name.value;
-  const fieldDef = partialSchema.getField(rootTypeName, fieldName);
+  const fieldDef = Definitions.getField(
+    schemaFragment.definitions,
+    rootTypeName,
+    fieldName
+  );
   if (!fieldDef) {
     throw new import_graphql.GraphQLError(
       `The subscription field "${fieldName}" is not defined.`,
       { nodes: fieldGroup }
     );
   }
-  const returnTypeRef = partialSchema.getTypeReference(fieldDef);
-  const resolveFn = (_a = partialSchema.getSubscriptionFieldResolver(rootTypeName, fieldName)) != null ? _a : exeContext.subscribeFieldResolver;
+  const returnTypeRef = Definitions.getFieldTypeReference(fieldDef);
+  const resolveFn = (_a = Resolvers.getSubscriptionFieldResolver(
+    schemaFragment,
+    rootTypeName,
+    fieldName
+  )) != null ? _a : exeContext.subscribeFieldResolver;
   const path = (0, import_Path.addPath)(void 0, responseName, rootTypeName);
   const info = buildResolveInfo(
     exeContext,
@@ -485,8 +526,12 @@ function handleFieldError(rawError, exeContext, returnTypeRef, fieldGroup, path,
 function resolveAndCompleteField(exeContext, parentTypeName, fieldDefinition, fieldGroup, path, source, incrementalDataRecord) {
   var _a;
   const fieldName = fieldGroup[0].name.value;
-  const returnTypeRef = exeContext.partialSchema.getTypeReference(fieldDefinition);
-  const resolveFn = (_a = exeContext.partialSchema.getFieldResolver(parentTypeName, fieldName)) != null ? _a : exeContext.fieldResolver;
+  const returnTypeRef = Definitions.getFieldTypeReference(fieldDefinition);
+  const resolveFn = (_a = Resolvers.getFieldResolver(
+    exeContext.schemaFragment,
+    parentTypeName,
+    fieldName
+  )) != null ? _a : exeContext.fieldResolver;
   const info = buildResolveInfo(
     exeContext,
     fieldName,
@@ -626,13 +671,13 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       incrementalDataRecord
     );
   }
-  const partialSchema = exeContext.partialSchema;
+  const { schemaFragment } = exeContext;
   const returnTypeName = (0, import_reference.typeNameFromReference)(returnTypeRef);
-  const leafType = partialSchema.getLeafTypeResolver(returnTypeRef);
+  const leafType = Resolvers.getLeafTypeResolver(schemaFragment, returnTypeRef);
   if (leafType) {
     return completeLeafValue(leafType, result);
   }
-  if (partialSchema.isAbstractType(returnTypeRef)) {
+  if (Definitions.isAbstractType(schemaFragment.definitions, returnTypeRef)) {
     return completeAbstractValue(
       exeContext,
       returnTypeName,
@@ -643,7 +688,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       incrementalDataRecord
     );
   }
-  if (partialSchema.isObjectType(returnTypeRef)) {
+  if (Definitions.isObjectType(schemaFragment.definitions, returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
@@ -894,21 +939,32 @@ function completeLeafValue(returnType, result) {
 }
 function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, path, result, incrementalDataRecord) {
   var _a;
-  const resolveTypeFn = (_a = exeContext.partialSchema.getAbstractTypeResolver(returnTypeName)) != null ? _a : exeContext.typeResolver;
+  const { schemaFragment } = exeContext;
+  const resolveTypeFn = (_a = Resolvers.getAbstractTypeResolver(schemaFragment, returnTypeName)) != null ? _a : exeContext.typeResolver;
   const contextValue = exeContext.contextValue;
   const runtimeTypeName = resolveTypeFn(result, contextValue, info);
-  if ((0, import_isPromise.isPromise)(runtimeTypeName)) {
-    return runtimeTypeName.then(
+  const validatedRuntimeTypeName = (0, import_isPromise.isPromise)(runtimeTypeName) ? runtimeTypeName.then(
+    (resolvedRuntimeTypeName) => ensureValidRuntimeType(
+      resolvedRuntimeTypeName,
+      exeContext,
+      returnTypeName,
+      fieldGroup,
+      info,
+      result
+    )
+  ) : ensureValidRuntimeType(
+    runtimeTypeName,
+    exeContext,
+    returnTypeName,
+    fieldGroup,
+    info,
+    result
+  );
+  if ((0, import_isPromise.isPromise)(validatedRuntimeTypeName)) {
+    return validatedRuntimeTypeName.then(
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
-        ensureValidRuntimeType(
-          resolvedRuntimeTypeName,
-          exeContext,
-          returnTypeName,
-          fieldGroup,
-          info,
-          result
-        ),
+        resolvedRuntimeTypeName,
         fieldGroup,
         path,
         result,
@@ -918,14 +974,7 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
   }
   return completeObjectValue(
     exeContext,
-    ensureValidRuntimeType(
-      runtimeTypeName,
-      exeContext,
-      returnTypeName,
-      fieldGroup,
-      info,
-      result
-    ),
+    validatedRuntimeTypeName,
     fieldGroup,
     path,
     result,
@@ -944,37 +993,72 @@ function ensureValidRuntimeType(runtimeTypeName, exeContext, returnTypeName, fie
       `Abstract type "${returnTypeName}" must resolve to an Object type at runtime for field "${info.returnTypeName}.${info.fieldName}" with value ${(0, import_inspect.inspect)(result)}, received "${(0, import_inspect.inspect)(runtimeTypeName)}".`
     );
   }
-  const partialSchema = exeContext.partialSchema;
-  const iface = partialSchema.getInterfaceType(returnTypeName);
-  if (iface) {
-    if (partialSchema.isDefined(runtimeTypeName) && !partialSchema.isObjectType(runtimeTypeName)) {
+  const strictInterfaceValidation = !!exeContext.schemaFragmentLoader;
+  const isDefinedType = Definitions.isDefined(
+    exeContext.schemaFragment.definitions,
+    runtimeTypeName
+  );
+  const loading = !isDefinedType ? requestSchemaFragment(exeContext, {
+    kind: "RuntimeType",
+    abstractTypeName: returnTypeName,
+    runtimeTypeName
+  }) : void 0;
+  return loading ? loading.then(
+    () => ensureValidRuntimeTypeImpl(
+      runtimeTypeName,
+      exeContext,
+      returnTypeName,
+      fieldGroup,
+      strictInterfaceValidation
+    )
+  ) : ensureValidRuntimeTypeImpl(
+    runtimeTypeName,
+    exeContext,
+    returnTypeName,
+    fieldGroup,
+    strictInterfaceValidation
+  );
+}
+function ensureValidRuntimeTypeImpl(runtimeTypeName, exeContext, returnTypeName, fieldGroup, strictInterfaceValidation) {
+  const definitions = exeContext.schemaFragment.definitions;
+  const union = Definitions.getUnionType(definitions, returnTypeName);
+  if (union || strictInterfaceValidation) {
+    if (!Definitions.isDefined(definitions, runtimeTypeName)) {
       throw new import_graphql.GraphQLError(
-        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
         { nodes: fieldGroup }
       );
     }
-    partialSchema.addInterfaceImplementation(returnTypeName, runtimeTypeName);
-  } else {
-    if (!partialSchema.isDefined(runtimeTypeName)) {
+    if (!Definitions.isObjectType(definitions, runtimeTypeName)) {
       throw new import_graphql.GraphQLError(
-        `Abstract type "${returnTypeName}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
         { nodes: fieldGroup }
       );
     }
-    if (!partialSchema.isObjectType(runtimeTypeName)) {
+    if (!Definitions.isSubType(definitions, returnTypeName, runtimeTypeName)) {
       throw new import_graphql.GraphQLError(
-        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
+        `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
         { nodes: fieldGroup }
       );
     }
-    if (!exeContext.partialSchema.isSubType(returnTypeName, runtimeTypeName)) {
+    return runtimeTypeName;
+  }
+  const iface = Definitions.getInterfaceType(definitions, returnTypeName);
+  if (iface) {
+    if (Definitions.isDefined(definitions, runtimeTypeName) && !Definitions.isObjectType(definitions, runtimeTypeName)) {
       throw new import_graphql.GraphQLError(
-        `Runtime Object type "${runtimeTypeName}" is not a possible type for "${returnTypeName}".`,
+        `Abstract type "${returnTypeName}" was resolved to a non-object type "${runtimeTypeName}".`,
         { nodes: fieldGroup }
       );
     }
+    Definitions.addInterfaceImplementation(
+      definitions,
+      returnTypeName,
+      runtimeTypeName
+    );
+    return runtimeTypeName;
   }
-  return runtimeTypeName;
+  (0, import_invariant.invariant)(false, `${returnTypeName} is not an abstract type`);
 }
 function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
   return collectAndExecuteSubfields(