@envelop/resource-limitations 0.2.0

package/README.md

@@ -0,0 +1,29 @@
+## `@envelop/resource-limitations`
+
+This plugins uses `extended-valiations` concept ([details here](https://github.com/dotansimha/envelop/tree/main/packages/plugins/extended-validation#envelopextended-validation)) for implemeting a resource-limitations rate-limit similar to GitHub GraphQL API (see https://docs.github.com/en/graphql/overview/resource-limitations for more details)
+
+## Getting Started
+
+```
+yarn add @envelop/resource-limitations
+```
+
+## Usage Example
+
+```ts
+import { envelop } from '@envelop/core';
+import { useResourceLimitations } from '@envelop/resource-limitations';
+
+const getEnveloped = envelop({
+  plugins: [
+    // ... other plugins ...
+    useResourceLimitations({
+      nodeCostLimit: 500000, // optional, default to 500000
+      paginationArgumentMaximum: 100, // optional, default to 100
+      paginationArgumentMinimum: 1, // optional, default to 1
+      paginationArgumentScalars: ['ConnectionInt'], // optional, use if connections use a different scalar type as the argument instead of `Int`
+      extensions: false, // set this to `true` in order to add the calculated const to the response of queries
+    }),
+  ],
+});
+```

package/index.d.ts

@@ -0,0 +1,45 @@
+import { Plugin } from '@envelop/types';
+import { ExtendedValidationRule } from '@envelop/extended-validation';
+import { ExecutionArgs } from 'graphql';
+export declare const defaultNodeCostLimit = 500000;
+export declare const defaultPaginationArgumentMaximum = 100;
+export declare const defaultPaginationArgumentMinimum = 1;
+export declare type ResourceLimitationValidationRuleParams = {
+    nodeCostLimit: number;
+    paginationArgumentMaximum: number;
+    paginationArgumentMinimum: number;
+    paginationArgumentTypes?: string[];
+    reportNodeCost?: (cost: number, executionArgs: ExecutionArgs) => void;
+};
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+export declare const ResourceLimitationValidationRule: (params: ResourceLimitationValidationRuleParams) => ExtendedValidationRule;
+declare type UseResourceLimitationsParams = {
+    /**
+     * The node cost limit for rejecting a operation.
+     * @default 500000
+     */
+    nodeCostLimit?: number;
+    /**
+     * The custom scalar types accepted for connection arguments.
+     */
+    paginationArgumentScalars?: string[];
+    /**
+     * The maximum value accepted for connection arguments.
+     * @default 100
+     */
+    paginationArgumentMaximum?: number;
+    /**
+     * The minimum value accepted for connection arguments.
+     * @default 1
+     */
+    paginationArgumentMinimum?: number;
+    /**
+     * Whether the resourceLimitations.nodeCost field should be included within the execution result extensions map.
+     * @default false
+     */
+    extensions?: boolean;
+};
+export declare const useResourceLimitations: (params?: UseResourceLimitationsParams | undefined) => Plugin;
+export {};

package/index.js

@@ -0,0 +1,255 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const graphql = require('graphql');
+const values_js = require('graphql/execution/values.js');
+
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ *
+ * Source: https://github.com/graphql/graphql-js/blob/main/src/jsutils/isAsyncIterable.ts
+ */
+function isAsyncIterable(maybeAsyncIterable) {
+    return typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0 ? void 0 : maybeAsyncIterable[Symbol.asyncIterator]) === 'function';
+}
+/**
+ * A utility function for hanlding `onExecuteDone` hook result, for simplifying the hanlding of AsyncIterable returned from `execute`.
+ *
+ * @param payload The payload send to `onExecuteDone` hook function
+ * @param fn The handler to be executed on each result
+ * @returns a subscription for streamed results, or undefined in case of an non-async
+ */
+function handleStreamOrSingleExecutionResult(payload, fn) {
+    if (isAsyncIterable(payload.result)) {
+        return { onNext: fn };
+    }
+    else {
+        fn({
+            args: payload.args,
+            result: payload.result,
+            setResult: payload.setResult,
+        });
+        return undefined;
+    }
+}
+
+const SYMBOL_EXTENDED_VALIDATION_RULES = Symbol('SYMBOL_EXTENDED_VALIDATION_RULES');
+const useExtendedValidation = (options) => {
+    let schemaTypeInfo;
+    return {
+        onSchemaChange({ schema }) {
+            schemaTypeInfo = new graphql.TypeInfo(schema);
+        },
+        onParse({ context, extendContext }) {
+            var _a;
+            const rules = (_a = context === null || context === void 0 ? void 0 : context[SYMBOL_EXTENDED_VALIDATION_RULES]) !== null && _a !== void 0 ? _a : [];
+            rules.push(...options.rules);
+            extendContext({
+                [SYMBOL_EXTENDED_VALIDATION_RULES]: rules,
+            });
+        },
+        onExecute({ args, setResultAndStopExecution }) {
+            const rules = args.contextValue[SYMBOL_EXTENDED_VALIDATION_RULES];
+            const errors = [];
+            const typeInfo = schemaTypeInfo || new graphql.TypeInfo(args.schema);
+            const validationContext = new graphql.ValidationContext(args.schema, args.document, typeInfo, e => {
+                errors.push(e);
+            });
+            const visitor = graphql.visitInParallel(rules.map(rule => rule(validationContext, args)));
+            graphql.visit(args.document, graphql.visitWithTypeInfo(typeInfo, visitor));
+            for (const rule of rules) {
+                rule(validationContext, args);
+            }
+            if (errors.length > 0) {
+                let result = {
+                    data: null,
+                    errors,
+                };
+                if (options.onValidationFailed) {
+                    options.onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
+                }
+                return setResultAndStopExecution(result);
+            }
+        },
+    };
+};
+
+const getWrappedType = (graphqlType) => {
+    if (graphqlType instanceof graphql.GraphQLList || graphqlType instanceof graphql.GraphQLNonNull) {
+        return getWrappedType(graphqlType.ofType);
+    }
+    return graphqlType;
+};
+const isValidArgType = (type, paginationArgumentTypes) => type === graphql.GraphQLInt || (graphql.isScalarType(type) && !!paginationArgumentTypes && paginationArgumentTypes.includes(type.name));
+const hasFieldDefConnectionArgs = (field, argumentTypes) => {
+    let hasFirst = false;
+    let hasLast = false;
+    for (const arg of field.args) {
+        if (arg.name === 'first' && isValidArgType(arg.type, argumentTypes)) {
+            hasFirst = true;
+        }
+        else if (arg.name === 'last' && isValidArgType(arg.type, argumentTypes)) {
+            hasLast = true;
+        }
+        else if (hasLast && hasFirst) {
+            break;
+        }
+    }
+    return { hasFirst, hasLast };
+};
+const buildMissingPaginationFieldErrorMessage = (params) => `Missing pagination argument for field '${params.fieldName}'. ` +
+    `Please provide ` +
+    (params.hasFirst && params.hasLast ? "either the 'first' or 'last'" : params.hasFirst ? "the 'first'" : "the 'last'") +
+    ' field argument.';
+const buildInvalidPaginationRangeErrorMessage = (params) => `Invalid pagination argument for field ${params.fieldName}. ` +
+    `The value for the '${params.argumentName}' argument must be an integer within ${params.paginationArgumentMinimum}-${params.paginationArgumentMaximum}.`;
+const defaultNodeCostLimit = 500000;
+const defaultPaginationArgumentMaximum = 100;
+const defaultPaginationArgumentMinimum = 1;
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+const ResourceLimitationValidationRule = (params) => (context, executionArgs) => {
+    const { paginationArgumentMaximum, paginationArgumentMinimum } = params;
+    const nodeCostStack = [];
+    let totalNodeCost = 0;
+    const connectionFieldMap = new WeakSet();
+    return {
+        Field: {
+            enter(fieldNode) {
+                const fieldDef = context.getFieldDef();
+                // if it is not found the query is invalid and graphql validation will complain
+                if (fieldDef != null) {
+                    const argumentValues = values_js.getArgumentValues(fieldDef, fieldNode, executionArgs.variableValues);
+                    const type = getWrappedType(fieldDef.type);
+                    if (type instanceof graphql.GraphQLObjectType && type.name.endsWith('Connection')) {
+                        let nodeCost = 1;
+                        connectionFieldMap.add(fieldNode);
+                        const { hasFirst, hasLast } = hasFieldDefConnectionArgs(fieldDef, params.paginationArgumentTypes);
+                        if (hasFirst === false && hasLast === false) {
+                            // eslint-disable-next-line no-console
+                            console.warn('Encountered paginated field without pagination arguments.');
+                        }
+                        else if (hasFirst === true || hasLast === true) {
+                            if ('first' in argumentValues === false && 'last' in argumentValues === false) {
+                                context.reportError(new graphql.GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                            else if ('first' in argumentValues === true && 'last' in argumentValues === false) {
+                                if (argumentValues.first < paginationArgumentMinimum || argumentValues.first > paginationArgumentMaximum) {
+                                    context.reportError(new graphql.GraphQLError(buildInvalidPaginationRangeErrorMessage({
+                                        paginationArgumentMaximum,
+                                        paginationArgumentMinimum,
+                                        argumentName: 'first',
+                                        fieldName: fieldDef.name,
+                                    }), fieldNode));
+                                }
+                                else {
+                                    // eslint-disable-next-line dot-notation
+                                    nodeCost = argumentValues['first'];
+                                }
+                            }
+                            else if ('last' in argumentValues === true && 'false' in argumentValues === false) {
+                                if (argumentValues.last < paginationArgumentMinimum || argumentValues.last > paginationArgumentMaximum) {
+                                    context.reportError(new graphql.GraphQLError(buildInvalidPaginationRangeErrorMessage({
+                                        paginationArgumentMaximum,
+                                        paginationArgumentMinimum,
+                                        argumentName: 'last',
+                                        fieldName: fieldDef.name,
+                                    }), fieldNode));
+                                }
+                                else {
+                                    // eslint-disable-next-line dot-notation
+                                    nodeCost = argumentValues['last'];
+                                }
+                            }
+                            else {
+                                context.reportError(new graphql.GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                        }
+                        nodeCostStack.push(nodeCost);
+                    }
+                }
+            },
+            leave(node) {
+                if (connectionFieldMap.delete(node)) {
+                    totalNodeCost = totalNodeCost + nodeCostStack.reduce((a, b) => a * b, 1);
+                    nodeCostStack.pop();
+                }
+            },
+        },
+        Document: {
+            leave(documentNode) {
+                var _a;
+                if (totalNodeCost === 0) {
+                    totalNodeCost = 1;
+                }
+                if (totalNodeCost > params.nodeCostLimit) {
+                    context.reportError(new graphql.GraphQLError(`Cannot request more than ${params.nodeCostLimit} nodes in a single document. Please split your operation into multiple sub operations or reduce the amount of requested nodes.`, documentNode));
+                }
+                (_a = params.reportNodeCost) === null || _a === void 0 ? void 0 : _a.call(params, totalNodeCost, executionArgs);
+            },
+        },
+    };
+};
+const useResourceLimitations = (params) => {
+    var _a, _b, _c, _d;
+    const paginationArgumentMaximum = (_a = params === null || params === void 0 ? void 0 : params.paginationArgumentMaximum) !== null && _a !== void 0 ? _a : defaultPaginationArgumentMaximum;
+    const paginationArgumentMinimum = (_b = params === null || params === void 0 ? void 0 : params.paginationArgumentMinimum) !== null && _b !== void 0 ? _b : defaultPaginationArgumentMinimum;
+    const nodeCostLimit = (_c = params === null || params === void 0 ? void 0 : params.nodeCostLimit) !== null && _c !== void 0 ? _c : defaultNodeCostLimit;
+    const extensions = (_d = params === null || params === void 0 ? void 0 : params.extensions) !== null && _d !== void 0 ? _d : false;
+    const nodeCostMap = new WeakMap();
+    const handleResult = ({ result, args }) => {
+        const nodeCost = nodeCostMap.get(args);
+        if (nodeCost != null) {
+            result.extensions = {
+                ...result.extensions,
+                resourceLimitations: {
+                    nodeCost,
+                },
+            };
+        }
+    };
+    return {
+        onPluginInit({ addPlugin }) {
+            addPlugin(useExtendedValidation({
+                rules: [
+                    ResourceLimitationValidationRule({
+                        nodeCostLimit,
+                        paginationArgumentMaximum,
+                        paginationArgumentMinimum,
+                        paginationArgumentTypes: params === null || params === void 0 ? void 0 : params.paginationArgumentScalars,
+                        reportNodeCost: extensions
+                            ? (nodeCost, ref) => {
+                                nodeCostMap.set(ref, nodeCost);
+                            }
+                            : undefined,
+                    }),
+                ],
+                onValidationFailed: params => handleResult(params),
+            }));
+        },
+        onExecute({ args }) {
+            return {
+                onExecuteDone(payload) {
+                    return handleStreamOrSingleExecutionResult(payload, ({ result }) => handleResult({ result, args }));
+                },
+            };
+        },
+    };
+};
+
+exports.ResourceLimitationValidationRule = ResourceLimitationValidationRule;
+exports.defaultNodeCostLimit = defaultNodeCostLimit;
+exports.defaultPaginationArgumentMaximum = defaultPaginationArgumentMaximum;
+exports.defaultPaginationArgumentMinimum = defaultPaginationArgumentMinimum;
+exports.useResourceLimitations = useResourceLimitations;

package/index.mjs

@@ -0,0 +1,247 @@
+import { TypeInfo, ValidationContext, visitInParallel, visit, visitWithTypeInfo, GraphQLObjectType, GraphQLError, GraphQLList, GraphQLNonNull, GraphQLInt, isScalarType } from 'graphql';
+import { getArgumentValues } from 'graphql/execution/values.js';
+
+/**
+ * Returns true if the provided object implements the AsyncIterator protocol via
+ * implementing a `Symbol.asyncIterator` method.
+ *
+ * Source: https://github.com/graphql/graphql-js/blob/main/src/jsutils/isAsyncIterable.ts
+ */
+function isAsyncIterable(maybeAsyncIterable) {
+    return typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0 ? void 0 : maybeAsyncIterable[Symbol.asyncIterator]) === 'function';
+}
+/**
+ * A utility function for hanlding `onExecuteDone` hook result, for simplifying the hanlding of AsyncIterable returned from `execute`.
+ *
+ * @param payload The payload send to `onExecuteDone` hook function
+ * @param fn The handler to be executed on each result
+ * @returns a subscription for streamed results, or undefined in case of an non-async
+ */
+function handleStreamOrSingleExecutionResult(payload, fn) {
+    if (isAsyncIterable(payload.result)) {
+        return { onNext: fn };
+    }
+    else {
+        fn({
+            args: payload.args,
+            result: payload.result,
+            setResult: payload.setResult,
+        });
+        return undefined;
+    }
+}
+
+const SYMBOL_EXTENDED_VALIDATION_RULES = Symbol('SYMBOL_EXTENDED_VALIDATION_RULES');
+const useExtendedValidation = (options) => {
+    let schemaTypeInfo;
+    return {
+        onSchemaChange({ schema }) {
+            schemaTypeInfo = new TypeInfo(schema);
+        },
+        onParse({ context, extendContext }) {
+            var _a;
+            const rules = (_a = context === null || context === void 0 ? void 0 : context[SYMBOL_EXTENDED_VALIDATION_RULES]) !== null && _a !== void 0 ? _a : [];
+            rules.push(...options.rules);
+            extendContext({
+                [SYMBOL_EXTENDED_VALIDATION_RULES]: rules,
+            });
+        },
+        onExecute({ args, setResultAndStopExecution }) {
+            const rules = args.contextValue[SYMBOL_EXTENDED_VALIDATION_RULES];
+            const errors = [];
+            const typeInfo = schemaTypeInfo || new TypeInfo(args.schema);
+            const validationContext = new ValidationContext(args.schema, args.document, typeInfo, e => {
+                errors.push(e);
+            });
+            const visitor = visitInParallel(rules.map(rule => rule(validationContext, args)));
+            visit(args.document, visitWithTypeInfo(typeInfo, visitor));
+            for (const rule of rules) {
+                rule(validationContext, args);
+            }
+            if (errors.length > 0) {
+                let result = {
+                    data: null,
+                    errors,
+                };
+                if (options.onValidationFailed) {
+                    options.onValidationFailed({ args, result, setResult: newResult => (result = newResult) });
+                }
+                return setResultAndStopExecution(result);
+            }
+        },
+    };
+};
+
+const getWrappedType = (graphqlType) => {
+    if (graphqlType instanceof GraphQLList || graphqlType instanceof GraphQLNonNull) {
+        return getWrappedType(graphqlType.ofType);
+    }
+    return graphqlType;
+};
+const isValidArgType = (type, paginationArgumentTypes) => type === GraphQLInt || (isScalarType(type) && !!paginationArgumentTypes && paginationArgumentTypes.includes(type.name));
+const hasFieldDefConnectionArgs = (field, argumentTypes) => {
+    let hasFirst = false;
+    let hasLast = false;
+    for (const arg of field.args) {
+        if (arg.name === 'first' && isValidArgType(arg.type, argumentTypes)) {
+            hasFirst = true;
+        }
+        else if (arg.name === 'last' && isValidArgType(arg.type, argumentTypes)) {
+            hasLast = true;
+        }
+        else if (hasLast && hasFirst) {
+            break;
+        }
+    }
+    return { hasFirst, hasLast };
+};
+const buildMissingPaginationFieldErrorMessage = (params) => `Missing pagination argument for field '${params.fieldName}'. ` +
+    `Please provide ` +
+    (params.hasFirst && params.hasLast ? "either the 'first' or 'last'" : params.hasFirst ? "the 'first'" : "the 'last'") +
+    ' field argument.';
+const buildInvalidPaginationRangeErrorMessage = (params) => `Invalid pagination argument for field ${params.fieldName}. ` +
+    `The value for the '${params.argumentName}' argument must be an integer within ${params.paginationArgumentMinimum}-${params.paginationArgumentMaximum}.`;
+const defaultNodeCostLimit = 500000;
+const defaultPaginationArgumentMaximum = 100;
+const defaultPaginationArgumentMinimum = 1;
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+const ResourceLimitationValidationRule = (params) => (context, executionArgs) => {
+    const { paginationArgumentMaximum, paginationArgumentMinimum } = params;
+    const nodeCostStack = [];
+    let totalNodeCost = 0;
+    const connectionFieldMap = new WeakSet();
+    return {
+        Field: {
+            enter(fieldNode) {
+                const fieldDef = context.getFieldDef();
+                // if it is not found the query is invalid and graphql validation will complain
+                if (fieldDef != null) {
+                    const argumentValues = getArgumentValues(fieldDef, fieldNode, executionArgs.variableValues);
+                    const type = getWrappedType(fieldDef.type);
+                    if (type instanceof GraphQLObjectType && type.name.endsWith('Connection')) {
+                        let nodeCost = 1;
+                        connectionFieldMap.add(fieldNode);
+                        const { hasFirst, hasLast } = hasFieldDefConnectionArgs(fieldDef, params.paginationArgumentTypes);
+                        if (hasFirst === false && hasLast === false) {
+                            // eslint-disable-next-line no-console
+                            console.warn('Encountered paginated field without pagination arguments.');
+                        }
+                        else if (hasFirst === true || hasLast === true) {
+                            if ('first' in argumentValues === false && 'last' in argumentValues === false) {
+                                context.reportError(new GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                            else if ('first' in argumentValues === true && 'last' in argumentValues === false) {
+                                if (argumentValues.first < paginationArgumentMinimum || argumentValues.first > paginationArgumentMaximum) {
+                                    context.reportError(new GraphQLError(buildInvalidPaginationRangeErrorMessage({
+                                        paginationArgumentMaximum,
+                                        paginationArgumentMinimum,
+                                        argumentName: 'first',
+                                        fieldName: fieldDef.name,
+                                    }), fieldNode));
+                                }
+                                else {
+                                    // eslint-disable-next-line dot-notation
+                                    nodeCost = argumentValues['first'];
+                                }
+                            }
+                            else if ('last' in argumentValues === true && 'false' in argumentValues === false) {
+                                if (argumentValues.last < paginationArgumentMinimum || argumentValues.last > paginationArgumentMaximum) {
+                                    context.reportError(new GraphQLError(buildInvalidPaginationRangeErrorMessage({
+                                        paginationArgumentMaximum,
+                                        paginationArgumentMinimum,
+                                        argumentName: 'last',
+                                        fieldName: fieldDef.name,
+                                    }), fieldNode));
+                                }
+                                else {
+                                    // eslint-disable-next-line dot-notation
+                                    nodeCost = argumentValues['last'];
+                                }
+                            }
+                            else {
+                                context.reportError(new GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                        }
+                        nodeCostStack.push(nodeCost);
+                    }
+                }
+            },
+            leave(node) {
+                if (connectionFieldMap.delete(node)) {
+                    totalNodeCost = totalNodeCost + nodeCostStack.reduce((a, b) => a * b, 1);
+                    nodeCostStack.pop();
+                }
+            },
+        },
+        Document: {
+            leave(documentNode) {
+                var _a;
+                if (totalNodeCost === 0) {
+                    totalNodeCost = 1;
+                }
+                if (totalNodeCost > params.nodeCostLimit) {
+                    context.reportError(new GraphQLError(`Cannot request more than ${params.nodeCostLimit} nodes in a single document. Please split your operation into multiple sub operations or reduce the amount of requested nodes.`, documentNode));
+                }
+                (_a = params.reportNodeCost) === null || _a === void 0 ? void 0 : _a.call(params, totalNodeCost, executionArgs);
+            },
+        },
+    };
+};
+const useResourceLimitations = (params) => {
+    var _a, _b, _c, _d;
+    const paginationArgumentMaximum = (_a = params === null || params === void 0 ? void 0 : params.paginationArgumentMaximum) !== null && _a !== void 0 ? _a : defaultPaginationArgumentMaximum;
+    const paginationArgumentMinimum = (_b = params === null || params === void 0 ? void 0 : params.paginationArgumentMinimum) !== null && _b !== void 0 ? _b : defaultPaginationArgumentMinimum;
+    const nodeCostLimit = (_c = params === null || params === void 0 ? void 0 : params.nodeCostLimit) !== null && _c !== void 0 ? _c : defaultNodeCostLimit;
+    const extensions = (_d = params === null || params === void 0 ? void 0 : params.extensions) !== null && _d !== void 0 ? _d : false;
+    const nodeCostMap = new WeakMap();
+    const handleResult = ({ result, args }) => {
+        const nodeCost = nodeCostMap.get(args);
+        if (nodeCost != null) {
+            result.extensions = {
+                ...result.extensions,
+                resourceLimitations: {
+                    nodeCost,
+                },
+            };
+        }
+    };
+    return {
+        onPluginInit({ addPlugin }) {
+            addPlugin(useExtendedValidation({
+                rules: [
+                    ResourceLimitationValidationRule({
+                        nodeCostLimit,
+                        paginationArgumentMaximum,
+                        paginationArgumentMinimum,
+                        paginationArgumentTypes: params === null || params === void 0 ? void 0 : params.paginationArgumentScalars,
+                        reportNodeCost: extensions
+                            ? (nodeCost, ref) => {
+                                nodeCostMap.set(ref, nodeCost);
+                            }
+                            : undefined,
+                    }),
+                ],
+                onValidationFailed: params => handleResult(params),
+            }));
+        },
+        onExecute({ args }) {
+            return {
+                onExecuteDone(payload) {
+                    return handleStreamOrSingleExecutionResult(payload, ({ result }) => handleResult({ result, args }));
+                },
+            };
+        },
+    };
+};
+
+export { ResourceLimitationValidationRule, defaultNodeCostLimit, defaultPaginationArgumentMaximum, defaultPaginationArgumentMinimum, useResourceLimitations };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@envelop/resource-limitations",
+  "version": "0.2.0",
+  "description": "A rate-limit implementation based on resource limitations and static calculation of the score (similar to GitHub GraphQL API)",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^14.0.0 || ^15.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotansimha/envelop.git",
+    "directory": "packages/plugins/resource-limitations"
+  },
+  "author": "Laurin Quast <laurinquast@googlemail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    }
+  }
+}