Use Promise helpers (#2455)

* Use Promise helpers

* chore(dependencies): updated changesets for modified dependencies

* Lockfile

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: ardatan

.changeset/@envelop_core-2455-dependencies.md

@@ -0,0 +1,5 @@
+---
+"@envelop/core": patch
+---
+dependencies updates:
+  - Added dependency [`@whatwg-node/promise-helpers@^1.0.0` ↗︎](https://www.npmjs.com/package/@whatwg-node/promise-helpers/v/1.0.0) (to `dependencies`)

.changeset/@envelop_on-resolve-2455-dependencies.md

@@ -0,0 +1,5 @@
+---
+"@envelop/on-resolve": patch
+---
+dependencies updates:
+  - Added dependency [`@whatwg-node/promise-helpers@^1.0.0` ↗︎](https://www.npmjs.com/package/@whatwg-node/promise-helpers/v/1.0.0) (to `dependencies`)

.changeset/@envelop_rate-limiter-2455-dependencies.md

@@ -0,0 +1,5 @@
+---
+"@envelop/rate-limiter": patch
+---
+dependencies updates:
+  - Added dependency [`@whatwg-node/promise-helpers@^1.0.0` ↗︎](https://www.npmjs.com/package/@whatwg-node/promise-helpers/v/1.0.0) (to `dependencies`)

.changeset/@envelop_types-2455-dependencies.md

@@ -0,0 +1,5 @@
+---
+"@envelop/types": patch
+---
+dependencies updates:
+  - Added dependency [`@whatwg-node/promise-helpers@^1.0.0` ↗︎](https://www.npmjs.com/package/@whatwg-node/promise-helpers/v/1.0.0) (to `dependencies`)

packages/core/package.json

@@ -57,6 +57,7 @@
   ],
   "dependencies": {
     "@envelop/types": "workspace:^",
+    "@whatwg-node/promise-helpers": "^1.0.0",
     "tslib": "^2.5.0"
   },
   "devDependencies": {

packages/core/src/utils.ts

@@ -40,53 +40,7 @@ export const makeSubscribe = (subscribeFn: (args: ExecutionArgs) => any): Subscr
   ((...polyArgs: PolymorphicSubscribeArguments): PromiseOrValue<AsyncIterableIterator<any>> =>
     subscribeFn(getSubscribeArgs(polyArgs))) as SubscribeFunction;
 
-export function mapAsyncIterator<T, O>(
-  source: AsyncIterable<T>,
-  mapper: (input: T) => Promise<O> | O,
-): AsyncGenerator<O> {
-  const iterator = source[Symbol.asyncIterator]();
-
-  async function mapResult(result: IteratorResult<T, O>): Promise<IteratorResult<O>> {
-    if (result.done) {
-      return result;
-    }
-    try {
-      return { value: await mapper(result.value), done: false };
-    } catch (error) {
-      try {
-        await iterator.return?.();
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      } catch (_error) {
-        /* ignore error */
-      }
-      throw error;
-    }
-  }
-
-  const stream: AsyncGenerator<O> = {
-    [Symbol.asyncIterator]() {
-      return stream;
-    },
-    async next() {
-      return await mapResult(await iterator.next());
-    },
-    async return() {
-      const promise = iterator.return?.();
-      return promise ? await mapResult(await promise) : { value: undefined as any, done: true };
-    },
-    async throw(error: unknown) {
-      const promise = iterator.throw?.();
-      if (promise) {
-        return await mapResult(await promise);
-      }
-      // if the source has no throw method we just re-throw error
-      // usually throw is not called anyways
-      throw error;
-    },
-  };
-
-  return stream;
-}
+export { mapAsyncIterator } from '@whatwg-node/promise-helpers';
 
 function getExecuteArgs(args: PolymorphicExecuteArguments): ExecutionArgs {
   return args.length === 1
@@ -226,31 +180,4 @@ export function errorAsyncIterator<TInput>(
   return stream;
 }
 
-export function isPromise<T>(value: any): value is Promise<T> {
-  return value?.then !== undefined;
-}
-
-export function mapMaybePromise<T, R>(
-  value: PromiseOrValue<T>,
-  mapper: (v: T) => PromiseOrValue<R>,
-  errorMapper?: (e: any) => PromiseOrValue<R>,
-): PromiseOrValue<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);
-}
+export { mapMaybePromise, isPromise } from '@whatwg-node/promise-helpers';

packages/plugins/on-resolve/package.json

@@ -50,7 +50,9 @@
     "@envelop/core": "workspace:^",
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@whatwg-node/promise-helpers": "^1.0.0"
+  },
   "devDependencies": {
     "@envelop/core": "workspace:^",
     "@graphql-tools/schema": "10.0.19",

packages/plugins/on-resolve/src/index.ts

@@ -5,19 +5,20 @@ import {
   isIntrospectionType,
   isObjectType,
 } from 'graphql';
-import { mapMaybePromise, Plugin, PromiseOrValue } from '@envelop/core';
+import type { Plugin } from '@envelop/core';
+import { handleMaybePromise, mapMaybePromise, MaybePromise } from '@whatwg-node/promise-helpers';
 
 export type Resolver<Context = unknown> = (
   root: unknown,
   args: Record<string, unknown>,
   context: Context,
   info: GraphQLResolveInfo,
-) => PromiseOrValue<unknown>;
+) => MaybePromise<unknown>;
 
 export type AfterResolver = (options: {
   result: unknown;
   setResult: (newResult: unknown) => void;
-}) => PromiseOrValue<void>;
+}) => MaybePromise<void>;
 
 export interface OnResolveOptions<PluginContext extends Record<string, any> = {}> {
   context: PluginContext;
@@ -30,7 +31,7 @@ export interface OnResolveOptions<PluginContext extends Record<string, any> = {}
 
 export type OnResolve<PluginContext extends Record<string, any> = {}> = (
   options: OnResolveOptions<PluginContext>,
-) => PromiseOrValue<AfterResolver | void>;
+) => MaybePromise<AfterResolver | void>;
 
 export type UseOnResolveOptions = {
   /**
@@ -64,57 +65,46 @@ export function useOnResolve<PluginContext extends Record<string, any> = {}>(
             let resolver = (field.resolve || defaultFieldResolver) as Resolver<PluginContext>;
 
             field.resolve = (root, args, context, info) =>
-              mapMaybePromise(
-                onResolve({
-                  root,
-                  args,
-                  context,
-                  info,
-                  resolver,
-                  replaceResolver: newResolver => {
-                    resolver = newResolver;
-                  },
-                }),
+              handleMaybePromise(
+                () =>
+                  onResolve({
+                    root,
+                    args,
+                    context,
+                    info,
+                    resolver,
+                    replaceResolver: newResolver => {
+                      resolver = newResolver;
+                    },
+                  }),
                 afterResolve => {
                   if (typeof afterResolve === 'function') {
-                    try {
-                      return mapMaybePromise(
-                        resolver(root, args, context, info),
-                        result =>
-                          mapMaybePromise(
-                            afterResolve({
-                              result,
-                              setResult: newResult => {
-                                result = newResult;
-                              },
-                            }),
-                            () => result,
-                          ),
-                        errorResult =>
-                          mapMaybePromise(
+                    return handleMaybePromise(
+                      () => resolver(root, args, context, info),
+                      result =>
+                        mapMaybePromise(
+                          afterResolve({
+                            result,
+                            setResult: newResult => {
+                              result = newResult;
+                            },
+                          }),
+                          () => result,
+                        ),
+                      errorResult =>
+                        handleMaybePromise(
+                          () =>
                             afterResolve({
                               result: errorResult,
                               setResult: newResult => {
                                 errorResult = newResult;
                               },
                             }),
-                            () => {
-                              throw errorResult;
-                            },
-                          ),
-                      );
-                    } catch (err) {
-                      let errorResult = err;
-                      return mapMaybePromise(
-                        afterResolve({
-                          result: errorResult,
-                          setResult: newResult => {
-                            errorResult = newResult;
+                          () => {
+                            throw errorResult;
                           },
-                        }),
-                        () => errorResult,
-                      );
-                    }
+                        ),
+                    );
                   }
                   return resolver(root, args, context, info);
                 },

packages/plugins/rate-limiter/package.json

@@ -53,6 +53,7 @@
   "dependencies": {
     "@envelop/on-resolve": "workspace:^",
     "@graphql-tools/utils": "^10.5.4",
+    "@whatwg-node/promise-helpers": "^1.0.0",
     "lodash.get": "^4.4.2",
     "minimatch": "^10.0.1",
     "ms": "^2.1.3",

packages/plugins/rate-limiter/src/index.ts

@@ -1,8 +1,9 @@
 import { GraphQLResolveInfo, responsePathAsArray } from 'graphql';
 import { minimatch } from 'minimatch';
-import { mapMaybePromise, Plugin } from '@envelop/core';
+import type { Plugin } from '@envelop/core';
 import { useOnResolve } from '@envelop/on-resolve';
 import { createGraphQLError, getDirectiveExtensions } from '@graphql-tools/utils';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
 import { getGraphQLRateLimiter } from './get-graphql-rate-limiter.js';
 import { InMemoryStore } from './in-memory-store.js';
 import { RateLimitError } from './rate-limit-error.js';
@@ -133,34 +134,35 @@ export const useRateLimiter = (options: RateLimiterPluginOptions): Plugin<RateLi
               const window = rateLimitDef.window;
               const identifier = identifyFn(context);
 
-              return mapMaybePromise(
-                rateLimiterFn(
-                  {
-                    parent: root,
-                    args: fieldIdentity ? { ...args, identifier } : args,
-                    context,
-                    info,
-                  },
-                  {
-                    max,
-                    window,
-                    identityArgs: fieldIdentity
-                      ? ['identifier', ...(rateLimitDef.identityArgs || [])]
-                      : rateLimitDef.identityArgs,
-                    arrayLengthField: rateLimitDef.arrayLengthField,
-                    uncountRejected: rateLimitDef.uncountRejected,
-                    readOnly: rateLimitDef.readOnly,
-                    message:
-                      message && identifier
-                        ? interpolateMessage(message, identifier, {
-                            root,
-                            args,
-                            context,
-                            info,
-                          })
-                        : undefined,
-                  },
-                ),
+              return handleMaybePromise(
+                () =>
+                  rateLimiterFn(
+                    {
+                      parent: root,
+                      args: fieldIdentity ? { ...args, identifier } : args,
+                      context,
+                      info,
+                    },
+                    {
+                      max,
+                      window,
+                      identityArgs: fieldIdentity
+                        ? ['identifier', ...(rateLimitDef.identityArgs || [])]
+                        : rateLimitDef.identityArgs,
+                      arrayLengthField: rateLimitDef.arrayLengthField,
+                      uncountRejected: rateLimitDef.uncountRejected,
+                      readOnly: rateLimitDef.readOnly,
+                      message:
+                        message && identifier
+                          ? interpolateMessage(message, identifier, {
+                              root,
+                              args,
+                              context,
+                              info,
+                            })
+                          : undefined,
+                    },
+                  ),
                 errorMessage => {
                   if (errorMessage) {
                     if (options.onRateLimitError) {