introduce new afterMaybeAsync helper

`after` becomes sync, requiring no return type check for the onFulfilled result.

src/execution/execute.ts

@@ -1,4 +1,5 @@
 import { after } from '../jsutils/after.js';
+import { afterMaybeAsync } from '../jsutils/afterMaybeAsync.js';
 import { catchAfter } from '../jsutils/catchAfter.js';
 import { inspect } from '../jsutils/inspect.js';
 import { invariant } from '../jsutils/invariant.js';
@@ -1282,7 +1283,7 @@ function completeAbstractValue(
   const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
 
   if (isPromise(runtimeType)) {
-    return after(runtimeType, (resolvedRuntimeType) =>
+    return afterMaybeAsync(runtimeType, (resolvedRuntimeType) =>
       completeObjectValue(
         exeContext,
         ensureValidRuntimeType(
@@ -1394,7 +1395,7 @@ function completeObjectValue(
     const isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info);
 
     if (isPromise(isTypeOf)) {
-      return after(isTypeOf, (resolvedIsTypeOf) => {
+      return afterMaybeAsync(isTypeOf, (resolvedIsTypeOf) => {
         if (!resolvedIsTypeOf) {
           throw invalidReturnTypeError(returnType, result, fieldNodes);
         }
@@ -2314,7 +2315,7 @@ class DeferredFragmentRecord {
   addData(data: PromiseOrValue<ObjMap<unknown> | null>) {
     const parentData = this.parentContext?.promise;
     if (parentData) {
-      this._resolve?.(after(parentData, () => data));
+      this._resolve?.(afterMaybeAsync(parentData, () => data));
       return;
     }
     this._resolve?.(data);
@@ -2368,7 +2369,7 @@ class StreamRecord {
   addItems(items: PromiseOrValue<Array<unknown> | null>) {
     const parentData = this.parentContext?.promise;
     if (parentData) {
-      this._resolve?.(after(parentData, () => items));
+      this._resolve?.(afterMaybeAsync(parentData, () => items));
       return;
     }
     this._resolve?.(items);

src/jsutils/after.ts

@@ -1,6 +1,3 @@
-import { isPromise } from './isPromise.js';
-import type { PromiseOrValue } from './PromiseOrValue.js';
-
 /**
  * Async Helper Function that avoides `.then()`
  *
@@ -11,11 +8,8 @@ import type { PromiseOrValue } from './PromiseOrValue.js';
  */
 export async function after<T, R>(
   promise: Promise<T>,
-  onFulfilled: (value: T) => PromiseOrValue<R>,
+  onFulfilled: (value: T) => R,
 ): Promise<R> {
   const result = onFulfilled(await promise);
-  if (isPromise(result)) {
-    return await result;
-  }
   return result;
 }

src/jsutils/afterMaybeAsync.ts

@@ -0,0 +1,21 @@
+import { isPromise } from './isPromise.js';
+import type { PromiseOrValue } from './PromiseOrValue.js';
+
+/**
+ * Async Helper Function that avoides `.then()`
+ *
+ * It is faster to await a promise prior to returning it from an async function
+ * than to return a promise with `.then()`.
+ *
+ * see: https://github.com/tc39/proposal-faster-promise-adoption
+ */
+export async function afterMaybeAsync<T, R>(
+  promise: Promise<T>,
+  onFulfilled: (value: T) => PromiseOrValue<R>,
+): Promise<R> {
+  const result = onFulfilled(await promise);
+  if (isPromise(result)) {
+    return await result;
+  }
+  return result;
+}

src/jsutils/promiseReduce.ts

@@ -1,4 +1,4 @@
-import { after } from './after.js';
+import { afterMaybeAsync } from './afterMaybeAsync.js';
 import { isPromise } from './isPromise.js';
 import type { PromiseOrValue } from './PromiseOrValue.js';
 
@@ -17,7 +17,7 @@ export function promiseReduce<T, U>(
   let accumulator = initialValue;
   for (const value of values) {
     accumulator = isPromise(accumulator)
-      ? after(accumulator, (resolved) => callbackFn(resolved, value))
+      ? afterMaybeAsync(accumulator, (resolved) => callbackFn(resolved, value))
       : callbackFn(accumulator, value);
   }
   return accumulator;