feat(utils): new helpers for promises

Author: ardatan

.changeset/lazy-otters-buy.md

@@ -0,0 +1,5 @@
+---
+'@graphql-tools/utils': minor
+---
+
+new `fakePromise`, `mapMaybePromise` and `fakeRejectPromise` helper functions

packages/executor/src/execution/execute.ts

@@ -35,6 +35,7 @@ import {
   addPath,
   collectFields,
   createGraphQLError,
+  fakePromise,
   getArgumentValues,
   getDefinedRootType,
   GraphQLStreamDirective,
@@ -1575,16 +1576,13 @@ export function flattenIncrementalResults<TData>(
     },
     next() {
       if (done) {
-        return Promise.resolve({
-          value: undefined,
-          done,
-        });
+        return fakePromise({ value: undefined, done });
       }
       if (initialResultSent) {
         return subsequentIterator.next();
       }
       initialResultSent = true;
-      return Promise.resolve({
+      return fakePromise({
         value: incrementalResults.initialResult,
         done,
       });

packages/executors/envelop/src/index.ts

@@ -1,4 +1,4 @@
-import { ExecutionArgs, Plugin } from '@envelop/core';
+import { ExecutionArgs, mapMaybePromise, Plugin } from '@envelop/core';
 import { Executor, isPromise, MaybePromise } from '@graphql-tools/utils';
 import { schemaFromExecutor } from '@graphql-tools/wrap';
 
@@ -97,25 +97,21 @@ export function useExecutor<TPluginContext extends Record<string, any>>(
         pluginCtx.schema$ = pluginCtx.schema;
       }
       ensureSchema(args.contextValue);
-      if (isPromise(pluginCtx.schemaSetPromise$)) {
-        return pluginCtx.schemaSetPromise$.then(() => {
-          setExecuteFn(executorToExecuteFn);
-        }) as Promise<void>;
-      }
-      setExecuteFn(executorToExecuteFn);
+      // @ts-expect-error - Typings are wrong
+      return mapMaybePromise(pluginCtx.schemaSetPromise$, () => {
+        setExecuteFn(executorToExecuteFn);
+      });
     },
     onSubscribe({ args, setSubscribeFn }) {
       if (args.schema) {
         pluginCtx.schema = args.schema;
         pluginCtx.schema$ = pluginCtx.schema;
       }
       ensureSchema(args.contextValue);
-      if (isPromise(pluginCtx.schemaSetPromise$)) {
-        return pluginCtx.schemaSetPromise$.then(() => {
-          setSubscribeFn(executorToExecuteFn);
-        }) as Promise<void>;
-      }
-      setSubscribeFn(executorToExecuteFn);
+      // @ts-expect-error - Typings are wrong
+      return mapMaybePromise(pluginCtx.schemaSetPromise$, () => {
+        setSubscribeFn(executorToExecuteFn);
+      });
     },
     onValidate({ params, context, setResult }) {
       if (params.schema) {

packages/links/src/AwaitVariablesLink.ts

@@ -1,9 +1,10 @@
 import * as apolloImport from '@apollo/client';
+import { mapMaybePromise } from '@graphql-tools/utils';
 
 const apollo: typeof apolloImport = (apolloImport as any)?.default ?? apolloImport;
 
 function getFinalPromise(object: any): Promise<any> {
-  return Promise.resolve(object).then(resolvedObject => {
+  return mapMaybePromise(object, resolvedObject => {
     if (resolvedObject == null) {
       return resolvedObject;
     }

packages/utils/src/createDeferred.ts

@@ -0,0 +1,18 @@
+export interface PromiseWithResolvers<T> {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason: any) => void;
+}
+
+export function createDeferred<T>(): PromiseWithResolvers<T> {
+  if (Promise.withResolvers) {
+    return Promise.withResolvers<T>();
+  }
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason: any) => void;
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return { promise, resolve, reject };
+}

packages/utils/src/fakePromise.ts

@@ -0,0 +1,61 @@
+function isPromise<T>(val: T | Promise<T>): val is Promise<T> {
+  return (val as any)?.then != null;
+}
+
+export function fakeRejectPromise(error: unknown): Promise<never> {
+  if (isPromise(error)) {
+    return error as Promise<never>;
+  }
+  return {
+    then() {
+      return this;
+    },
+    catch(reject: (error: unknown) => any) {
+      if (reject) {
+        return fakePromise(reject(error));
+      }
+      return this;
+    },
+    finally(cb) {
+      if (cb) {
+        cb();
+      }
+      return this;
+    },
+    [Symbol.toStringTag]: 'Promise',
+  };
+}
+
+export function fakePromise<T>(value: T): Promise<T> {
+  if (isPromise(value)) {
+    return value;
+  }
+  // Write a fake promise to avoid the promise constructor
+  // being called with `new Promise` in the browser.
+  return {
+    then(resolve: (value: T) => any) {
+      if (resolve) {
+        const callbackResult = resolve(value);
+        if (isPromise(callbackResult)) {
+          return callbackResult;
+        }
+        return fakePromise(callbackResult);
+      }
+      return this;
+    },
+    catch() {
+      return this;
+    },
+    finally(cb) {
+      if (cb) {
+        const callbackResult = cb();
+        if (isPromise(callbackResult)) {
+          return callbackResult.then(() => value);
+        }
+        return fakePromise(value);
+      }
+      return this;
+    },
+    [Symbol.toStringTag]: 'Promise',
+  };
+}

packages/utils/src/index.ts

@@ -55,3 +55,6 @@ export * from './directives.js';
 export * from './mergeIncrementalResult.js';
 export * from './debugTimer.js';
 export * from './getDirectiveExtensions.js';
+export * from './map-maybe-promise.js';
+export * from './fakePromise.js';
+export * from './createDeferred.js';

packages/utils/src/jsutils.ts

@@ -1,4 +1,5 @@
 import { MaybePromise } from './executor.js';
+import { mapMaybePromise } from './map-maybe-promise.js';
 
 export function isIterableObject(value: unknown): value is Iterable<unknown> {
   return value != null && typeof value === 'object' && Symbol.iterator in value;
@@ -20,9 +21,7 @@ export function promiseReduce<T, U>(
   let accumulator = initialValue;
 
   for (const value of values) {
-    accumulator = isPromise(accumulator)
-      ? accumulator.then(resolved => callbackFn(resolved, value))
-      : callbackFn(accumulator, value);
+    accumulator = mapMaybePromise(accumulator, resolved => callbackFn(resolved, value));
   }
 
   return accumulator;

packages/utils/src/map-maybe-promise.ts

@@ -0,0 +1,27 @@
+import { isPromise } from '../src/jsutils.js';
+import { MaybePromise } from './executor.js';
+
+export function mapMaybePromise<T, R>(
+  value: MaybePromise<T>,
+  mapper: (v: T) => MaybePromise<R>,
+  errorMapper?: (e: any) => MaybePromise<R>,
+): MaybePromise<R> {
+  if (isPromise(value)) {
+    if (errorMapper) {
+      try {
+        return value.then(mapper, errorMapper);
+      } catch (e) {
+        return errorMapper(e);
+      }
+    }
+    return value.then(mapper);
+  }
+  if (errorMapper) {
+    try {
+      return mapper(value);
+    } catch (e) {
+      return errorMapper(e);
+    }
+  }
+  return mapper(value);
+}

packages/utils/src/mapAsyncIterator.ts

@@ -1,5 +1,6 @@
 import type { MaybePromise } from './executor.js';
-import { isPromise } from './jsutils.js';
+import { fakePromise, fakeRejectPromise } from './fakePromise.js';
+import { mapMaybePromise } from './map-maybe-promise.js';
 
 /**
  * Given an AsyncIterable and a callback function, return an AsyncIterator
@@ -21,18 +22,17 @@ export function mapAsyncIterator<T, U>(
   if (onEnd) {
     let onEndWithValueResult: any /** R in onEndWithValue */;
     onEndWithValue = value => {
-      if (onEndWithValueResult) {
-        return onEndWithValueResult;
-      }
-      const onEnd$ = onEnd();
-      return (onEndWithValueResult = isPromise(onEnd$) ? onEnd$.then(() => value) : value);
+      onEndWithValueResult ||= mapMaybePromise(onEnd(), () => value);
+      return onEndWithValueResult;
     };
   }
 
   if (typeof iterator.return === 'function') {
     $return = iterator.return;
     abruptClose = (error: any) => {
-      const rethrow = () => Promise.reject(error);
+      const rethrow = () => {
+        throw error;
+      };
       return $return.call(iterator).then(rethrow, rethrow);
     };
   }
@@ -41,7 +41,9 @@ export function mapAsyncIterator<T, U>(
     if (result.done) {
       return onEndWithValue ? onEndWithValue(result) : result;
     }
-    return asyncMapValue(result.value, onNext).then(iteratorResult, abruptClose);
+    return mapMaybePromise(result.value, value =>
+      mapMaybePromise(onNext(value), iteratorResult, abruptClose),
+    );
   }
 
   let mapReject: any;
@@ -50,10 +52,10 @@ export function mapAsyncIterator<T, U>(
     // Capture rejectCallback to ensure it cannot be null.
     const reject = onError;
     mapReject = (error: any) => {
-      if (onErrorResult) {
-        return onErrorResult;
-      }
-      return (onErrorResult = asyncMapValue(error, reject).then(iteratorResult, abruptClose));
+      onErrorResult ||= mapMaybePromise(error, error =>
+        mapMaybePromise(reject(error), iteratorResult, abruptClose),
+      );
+      return onErrorResult;
     };
   }
 
@@ -64,25 +66,24 @@ export function mapAsyncIterator<T, U>(
     return() {
       const res$ = $return
         ? $return.call(iterator).then(mapResult, mapReject)
-        : Promise.resolve({ value: undefined, done: true });
+        : fakePromise({ value: undefined, done: true });
       return onEndWithValue ? res$.then(onEndWithValue) : res$;
     },
     throw(error: any) {
       if (typeof iterator.throw === 'function') {
         return iterator.throw(error).then(mapResult, mapReject);
       }
-      return Promise.reject(error).catch(abruptClose);
+      if (abruptClose) {
+        return abruptClose(error);
+      }
+      return fakeRejectPromise(error);
     },
     [Symbol.asyncIterator]() {
       return this;
     },
   };
 }
 
-function asyncMapValue<T, U>(value: T, callback: (value: T) => PromiseLike<U> | U): Promise<U> {
-  return new Promise(resolve => resolve(callback(value)));
-}
-
 function iteratorResult<T>(value: T): IteratorResult<T> {
   return { value, done: false };
 }