Refactor Rate Limit plugin (ardatan#2292)

* Refactor Rate Limit plugin

* chore(dependencies): updated changesets for modified dependencies

* Ignore changesets

* ..

* Fix field identity support

---------

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

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

@@ -0,0 +1,7 @@
+---
+"@envelop/rate-limiter": patch
+---
+dependencies updates:
+  - Updated dependency [`graphql-rate-limit@^3.3.0` ↗︎](https://www.npmjs.com/package/graphql-rate-limit/v/3.3.0) (from `3.3.0`, in `dependencies`)
+  - Added dependency [`@graphql-tools/utils@^10.5.4` ↗︎](https://www.npmjs.com/package/@graphql-tools/utils/v/10.5.4) (to `dependencies`)
+  - Added dependency [`minimatch@^10.0.1` ↗︎](https://www.npmjs.com/package/minimatch/v/10.0.1) (to `dependencies`)

.changeset/chilled-shirts-develop.md

@@ -0,0 +1,26 @@
+---
+'@envelop/rate-limiter': minor
+---
+
+Now you can define a custom string interpolation function to be used in the rate limit message. This
+is useful when you want to include dynamic values in the message.
+
+```ts
+useRateLimiter({
+  configByField: [
+    {
+      type: 'Query',
+      field: 'search', // You can also use glob patterns
+      max: 10,
+      window: '1m',
+      message:
+        'My custom message with interpolated values: ${args.searchTerm} and ${context.user.id}'
+    }
+  ],
+  interpolateMessage: (message, args, context) => {
+    return message.replace(/\${(.*?)}/g, (_, key) => {
+      return key.split('.').reduce((acc, part) => acc[part], { args, context })
+    })
+  }
+})
+```

.changeset/early-deers-roll.md

@@ -0,0 +1,5 @@
+---
+'@envelop/on-resolve': patch
+---
+
+Refactor the plugin to avoid extra promises with \`mapMaybePromise\`

.changeset/fuzzy-donkeys-walk.md

@@ -0,0 +1,17 @@
+---
+'@envelop/rate-limiter': minor
+---
+
+New directive SDL;
+
+```graphql
+directive @rateLimit(
+  max: Int
+  window: String
+  message: String
+  identityArgs: [String]
+  arrayLengthField: String
+  readOnly: Boolean
+  uncountRejected: Boolean
+) on FIELD_DEFINITION
+```

.changeset/olive-rings-enjoy.md

@@ -0,0 +1,18 @@
+---
+'@envelop/rate-limiter': minor
+---
+
+Programmatic API to define rate limit configuration in addition to directives
+
+```ts
+useRateLimiter({
+  configByField: [
+    {
+      type: 'Query',
+      field: 'search', // You can also use glob patterns
+      max: 10,
+      window: '1m'
+    }
+  ]
+})
+```

.changeset/sharp-spoons-jam.md

@@ -0,0 +1,5 @@
+---
+'@envelop/core': patch
+---
+
+Export `mapMaybePromise` and `isPromise`

.prettierignore

@@ -9,3 +9,4 @@ examples/sveltekit
 .next
 pnpm-lock.yaml
 .husky
+.changeset/

packages/core/src/utils.ts

@@ -224,3 +224,32 @@ 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);
+}

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

@@ -5,7 +5,7 @@ import {
   isIntrospectionType,
   isObjectType,
 } from 'graphql';
-import { Plugin, PromiseOrValue } from '@envelop/core';
+import { mapMaybePromise, Plugin, PromiseOrValue } from '@envelop/core';
 
 export type Resolver<Context = unknown> = (
   root: unknown,
@@ -63,39 +63,62 @@ export function useOnResolve<PluginContext extends Record<string, any> = {}>(
 
             let resolver = (field.resolve || defaultFieldResolver) as Resolver<PluginContext>;
 
-            field.resolve = async (root, args, context, info) => {
-              const afterResolve = await onResolve({
-                root,
-                args,
-                context,
-                info,
-                resolver,
-                replaceResolver: newResolver => {
-                  resolver = newResolver;
-                },
-              });
-
-              let result;
-              try {
-                result = await resolver(root, args, context, info);
-              } catch (err) {
-                result = err as Error;
-              }
-
-              if (typeof afterResolve === 'function') {
-                await afterResolve({
-                  result,
-                  setResult: newResult => {
-                    result = newResult;
+            field.resolve = (root, args, context, info) =>
+              mapMaybePromise(
+                onResolve({
+                  root,
+                  args,
+                  context,
+                  info,
+                  resolver,
+                  replaceResolver: newResolver => {
+                    resolver = newResolver;
                   },
-                });
-              }
-
-              if (result instanceof Error) {
-                throw result;
-              }
-              return result;
-            };
+                }),
+                afterResolve => {
+                  if (typeof afterResolve === 'function') {
+                    try {
+                      return mapMaybePromise(
+                        resolver(root, args, context, info),
+                        result =>
+                          mapMaybePromise(
+                            afterResolve({
+                              result,
+                              setResult: newResult => {
+                                result = newResult;
+                              },
+                            }),
+                            () => result,
+                          ),
+                        errorResult =>
+                          mapMaybePromise(
+                            afterResolve({
+                              result: errorResult,
+                              setResult: newResult => {
+                                errorResult = newResult;
+                              },
+                            }),
+                            () => {
+                              throw errorResult;
+                            },
+                          ),
+                      );
+                    } catch (err) {
+                      let errorResult = err;
+                      return mapMaybePromise(
+                        afterResolve({
+                          result: errorResult,
+                          setResult: newResult => {
+                            errorResult = newResult;
+                          },
+                        }),
+                        () => errorResult,
+                      );
+                    }
+                  }
+                  return resolver(root, args, context, info);
+                },
+              );
 
             field[hasWrappedResolveSymbol] = true;
           }

packages/plugins/rate-limiter/package.json

@@ -52,7 +52,9 @@
   },
   "dependencies": {
     "@envelop/on-resolve": "^4.1.0",
-    "graphql-rate-limit": "3.3.0",
+    "@graphql-tools/utils": "^10.5.4",
+    "graphql-rate-limit": "^3.3.0",
+    "minimatch": "^10.0.1",
     "tslib": "^2.5.0"
   },
   "devDependencies": {