@graphitation/supermassive 3.9.0 → 3.10.0

package/lib/executeWithoutSchema.js

@@ -1,27 +1,10 @@
 "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;
-var __spreadValues = (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;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -43,26 +26,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 var executeWithoutSchema_exports = {};
 __export(executeWithoutSchema_exports, {
   assertValidExecutionArguments: () => assertValidExecutionArguments,
@@ -190,12 +153,13 @@ function buildExecutionContext(args) {
   };
 }
 function buildPerEventExecutionContext(exeContext, payload) {
-  return __spreadProps(__spreadValues({}, exeContext), {
+  return {
+    ...exeContext,
     contextValue: exeContext.buildContextValue ? exeContext.buildContextValue(exeContext.contextValue) : exeContext.contextValue,
     rootValue: payload,
     subsequentPayloads: /* @__PURE__ */ new Set(),
     errors: []
-  });
+  };
 }
 function executeOperationWithBeforeHook(exeContext) {
   const hooks = exeContext.fieldExecutionHooks;
@@ -298,9 +262,10 @@ function buildResponse(exeContext, data) {
     const initialResult = exeContext.errors.length === 0 ? { data } : { errors: exeContext.errors, data };
     if (exeContext.subsequentPayloads.size > 0) {
       return {
-        initialResult: __spreadProps(__spreadValues({}, initialResult), {
+        initialResult: {
+          ...initialResult,
           hasNext: true
-        }),
+        },
         subsequentResults: yieldSubsequentPayloads(exeContext)
       };
     } else {
@@ -915,36 +880,34 @@ function completeValue(exeContext, returnTypeRef, fieldGroup, info, path, result
     "Cannot complete value of unexpected output type: " + (0, import_reference.inspectTypeReference)(returnTypeRef)
   );
 }
-function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
-  return __async(this, null, function* () {
-    try {
-      const resolved = yield result;
-      let completed = completeValue(
-        exeContext,
-        returnTypeRef,
-        fieldGroup,
-        info,
-        path,
-        resolved,
-        incrementalDataRecord
-      );
-      if ((0, import_isPromise.isPromise)(completed)) {
-        completed = yield completed;
-      }
-      return completed;
-    } catch (rawError) {
-      handleFieldError(
-        rawError,
-        exeContext,
-        returnTypeRef,
-        fieldGroup,
-        path,
-        incrementalDataRecord
-      );
-      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-      return null;
+async function completePromisedValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
+  try {
+    const resolved = await result;
+    let completed = completeValue(
+      exeContext,
+      returnTypeRef,
+      fieldGroup,
+      info,
+      path,
+      resolved,
+      incrementalDataRecord
+    );
+    if ((0, import_isPromise.isPromise)(completed)) {
+      completed = await completed;
     }
-  });
+    return completed;
+  } catch (rawError) {
+    handleFieldError(
+      rawError,
+      exeContext,
+      returnTypeRef,
+      fieldGroup,
+      path,
+      incrementalDataRecord
+    );
+    filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+    return null;
+  }
 }
 function completeListValue(exeContext, returnTypeRef, fieldGroup, info, path, result, incrementalDataRecord) {
   const itemTypeRef = (0, import_reference.unwrap)(returnTypeRef);
@@ -1093,53 +1056,51 @@ function getStreamValues(exeContext, fieldGroup, path) {
     label: typeof stream.label === "string" ? stream.label : void 0
   };
 }
-function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
-  return __async(this, null, function* () {
-    const stream = getStreamValues(exeContext, fieldGroup, path);
-    let containsPromise = false;
-    const completedResults = [];
-    let index = 0;
-    while (true) {
-      if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
-        executeStreamAsyncIterator(
-          index,
-          asyncIterator,
-          exeContext,
-          fieldGroup,
-          info,
-          itemTypeRef,
-          path,
-          stream.label,
-          incrementalDataRecord
-        );
-        break;
-      }
-      const itemPath = (0, import_Path.addPath)(path, index, void 0);
-      let iteration;
-      try {
-        iteration = yield asyncIterator.next();
-        if (iteration.done) {
-          break;
-        }
-      } catch (rawError) {
-        throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
-      }
-      if (completeListItemValue(
-        iteration.value,
-        completedResults,
+async function completeAsyncIteratorValue(exeContext, itemTypeRef, fieldGroup, info, path, asyncIterator, incrementalDataRecord) {
+  const stream = getStreamValues(exeContext, fieldGroup, path);
+  let containsPromise = false;
+  const completedResults = [];
+  let index = 0;
+  while (true) {
+    if (stream && typeof stream.initialCount === "number" && index >= stream.initialCount) {
+      executeStreamAsyncIterator(
+        index,
+        asyncIterator,
         exeContext,
-        itemTypeRef,
         fieldGroup,
         info,
-        itemPath,
+        itemTypeRef,
+        path,
+        stream.label,
         incrementalDataRecord
-      )) {
-        containsPromise = true;
+      );
+      break;
+    }
+    const itemPath = (0, import_Path.addPath)(path, index, void 0);
+    let iteration;
+    try {
+      iteration = await asyncIterator.next();
+      if (iteration.done) {
+        break;
       }
-      index += 1;
+    } catch (rawError) {
+      throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
     }
-    return containsPromise ? Promise.all(completedResults) : completedResults;
-  });
+    if (completeListItemValue(
+      iteration.value,
+      completedResults,
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      itemPath,
+      incrementalDataRecord
+    )) {
+      containsPromise = true;
+    }
+    index += 1;
+  }
+  return containsPromise ? Promise.all(completedResults) : completedResults;
 }
 function completeLeafValue(returnType, result) {
   const serializedResult = returnType.serialize(result);
@@ -1749,116 +1710,112 @@ function executeStreamField(path, itemPath, item, exeContext, fieldGroup, info,
   incrementalDataRecord.addItems([completedItem]);
   return incrementalDataRecord;
 }
-function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
-  return __async(this, null, function* () {
-    let item;
-    try {
-      const { value, done } = yield asyncIterator.next();
-      if (done) {
-        incrementalDataRecord.setIsCompletedAsyncIterator();
-        return { done, value: void 0 };
-      }
-      item = value;
-    } catch (rawError) {
-      throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+async function executeStreamAsyncIteratorItem(asyncIterator, exeContext, fieldGroup, info, itemTypeRef, incrementalDataRecord, path, itemPath) {
+  let item;
+  try {
+    const { value, done } = await asyncIterator.next();
+    if (done) {
+      incrementalDataRecord.setIsCompletedAsyncIterator();
+      return { done, value: void 0 };
     }
-    let completedItem;
+    item = value;
+  } catch (rawError) {
+    throw (0, import_graphql.locatedError)(rawError, fieldGroup, (0, import_Path.pathToArray)(path));
+  }
+  let completedItem;
+  try {
+    completedItem = completeValue(
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      info,
+      itemPath,
+      item,
+      incrementalDataRecord
+    );
+    if ((0, import_isPromise.isPromise)(completedItem)) {
+      completedItem = completedItem.then(void 0, (rawError) => {
+        handleFieldError(
+          rawError,
+          exeContext,
+          itemTypeRef,
+          fieldGroup,
+          itemPath,
+          incrementalDataRecord
+        );
+        filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+        return null;
+      });
+    }
+    return { done: false, value: completedItem };
+  } catch (rawError) {
+    handleFieldError(
+      rawError,
+      exeContext,
+      itemTypeRef,
+      fieldGroup,
+      itemPath,
+      incrementalDataRecord
+    );
+    filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
+    return { done: false, value: null };
+  }
+}
+async function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
+  let index = initialIndex;
+  let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
+  while (true) {
+    const itemPath = (0, import_Path.addPath)(path, index, void 0);
+    const incrementalDataRecord = new StreamItemsRecord({
+      label,
+      path: itemPath,
+      parentContext: previousIncrementalDataRecord,
+      asyncIterator,
+      exeContext
+    });
+    let iteration;
     try {
-      completedItem = completeValue(
+      iteration = await executeStreamAsyncIteratorItem(
+        asyncIterator,
         exeContext,
-        itemTypeRef,
         fieldGroup,
         info,
-        itemPath,
-        item,
-        incrementalDataRecord
+        itemTypeRef,
+        incrementalDataRecord,
+        path,
+        itemPath
       );
-      if ((0, import_isPromise.isPromise)(completedItem)) {
-        completedItem = completedItem.then(void 0, (rawError) => {
-          handleFieldError(
-            rawError,
-            exeContext,
-            itemTypeRef,
-            fieldGroup,
-            itemPath,
-            incrementalDataRecord
-          );
-          filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
-          return null;
+    } catch (error) {
+      incrementalDataRecord.errors.push(error);
+      filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+      incrementalDataRecord.addItems(null);
+      if (asyncIterator == null ? void 0 : asyncIterator.return) {
+        asyncIterator.return().catch(() => {
         });
       }
-      return { done: false, value: completedItem };
-    } catch (rawError) {
-      handleFieldError(
-        rawError,
-        exeContext,
-        itemTypeRef,
-        fieldGroup,
-        itemPath,
-        incrementalDataRecord
-      );
-      filterSubsequentPayloads(exeContext, itemPath, incrementalDataRecord);
-      return { done: false, value: null };
+      return;
     }
-  });
-}
-function executeStreamAsyncIterator(initialIndex, asyncIterator, exeContext, fieldGroup, info, itemTypeRef, path, label, parentContext) {
-  return __async(this, null, function* () {
-    let index = initialIndex;
-    let previousIncrementalDataRecord = parentContext != null ? parentContext : void 0;
-    while (true) {
-      const itemPath = (0, import_Path.addPath)(path, index, void 0);
-      const incrementalDataRecord = new StreamItemsRecord({
-        label,
-        path: itemPath,
-        parentContext: previousIncrementalDataRecord,
-        asyncIterator,
-        exeContext
-      });
-      let iteration;
-      try {
-        iteration = yield executeStreamAsyncIteratorItem(
-          asyncIterator,
-          exeContext,
-          fieldGroup,
-          info,
-          itemTypeRef,
-          incrementalDataRecord,
-          path,
-          itemPath
-        );
-      } catch (error) {
-        incrementalDataRecord.errors.push(error);
-        filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-        incrementalDataRecord.addItems(null);
-        if (asyncIterator == null ? void 0 : asyncIterator.return) {
-          asyncIterator.return().catch(() => {
-          });
+    const { done, value: completedItem } = iteration;
+    let completedItems;
+    if ((0, import_isPromise.isPromise)(completedItem)) {
+      completedItems = completedItem.then(
+        (value) => [value],
+        (error) => {
+          incrementalDataRecord.errors.push(error);
+          filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
+          return null;
         }
-        return;
-      }
-      const { done, value: completedItem } = iteration;
-      let completedItems;
-      if ((0, import_isPromise.isPromise)(completedItem)) {
-        completedItems = completedItem.then(
-          (value) => [value],
-          (error) => {
-            incrementalDataRecord.errors.push(error);
-            filterSubsequentPayloads(exeContext, path, incrementalDataRecord);
-            return null;
-          }
-        );
-      } else {
-        completedItems = [completedItem];
-      }
-      incrementalDataRecord.addItems(completedItems);
-      if (done) {
-        break;
-      }
-      previousIncrementalDataRecord = incrementalDataRecord;
-      index++;
+      );
+    } else {
+      completedItems = [completedItem];
     }
-  });
+    incrementalDataRecord.addItems(completedItems);
+    if (done) {
+      break;
+    }
+    previousIncrementalDataRecord = incrementalDataRecord;
+    index++;
+  }
 }
 function filterSubsequentPayloads(exeContext, nullPath, currentIncrementalDataRecord) {
   const nullPathArray = (0, import_Path.pathToArray)(nullPath);
@@ -1910,36 +1867,34 @@ function getCompletedIncrementalResults(exeContext) {
 }
 function yieldSubsequentPayloads(exeContext) {
   let isDone = false;
-  function next() {
-    return __async(this, null, function* () {
-      if (isDone) {
-        return { value: void 0, done: true };
-      }
-      yield Promise.race(
-        Array.from(exeContext.subsequentPayloads).map((p) => p.promise)
-      );
-      if (isDone) {
-        return { value: void 0, done: true };
-      }
-      const incremental = getCompletedIncrementalResults(exeContext);
-      const hasNext = exeContext.subsequentPayloads.size > 0;
-      if (!incremental.length && hasNext) {
-        return next();
-      }
-      if (!hasNext) {
-        isDone = true;
-      }
-      return {
-        value: incremental.length ? { incremental, hasNext } : { hasNext },
-        done: false
-      };
-    });
+  async function next() {
+    if (isDone) {
+      return { value: void 0, done: true };
+    }
+    await Promise.race(
+      Array.from(exeContext.subsequentPayloads).map((p) => p.promise)
+    );
+    if (isDone) {
+      return { value: void 0, done: true };
+    }
+    const incremental = getCompletedIncrementalResults(exeContext);
+    const hasNext = exeContext.subsequentPayloads.size > 0;
+    if (!incremental.length && hasNext) {
+      return next();
+    }
+    if (!hasNext) {
+      isDone = true;
+    }
+    return {
+      value: incremental.length ? { incremental, hasNext } : { hasNext },
+      done: false
+    };
   }
   function returnStreamIterators() {
     const promises = [];
     exeContext.subsequentPayloads.forEach((incrementalDataRecord) => {
-      var _a2;
-      if (isStreamItemsRecord(incrementalDataRecord) && ((_a2 = incrementalDataRecord.asyncIterator) == null ? void 0 : _a2.return)) {
+      var _a;
+      if (isStreamItemsRecord(incrementalDataRecord) && ((_a = incrementalDataRecord.asyncIterator) == null ? void 0 : _a.return)) {
         promises.push(incrementalDataRecord.asyncIterator.return());
       }
     });
@@ -1950,19 +1905,15 @@ function yieldSubsequentPayloads(exeContext) {
       return this;
     },
     next,
-    return() {
-      return __async(this, null, function* () {
-        yield returnStreamIterators();
-        isDone = true;
-        return { value: void 0, done: true };
-      });
+    async return() {
+      await returnStreamIterators();
+      isDone = true;
+      return { value: void 0, done: true };
     },
-    throw(error) {
-      return __async(this, null, function* () {
-        yield returnStreamIterators();
-        isDone = true;
-        return Promise.reject(error);
-      });
+    async throw(error) {
+      await returnStreamIterators();
+      isDone = true;
+      return Promise.reject(error);
     }
   };
 }