@graphitation/supermassive 3.0.0-alpha.6 → 3.0.0-alpha.8

package/lib/executeWithoutSchema.mjs

@@ -67,9 +67,6 @@ import { isAsyncIterable } from "./jsutils/isAsyncIterable.mjs";
 import { mapAsyncIterator } from "./utilities/mapAsyncIterator.mjs";
 import { GraphQLStreamDirective } from "./schema/directives.mjs";
 import { memoize3 } from "./jsutils/memoize3.mjs";
-import {
-  PartialSchema
-} from "./schema/fragment.mjs";
 import {
   inspectTypeReference,
   isListType,
@@ -77,12 +74,14 @@ import {
   typeNameFromReference,
   unwrap
 } from "./schema/reference.mjs";
+import * as Definitions from "./schema/definition.mjs";
+import * as Resolvers from "./schema/resolvers.mjs";
 var collectSubfields = memoize3(
   (exeContext, returnTypeName, fieldGroup) => _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);
@@ -98,7 +97,6 @@ function assertValidExecutionArguments(document, rawVariableValues) {
 function buildExecutionContext(args) {
   var _a, _b;
   const {
-    // resolvers,
     schemaFragment,
     schemaFragmentLoader,
     document,
@@ -143,9 +141,8 @@ function buildExecutionContext(args) {
     return [new GraphQLError("Must provide an operation.")];
   }
   const variableDefinitions = (_b = operation.variableDefinitions) != null ? _b : [];
-  const partialSchema = new PartialSchema(schemaFragment);
   const coercedVariableValues = getVariableValues(
-    partialSchema,
+    schemaFragment,
     variableDefinitions,
     variableValues != null ? variableValues : {},
     { maxErrors: 50 }
@@ -154,7 +151,6 @@ function buildExecutionContext(args) {
     return coercedVariableValues.errors;
   }
   return {
-    partialSchema,
     schemaFragment,
     schemaFragmentLoader,
     fragments,
@@ -318,8 +314,13 @@ function executeFields(exeContext, parentTypeName, sourceValue, path, groupedFie
   return 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,
@@ -331,30 +332,51 @@ 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;
+  }
+  const currentSchemaId = exeContext.schemaFragment.schemaId;
+  return exeContext.schemaFragmentLoader(
+    exeContext.schemaFragment,
+    exeContext.contextValue,
+    request
+  ).then(({ mergedFragment, mergedContextValue }) => {
+    if (currentSchemaId !== mergedFragment.schemaId) {
+      throw new Error(
+        `Cannot use new schema fragment: old and new fragments describe different schemas: ${currentSchemaId} vs. ${mergedFragment.schemaId}`
+      );
+    }
+    exeContext.contextValue = mergedContextValue != null ? mergedContextValue : exeContext.contextValue;
+    exeContext.schemaFragment = mergedFragment;
   });
 }
 function createSourceEventStream(exeContext) {
@@ -370,21 +392,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 } = 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 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 = addPath(void 0, responseName, rootTypeName);
   const info = buildResolveInfo(
     exeContext,
@@ -478,8 +508,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,
@@ -619,13 +653,13 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       incrementalDataRecord
     );
   }
-  const partialSchema = exeContext.partialSchema;
+  const { schemaFragment } = exeContext;
   const returnTypeName = 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,
@@ -636,7 +670,7 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
       incrementalDataRecord
     );
   }
-  if (partialSchema.isObjectType(returnTypeRef)) {
+  if (Definitions.isObjectType(schemaFragment.definitions, returnTypeRef)) {
     return completeObjectValue(
       exeContext,
       returnTypeName,
@@ -887,21 +921,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 (isPromise(runtimeTypeName)) {
-    return runtimeTypeName.then(
+  const validatedRuntimeTypeName = isPromise(runtimeTypeName) ? runtimeTypeName.then(
+    (resolvedRuntimeTypeName) => ensureValidRuntimeType(
+      resolvedRuntimeTypeName,
+      exeContext,
+      returnTypeName,
+      fieldGroup,
+      info,
+      result
+    )
+  ) : ensureValidRuntimeType(
+    runtimeTypeName,
+    exeContext,
+    returnTypeName,
+    fieldGroup,
+    info,
+    result
+  );
+  if (isPromise(validatedRuntimeTypeName)) {
+    return validatedRuntimeTypeName.then(
       (resolvedRuntimeTypeName) => completeObjectValue(
         exeContext,
-        ensureValidRuntimeType(
-          resolvedRuntimeTypeName,
-          exeContext,
-          returnTypeName,
-          fieldGroup,
-          info,
-          result
-        ),
+        resolvedRuntimeTypeName,
         fieldGroup,
         path,
         result,
@@ -911,14 +956,7 @@ function completeAbstractValue(exeContext, returnTypeName, fieldGroup, info, pat
   }
   return completeObjectValue(
     exeContext,
-    ensureValidRuntimeType(
-      runtimeTypeName,
-      exeContext,
-      returnTypeName,
-      fieldGroup,
-      info,
-      result
-    ),
+    validatedRuntimeTypeName,
     fieldGroup,
     path,
     result,
@@ -937,37 +975,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 ${inspect(result)}, received "${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 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 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 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 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;
+  invariant(false, `${returnTypeName} is not an abstract type`);
 }
 function completeObjectValue(exeContext, returnTypeName, fieldGroup, path, result, incrementalDataRecord) {
   return collectAndExecuteSubfields(