@envelop/rate-limiter 10.0.0-alpha-20251212015846-91d81e2860e085b5f5e1a780e4cab2f58e349142 → 10.0.0-alpha-20251212093955-081ac8d8cd90f8b5d037dd416f9eca842de513d1

package/cjs/get-graphql-rate-limiter.js

@@ -59,9 +59,9 @@ userConfig) => {
      * @param args - pass the resolver args as an object
      * @param config - field level config
      */
-    const rateLimiter = (
+    const rateLimiter = (fieldName, 
     // Resolver args
-    { args, context, info, }, 
+    { args, context, }, 
     // Field level config (e.g. the directive parameters)
     { arrayLengthField, identityArgs, max, window, message, readOnly, uncountRejected, }) => {
         // Identify the user or client on the context
@@ -69,7 +69,7 @@ userConfig) => {
         // User defined window in ms that this field can be accessed for before the call is expired
         const windowMs = (window ? (0, ms_1.default)(window) : DEFAULT_WINDOW);
         // String key for this field
-        const fieldIdentity = getFieldIdentity(info.fieldName, identityArgs || DEFAULT_FIELD_IDENTITY_ARGS, args);
+        const fieldIdentity = getFieldIdentity(fieldName, identityArgs || DEFAULT_FIELD_IDENTITY_ARGS, args);
         // User configured maximum calls to this field
         const maxCalls = max || DEFAULT_MAX;
         // Call count could be determined by the lenght of the array value, but most commonly 1
@@ -107,7 +107,7 @@ userConfig) => {
                     formatError({
                         contextIdentity,
                         fieldIdentity,
-                        fieldName: info.fieldName,
+                        fieldName,
                         max: maxCalls,
                         window: windowMs,
                     });

package/cjs/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useRateLimiter = exports.defaultInterpolateMessageFn = exports.DIRECTIVE_SDL = exports.Store = exports.RedisStore = exports.RateLimitError = exports.InMemoryStore = void 0;
+exports.useRateLimiter = exports.defaultInterpolateMessageFn = exports.DIRECTIVE_SDL = exports.Store = exports.RedisStore = exports.InMemoryStore = void 0;
 const tslib_1 = require("tslib");
+const types_1 = require("util/types");
 const graphql_1 = require("graphql");
 const picomatch_1 = tslib_1.__importDefault(require("picomatch"));
 const utils_1 = require("@graphql-tools/utils");
@@ -9,8 +10,6 @@ const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const get_graphql_rate_limiter_js_1 = require("./get-graphql-rate-limiter.js");
 const in_memory_store_js_1 = require("./in-memory-store.js");
 Object.defineProperty(exports, "InMemoryStore", { enumerable: true, get: function () { return in_memory_store_js_1.InMemoryStore; } });
-const rate_limit_error_js_1 = require("./rate-limit-error.js");
-Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return rate_limit_error_js_1.RateLimitError; } });
 const redis_store_js_1 = require("./redis-store.js");
 Object.defineProperty(exports, "RedisStore", { enumerable: true, get: function () { return redis_store_js_1.RedisStore; } });
 const store_js_1 = require("./store.js");
@@ -28,6 +27,9 @@ exports.DIRECTIVE_SDL = `
 `;
 const defaultInterpolateMessageFn = (message, identifier) => interpolateByArgs(message, { id: identifier });
 exports.defaultInterpolateMessageFn = defaultInterpolateMessageFn;
+const getTypeInfo = (0, utils_1.memoize1)(function getTypeInfo(schema) {
+    return new graphql_1.TypeInfo(schema);
+});
 const useRateLimiter = (options) => {
     const rateLimiterFn = (0, get_graphql_rate_limiter_js_1.getGraphQLRateLimiter)({
         ...options,
@@ -40,81 +42,144 @@ const useRateLimiter = (options) => {
             type: (0, picomatch_1.default)(config.type),
             field: (0, picomatch_1.default)(config.field),
         },
-    }));
+    })) || [];
     const directiveName = options.rateLimitDirectiveName ?? 'rateLimit';
+    const getRateLimitConfig = (0, utils_1.memoize4)(function getFieldConfigs(configByField, schema, type, field) {
+        const fieldConfigs = configByField?.filter(({ isMatch }) => isMatch.type(type.name) && isMatch.field(field.name));
+        if (fieldConfigs && fieldConfigs.length > 1) {
+            throw new Error(`Config error: field '${type.name}.${field.name}' has multiple matching configuration`);
+        }
+        const fieldConfig = fieldConfigs?.[0];
+        const rateLimitDirective = (0, utils_1.getDirectiveExtensions)(field, schema)[directiveName]?.[0];
+        if (rateLimitDirective && fieldConfig) {
+            throw new Error(`Config error: field '${type.name}.${field.name}' has both a configuration and a directive`);
+        }
+        const rateLimitConfig = rateLimitDirective || fieldConfig;
+        if (!rateLimitConfig) {
+            return undefined;
+        }
+        rateLimitConfig.max = Number(rateLimitConfig.max);
+        if (rateLimitConfig?.identifyFn) {
+            rateLimitConfig.identityArgs = ['identifier', ...(rateLimitConfig.identityArgs ?? [])];
+        }
+        return rateLimitConfig;
+    });
     return {
-        onSchemaChange({ schema: _schema }) {
-            if (!_schema) {
-                return;
-            }
-            const schema = _schema;
-            for (const type of Object.values(schema.getTypeMap())) {
-                if (!(0, graphql_1.isObjectType)(type)) {
-                    continue;
-                }
-                for (const field of Object.values(type.getFields())) {
-                    const fieldConfigs = configByField?.filter(({ isMatch }) => isMatch.type(type.name) && isMatch.field(field.name));
-                    if (fieldConfigs && fieldConfigs.length > 1) {
-                        throw new Error(`Config error: field '${type.name}.${field.name}' has multiple matching configuration`);
-                    }
-                    const fieldConfig = fieldConfigs?.[0];
-                    const rateLimitDirective = (0, utils_1.getDirectiveExtensions)(field, schema)[directiveName]?.[0];
-                    if (rateLimitDirective && fieldConfig) {
-                        throw new Error(`Config error: field '${type.name}.${field.name}' has both a configuration and a directive`);
-                    }
-                    const baseConfig = rateLimitDirective ?? fieldConfig;
-                    if (baseConfig) {
-                        const rateLimitConfig = { ...baseConfig };
-                        rateLimitConfig.max = rateLimitConfig.max && Number(rateLimitConfig.max);
-                        if (fieldConfig?.identifyFn) {
-                            rateLimitConfig.identityArgs = [
-                                'identifier',
-                                ...(rateLimitConfig.identityArgs ?? []),
-                            ];
+        onExecute({ args, setResultAndStopExecution }) {
+            const { document, schema, contextValue: context, variableValues, rootValue: root } = args;
+            const typeInfo = getTypeInfo(schema);
+            const rateLimitCalls = new Set();
+            const errors = [];
+            args.document = (0, graphql_1.visit)(document, (0, graphql_1.visitWithTypeInfo)(typeInfo, {
+                Field(node, _key, _parent, path, _ancestors) {
+                    const type = typeInfo.getParentType();
+                    const field = typeInfo.getFieldDef();
+                    if (type != null && field != null) {
+                        const rateLimitConfig = getRateLimitConfig(configByField, schema, type, field);
+                        if (!rateLimitConfig) {
+                            return;
                         }
-                        const originalResolver = field.resolve ?? graphql_1.defaultFieldResolver;
-                        field.resolve = (parent, args, context, info) => {
-                            const resolverRateLimitConfig = { ...rateLimitConfig };
-                            const executionArgs = { parent, args, context, info };
-                            const identifier = (fieldConfig?.identifyFn ?? options.identifyFn)(context);
-                            if (fieldConfig?.identifyFn) {
-                                executionArgs.args = { identifier, ...args };
+                        const resolverRateLimitConfig = { ...rateLimitConfig };
+                        const identifier = (rateLimitConfig?.identifyFn ?? options.identifyFn)(context);
+                        let args = null;
+                        function getArgValues() {
+                            if (!args) {
+                                if (field) {
+                                    args = (0, utils_1.getArgumentValues)(field, node, variableValues);
+                                }
                             }
-                            if (resolverRateLimitConfig.message && identifier) {
-                                const messageArgs = { root: parent, args, context, info };
-                                resolverRateLimitConfig.message = interpolateMessage(resolverRateLimitConfig.message, identifier, messageArgs);
+                            return args;
+                        }
+                        const executionArgs = {
+                            identifier,
+                            root,
+                            get args() {
+                                return {
+                                    ...(getArgValues() || {}),
+                                    identifier,
+                                };
+                            },
+                            context,
+                            type,
+                            field,
+                        };
+                        if (resolverRateLimitConfig.message && identifier) {
+                            resolverRateLimitConfig.message = interpolateMessage(resolverRateLimitConfig.message, identifier, executionArgs);
+                        }
+                        const rateLimitResult = (0, promise_helpers_1.handleMaybePromise)(() => rateLimiterFn(field.name, executionArgs, resolverRateLimitConfig), rateLimitError => {
+                            if (!rateLimitError) {
+                                return true;
                             }
-                            return (0, promise_helpers_1.handleMaybePromise)(() => rateLimiterFn(executionArgs, resolverRateLimitConfig), rateLimitError => {
-                                if (!rateLimitError) {
-                                    return originalResolver(parent, args, context, info);
-                                }
-                                if (options.onRateLimitError) {
-                                    options.onRateLimitError({
-                                        error: rateLimitError,
-                                        identifier,
-                                        context,
-                                        info,
-                                    });
-                                }
-                                if (options.transformError) {
-                                    throw options.transformError(rateLimitError);
+                            if (options.onRateLimitError) {
+                                options.onRateLimitError({
+                                    error: rateLimitError,
+                                    ...executionArgs,
+                                });
+                            }
+                            if (options.transformError) {
+                                throw options.transformError(rateLimitError);
+                            }
+                            const resolvePath = [];
+                            let curr = document;
+                            const operationAST = (0, utils_1.getOperationASTFromDocument)(document);
+                            let currType = (0, utils_1.getDefinedRootType)(schema, operationAST.operation);
+                            for (const pathItem of path) {
+                                curr = curr[pathItem];
+                                if (curr?.kind === 'Field') {
+                                    const fieldName = curr.name.value;
+                                    const responseKey = curr.alias?.value ?? fieldName;
+                                    let field;
+                                    if ((0, graphql_1.isObjectType)(currType)) {
+                                        field = currType.getFields()[fieldName];
+                                    }
+                                    else if ((0, graphql_1.isAbstractType)(currType)) {
+                                        for (const possibleType of schema.getPossibleTypes(currType)) {
+                                            field = possibleType.getFields()[fieldName];
+                                            if (field) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    if ((0, graphql_1.isListType)(field?.type)) {
+                                        resolvePath.push('@');
+                                    }
+                                    resolvePath.push(responseKey);
+                                    if (field?.type) {
+                                        currType = (0, graphql_1.getNamedType)(field.type);
+                                    }
                                 }
-                                const errorOptions = {
-                                    extensions: { http: { statusCode: 429 } },
-                                    path: (0, graphql_1.responsePathAsArray)(info.path),
-                                    nodes: info.fieldNodes,
+                            }
+                            const errorOptions = {
+                                extensions: { http: { statusCode: 429 } },
+                                path: resolvePath,
+                                nodes: [node],
+                            };
+                            if (resolverRateLimitConfig.window) {
+                                errorOptions.extensions.http.headers = {
+                                    'Retry-After': resolverRateLimitConfig.window,
                                 };
-                                if (resolverRateLimitConfig.window) {
-                                    errorOptions.extensions.http.headers = {
-                                        'Retry-After': resolverRateLimitConfig.window,
-                                    };
-                                }
-                                throw (0, utils_1.createGraphQLError)(rateLimitError, errorOptions);
-                            });
-                        };
+                            }
+                            errors.push((0, utils_1.createGraphQLError)(rateLimitError, errorOptions));
+                            return false;
+                        });
+                        if ((0, types_1.isPromise)(rateLimitResult)) {
+                            rateLimitCalls.add(rateLimitResult);
+                            return node;
+                        }
+                        else if (rateLimitResult === false) {
+                            return null;
+                        }
                     }
+                    return node;
+                },
+            }));
+            return (0, promise_helpers_1.handleMaybePromise)(() => (rateLimitCalls.size ? Promise.all(rateLimitCalls) : undefined), () => {
+                if (errors.length) {
+                    setResultAndStopExecution({
+                        errors,
+                    });
                 }
-            }
+            });
         },
         onContextBuilding({ extendContext }) {
             extendContext({

package/esm/get-graphql-rate-limiter.js

@@ -54,9 +54,9 @@ userConfig) => {
      * @param args - pass the resolver args as an object
      * @param config - field level config
      */
-    const rateLimiter = (
+    const rateLimiter = (fieldName, 
     // Resolver args
-    { args, context, info, }, 
+    { args, context, }, 
     // Field level config (e.g. the directive parameters)
     { arrayLengthField, identityArgs, max, window, message, readOnly, uncountRejected, }) => {
         // Identify the user or client on the context
@@ -64,7 +64,7 @@ userConfig) => {
         // User defined window in ms that this field can be accessed for before the call is expired
         const windowMs = (window ? ms(window) : DEFAULT_WINDOW);
         // String key for this field
-        const fieldIdentity = getFieldIdentity(info.fieldName, identityArgs || DEFAULT_FIELD_IDENTITY_ARGS, args);
+        const fieldIdentity = getFieldIdentity(fieldName, identityArgs || DEFAULT_FIELD_IDENTITY_ARGS, args);
         // User configured maximum calls to this field
         const maxCalls = max || DEFAULT_MAX;
         // Call count could be determined by the lenght of the array value, but most commonly 1
@@ -102,7 +102,7 @@ userConfig) => {
                     formatError({
                         contextIdentity,
                         fieldIdentity,
-                        fieldName: info.fieldName,
+                        fieldName,
                         max: maxCalls,
                         window: windowMs,
                     });

package/esm/index.js

@@ -1,13 +1,13 @@
-import { defaultFieldResolver, isObjectType, responsePathAsArray, } from 'graphql';
+import { isPromise } from 'util/types';
+import { getNamedType, isAbstractType, isListType, isObjectType, TypeInfo, visit, visitWithTypeInfo, } from 'graphql';
 import picomatch from 'picomatch';
-import { createGraphQLError, getDirectiveExtensions } from '@graphql-tools/utils';
+import { createGraphQLError, getArgumentValues, getDefinedRootType, getDirectiveExtensions, getOperationASTFromDocument, memoize1, memoize4, } 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';
 import { RedisStore } from './redis-store.js';
 import { Store } from './store.js';
-export { InMemoryStore, RateLimitError, RedisStore, Store, };
+export { InMemoryStore, RedisStore, Store, };
 export const DIRECTIVE_SDL = /* GraphQL */ `
   directive @rateLimit(
     max: Int
@@ -20,6 +20,9 @@ export const DIRECTIVE_SDL = /* GraphQL */ `
   ) on FIELD_DEFINITION
 `;
 export const defaultInterpolateMessageFn = (message, identifier) => interpolateByArgs(message, { id: identifier });
+const getTypeInfo = memoize1(function getTypeInfo(schema) {
+    return new TypeInfo(schema);
+});
 export const useRateLimiter = (options) => {
     const rateLimiterFn = getGraphQLRateLimiter({
         ...options,
@@ -32,81 +35,144 @@ export const useRateLimiter = (options) => {
             type: picomatch(config.type),
             field: picomatch(config.field),
         },
-    }));
+    })) || [];
     const directiveName = options.rateLimitDirectiveName ?? 'rateLimit';
+    const getRateLimitConfig = memoize4(function getFieldConfigs(configByField, schema, type, field) {
+        const fieldConfigs = configByField?.filter(({ isMatch }) => isMatch.type(type.name) && isMatch.field(field.name));
+        if (fieldConfigs && fieldConfigs.length > 1) {
+            throw new Error(`Config error: field '${type.name}.${field.name}' has multiple matching configuration`);
+        }
+        const fieldConfig = fieldConfigs?.[0];
+        const rateLimitDirective = getDirectiveExtensions(field, schema)[directiveName]?.[0];
+        if (rateLimitDirective && fieldConfig) {
+            throw new Error(`Config error: field '${type.name}.${field.name}' has both a configuration and a directive`);
+        }
+        const rateLimitConfig = rateLimitDirective || fieldConfig;
+        if (!rateLimitConfig) {
+            return undefined;
+        }
+        rateLimitConfig.max = Number(rateLimitConfig.max);
+        if (rateLimitConfig?.identifyFn) {
+            rateLimitConfig.identityArgs = ['identifier', ...(rateLimitConfig.identityArgs ?? [])];
+        }
+        return rateLimitConfig;
+    });
     return {
-        onSchemaChange({ schema: _schema }) {
-            if (!_schema) {
-                return;
-            }
-            const schema = _schema;
-            for (const type of Object.values(schema.getTypeMap())) {
-                if (!isObjectType(type)) {
-                    continue;
-                }
-                for (const field of Object.values(type.getFields())) {
-                    const fieldConfigs = configByField?.filter(({ isMatch }) => isMatch.type(type.name) && isMatch.field(field.name));
-                    if (fieldConfigs && fieldConfigs.length > 1) {
-                        throw new Error(`Config error: field '${type.name}.${field.name}' has multiple matching configuration`);
-                    }
-                    const fieldConfig = fieldConfigs?.[0];
-                    const rateLimitDirective = getDirectiveExtensions(field, schema)[directiveName]?.[0];
-                    if (rateLimitDirective && fieldConfig) {
-                        throw new Error(`Config error: field '${type.name}.${field.name}' has both a configuration and a directive`);
-                    }
-                    const baseConfig = rateLimitDirective ?? fieldConfig;
-                    if (baseConfig) {
-                        const rateLimitConfig = { ...baseConfig };
-                        rateLimitConfig.max = rateLimitConfig.max && Number(rateLimitConfig.max);
-                        if (fieldConfig?.identifyFn) {
-                            rateLimitConfig.identityArgs = [
-                                'identifier',
-                                ...(rateLimitConfig.identityArgs ?? []),
-                            ];
+        onExecute({ args, setResultAndStopExecution }) {
+            const { document, schema, contextValue: context, variableValues, rootValue: root } = args;
+            const typeInfo = getTypeInfo(schema);
+            const rateLimitCalls = new Set();
+            const errors = [];
+            args.document = visit(document, visitWithTypeInfo(typeInfo, {
+                Field(node, _key, _parent, path, _ancestors) {
+                    const type = typeInfo.getParentType();
+                    const field = typeInfo.getFieldDef();
+                    if (type != null && field != null) {
+                        const rateLimitConfig = getRateLimitConfig(configByField, schema, type, field);
+                        if (!rateLimitConfig) {
+                            return;
                         }
-                        const originalResolver = field.resolve ?? defaultFieldResolver;
-                        field.resolve = (parent, args, context, info) => {
-                            const resolverRateLimitConfig = { ...rateLimitConfig };
-                            const executionArgs = { parent, args, context, info };
-                            const identifier = (fieldConfig?.identifyFn ?? options.identifyFn)(context);
-                            if (fieldConfig?.identifyFn) {
-                                executionArgs.args = { identifier, ...args };
+                        const resolverRateLimitConfig = { ...rateLimitConfig };
+                        const identifier = (rateLimitConfig?.identifyFn ?? options.identifyFn)(context);
+                        let args = null;
+                        function getArgValues() {
+                            if (!args) {
+                                if (field) {
+                                    args = getArgumentValues(field, node, variableValues);
+                                }
                             }
-                            if (resolverRateLimitConfig.message && identifier) {
-                                const messageArgs = { root: parent, args, context, info };
-                                resolverRateLimitConfig.message = interpolateMessage(resolverRateLimitConfig.message, identifier, messageArgs);
+                            return args;
+                        }
+                        const executionArgs = {
+                            identifier,
+                            root,
+                            get args() {
+                                return {
+                                    ...(getArgValues() || {}),
+                                    identifier,
+                                };
+                            },
+                            context,
+                            type,
+                            field,
+                        };
+                        if (resolverRateLimitConfig.message && identifier) {
+                            resolverRateLimitConfig.message = interpolateMessage(resolverRateLimitConfig.message, identifier, executionArgs);
+                        }
+                        const rateLimitResult = handleMaybePromise(() => rateLimiterFn(field.name, executionArgs, resolverRateLimitConfig), rateLimitError => {
+                            if (!rateLimitError) {
+                                return true;
                             }
-                            return handleMaybePromise(() => rateLimiterFn(executionArgs, resolverRateLimitConfig), rateLimitError => {
-                                if (!rateLimitError) {
-                                    return originalResolver(parent, args, context, info);
-                                }
-                                if (options.onRateLimitError) {
-                                    options.onRateLimitError({
-                                        error: rateLimitError,
-                                        identifier,
-                                        context,
-                                        info,
-                                    });
-                                }
-                                if (options.transformError) {
-                                    throw options.transformError(rateLimitError);
+                            if (options.onRateLimitError) {
+                                options.onRateLimitError({
+                                    error: rateLimitError,
+                                    ...executionArgs,
+                                });
+                            }
+                            if (options.transformError) {
+                                throw options.transformError(rateLimitError);
+                            }
+                            const resolvePath = [];
+                            let curr = document;
+                            const operationAST = getOperationASTFromDocument(document);
+                            let currType = getDefinedRootType(schema, operationAST.operation);
+                            for (const pathItem of path) {
+                                curr = curr[pathItem];
+                                if (curr?.kind === 'Field') {
+                                    const fieldName = curr.name.value;
+                                    const responseKey = curr.alias?.value ?? fieldName;
+                                    let field;
+                                    if (isObjectType(currType)) {
+                                        field = currType.getFields()[fieldName];
+                                    }
+                                    else if (isAbstractType(currType)) {
+                                        for (const possibleType of schema.getPossibleTypes(currType)) {
+                                            field = possibleType.getFields()[fieldName];
+                                            if (field) {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    if (isListType(field?.type)) {
+                                        resolvePath.push('@');
+                                    }
+                                    resolvePath.push(responseKey);
+                                    if (field?.type) {
+                                        currType = getNamedType(field.type);
+                                    }
                                 }
-                                const errorOptions = {
-                                    extensions: { http: { statusCode: 429 } },
-                                    path: responsePathAsArray(info.path),
-                                    nodes: info.fieldNodes,
+                            }
+                            const errorOptions = {
+                                extensions: { http: { statusCode: 429 } },
+                                path: resolvePath,
+                                nodes: [node],
+                            };
+                            if (resolverRateLimitConfig.window) {
+                                errorOptions.extensions.http.headers = {
+                                    'Retry-After': resolverRateLimitConfig.window,
                                 };
-                                if (resolverRateLimitConfig.window) {
-                                    errorOptions.extensions.http.headers = {
-                                        'Retry-After': resolverRateLimitConfig.window,
-                                    };
-                                }
-                                throw createGraphQLError(rateLimitError, errorOptions);
-                            });
-                        };
+                            }
+                            errors.push(createGraphQLError(rateLimitError, errorOptions));
+                            return false;
+                        });
+                        if (isPromise(rateLimitResult)) {
+                            rateLimitCalls.add(rateLimitResult);
+                            return node;
+                        }
+                        else if (rateLimitResult === false) {
+                            return null;
+                        }
                     }
+                    return node;
+                },
+            }));
+            return handleMaybePromise(() => (rateLimitCalls.size ? Promise.all(rateLimitCalls) : undefined), () => {
+                if (errors.length) {
+                    setResultAndStopExecution({
+                        errors,
+                    });
                 }
-            }
+            });
         },
         onContextBuilding({ extendContext }) {
             extendContext({

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@envelop/rate-limiter",
-  "version": "10.0.0-alpha-20251212015846-91d81e2860e085b5f5e1a780e4cab2f58e349142",
+  "version": "10.0.0-alpha-20251212093955-081ac8d8cd90f8b5d037dd416f9eca842de513d1",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0",
-    "@envelop/core": "^5.5.0-alpha-20251212015846-91d81e2860e085b5f5e1a780e4cab2f58e349142"
+    "@envelop/core": "^5.5.0-alpha-20251212093955-081ac8d8cd90f8b5d037dd416f9eca842de513d1"
   },
   "dependencies": {
     "@graphql-tools/utils": "^10.5.4",
@@ -14,7 +14,7 @@
     "ms": "^2.1.3",
     "picomatch": "^4.0.3",
     "tslib": "^2.5.0",
-    "@envelop/on-resolve": "^8.0.0-alpha-20251212015846-91d81e2860e085b5f5e1a780e4cab2f58e349142"
+    "@envelop/on-resolve": "^8.0.0-alpha-20251212093955-081ac8d8cd90f8b5d037dd416f9eca842de513d1"
   },
   "repository": {
     "type": "git",

package/typings/get-graphql-rate-limiter.d.cts

@@ -1,4 +1,3 @@
-import type { GraphQLResolveInfo } from 'graphql';
 import { MaybePromise } from '@whatwg-node/promise-helpers';
 import type { GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs } from './types.cjs';
 /**
@@ -20,10 +19,8 @@ declare const getFieldIdentity: (fieldName: string, identityArgs: readonly strin
  * can wrap this or it can be used directly in resolvers.
  * @param userConfig - global (usually app-wide) rate limiting config
  */
-declare const getGraphQLRateLimiter: (userConfig: GraphQLRateLimitConfig) => (({ args, context, info, }: {
-    parent: any;
+declare const getGraphQLRateLimiter: (userConfig: GraphQLRateLimitConfig) => ((fieldName: string, { args, context, }: {
     args: Record<string, any>;
     context: any;
-    info: GraphQLResolveInfo;
 }, { arrayLengthField, identityArgs, max, window, message, uncountRejected, }: GraphQLRateLimitDirectiveArgs) => MaybePromise<string | undefined>);
 export { getGraphQLRateLimiter, getFieldIdentity };

package/typings/get-graphql-rate-limiter.d.ts

@@ -1,4 +1,3 @@
-import type { GraphQLResolveInfo } from 'graphql';
 import { MaybePromise } from '@whatwg-node/promise-helpers';
 import type { GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs } from './types.js';
 /**
@@ -20,10 +19,8 @@ declare const getFieldIdentity: (fieldName: string, identityArgs: readonly strin
  * can wrap this or it can be used directly in resolvers.
  * @param userConfig - global (usually app-wide) rate limiting config
  */
-declare const getGraphQLRateLimiter: (userConfig: GraphQLRateLimitConfig) => (({ args, context, info, }: {
-    parent: any;
+declare const getGraphQLRateLimiter: (userConfig: GraphQLRateLimitConfig) => ((fieldName: string, { args, context, }: {
     args: Record<string, any>;
     context: any;
-    info: GraphQLResolveInfo;
 }, { arrayLengthField, identityArgs, max, window, message, uncountRejected, }: GraphQLRateLimitDirectiveArgs) => MaybePromise<string | undefined>);
 export { getGraphQLRateLimiter, getFieldIdentity };

package/typings/index.d.cts

@@ -1,19 +1,20 @@
-import { GraphQLResolveInfo } from 'graphql';
+import { GraphQLField, GraphQLNamedOutputType } from 'graphql';
 import type { Plugin } from '@envelop/core';
 import { getGraphQLRateLimiter } from './get-graphql-rate-limiter.cjs';
 import { InMemoryStore } from './in-memory-store.cjs';
-import { RateLimitError } from './rate-limit-error.cjs';
 import { RedisStore } from './redis-store.cjs';
 import { Store } from './store.cjs';
 import { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, Options } from './types.cjs';
-export { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, InMemoryStore, Options, RateLimitError, RedisStore, Store, };
+export { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, InMemoryStore, Options, RedisStore, Store, };
 export type IdentifyFn<ContextType = unknown> = (context: ContextType) => string;
-export type MessageInterpolator<ContextType = unknown> = (message: string, identifier: string, params: {
+interface RateLimitExecutionParams<ContextType = unknown> {
     root: unknown;
     args: Record<string, unknown>;
     context: ContextType;
-    info: GraphQLResolveInfo;
-}) => string;
+    type: GraphQLNamedOutputType;
+    field: GraphQLField<any, any>;
+}
+export type MessageInterpolator<ContextType = unknown> = (message: string, identifier: string, params: RateLimitExecutionParams<ContextType>) => string;
 export declare const DIRECTIVE_SDL = "\n  directive @rateLimit(\n    max: Int\n    window: String\n    message: String\n    identityArgs: [String]\n    arrayLengthField: String\n    readOnly: Boolean\n    uncountRejected: Boolean\n  ) on FIELD_DEFINITION\n";
 export type RateLimitDirectiveArgs = {
     max?: number;
@@ -31,9 +32,7 @@ export type RateLimiterPluginOptions = {
     onRateLimitError?: (event: {
         error: string;
         identifier: string;
-        context: unknown;
-        info: GraphQLResolveInfo;
-    }) => void;
+    } & RateLimitExecutionParams) => void;
     interpolateMessage?: MessageInterpolator;
     configByField?: ConfigByField[];
 } & Omit<GraphQLRateLimitConfig, 'identifyContext'>;

package/typings/index.d.ts

@@ -1,19 +1,20 @@
-import { GraphQLResolveInfo } from 'graphql';
+import { GraphQLField, GraphQLNamedOutputType } from 'graphql';
 import type { Plugin } from '@envelop/core';
 import { getGraphQLRateLimiter } from './get-graphql-rate-limiter.js';
 import { InMemoryStore } from './in-memory-store.js';
-import { RateLimitError } from './rate-limit-error.js';
 import { RedisStore } from './redis-store.js';
 import { Store } from './store.js';
 import { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, Options } from './types.js';
-export { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, InMemoryStore, Options, RateLimitError, RedisStore, Store, };
+export { FormatErrorInput, GraphQLRateLimitConfig, GraphQLRateLimitDirectiveArgs, Identity, InMemoryStore, Options, RedisStore, Store, };
 export type IdentifyFn<ContextType = unknown> = (context: ContextType) => string;
-export type MessageInterpolator<ContextType = unknown> = (message: string, identifier: string, params: {
+interface RateLimitExecutionParams<ContextType = unknown> {
     root: unknown;
     args: Record<string, unknown>;
     context: ContextType;
-    info: GraphQLResolveInfo;
-}) => string;
+    type: GraphQLNamedOutputType;
+    field: GraphQLField<any, any>;
+}
+export type MessageInterpolator<ContextType = unknown> = (message: string, identifier: string, params: RateLimitExecutionParams<ContextType>) => string;
 export declare const DIRECTIVE_SDL = "\n  directive @rateLimit(\n    max: Int\n    window: String\n    message: String\n    identityArgs: [String]\n    arrayLengthField: String\n    readOnly: Boolean\n    uncountRejected: Boolean\n  ) on FIELD_DEFINITION\n";
 export type RateLimitDirectiveArgs = {
     max?: number;
@@ -31,9 +32,7 @@ export type RateLimiterPluginOptions = {
     onRateLimitError?: (event: {
         error: string;
         identifier: string;
-        context: unknown;
-        info: GraphQLResolveInfo;
-    }) => void;
+    } & RateLimitExecutionParams) => void;
     interpolateMessage?: MessageInterpolator;
     configByField?: ConfigByField[];
 } & Omit<GraphQLRateLimitConfig, 'identifyContext'>;

package/typings/types.d.cts

@@ -89,11 +89,5 @@ export interface GraphQLRateLimitConfig {
      * Custom error messages.
      */
     readonly formatError?: (input: FormatErrorInput) => string;
-    /**
-     * Return an error.
-     *
-     * Defaults to new RateLimitError.
-     */
-    readonly createError?: (message: string) => Error;
     readonly enableBatchRequestCache?: boolean;
 }

package/typings/types.d.ts

@@ -89,11 +89,5 @@ export interface GraphQLRateLimitConfig {
      * Custom error messages.
      */
     readonly formatError?: (input: FormatErrorInput) => string;
-    /**
-     * Return an error.
-     *
-     * Defaults to new RateLimitError.
-     */
-    readonly createError?: (message: string) => Error;
     readonly enableBatchRequestCache?: boolean;
 }

package/cjs/rate-limit-error.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitError = void 0;
-class RateLimitError extends Error {
-    isRateLimitError = true;
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, RateLimitError.prototype);
-    }
-}
-exports.RateLimitError = RateLimitError;

package/esm/rate-limit-error.js

@@ -1,8 +0,0 @@
-class RateLimitError extends Error {
-    isRateLimitError = true;
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, RateLimitError.prototype);
-    }
-}
-export { RateLimitError };

package/typings/rate-limit-error.d.cts

@@ -1,5 +0,0 @@
-declare class RateLimitError extends Error {
-    readonly isRateLimitError = true;
-    constructor(message: string);
-}
-export { RateLimitError };

package/typings/rate-limit-error.d.ts

@@ -1,5 +0,0 @@
-declare class RateLimitError extends Error {
-    readonly isRateLimitError = true;
-    constructor(message: string);
-}
-export { RateLimitError };