@envelop/resource-limitations 8.0.1-alpha-20260116142832-a2277336f0a5a4d64d168c98cf97b7513f70b9f7 → 8.1.0-alpha-20260120163327-6e77ec22fc62a09ba152ed764585743e1557eaf8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dotan Simha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cjs/index.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useResourceLimitations = exports.ResourceLimitationValidationRule = exports.defaultPaginationArgumentMinimum = exports.defaultPaginationArgumentMaximum = exports.defaultNodeCostLimit = void 0;
+const graphql_1 = require("graphql");
+const core_1 = require("@envelop/core");
+const extended_validation_1 = require("@envelop/extended-validation");
+const utils_1 = require("@graphql-tools/utils");
+const getWrappedType = (graphqlType) => {
+    if (graphqlType instanceof graphql_1.GraphQLList || graphqlType instanceof graphql_1.GraphQLNonNull) {
+        return getWrappedType(graphqlType.ofType);
+    }
+    return graphqlType;
+};
+const isValidArgType = (type, paginationArgumentTypes) => type === graphql_1.GraphQLInt ||
+    ((0, graphql_1.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}.`;
+exports.defaultNodeCostLimit = 500000;
+exports.defaultPaginationArgumentMaximum = 100;
+exports.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 = (0, utils_1.getArgumentValues)(fieldDef, fieldNode, executionArgs.variableValues || undefined);
+                    const type = getWrappedType(fieldDef.type);
+                    if (type instanceof graphql_1.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) ||
+                                (argumentValues.first === null && argumentValues.last === null)) {
+                                context.reportError(new graphql_1.GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                            else if ('first' in argumentValues && !argumentValues.last) {
+                                if (argumentValues.first < paginationArgumentMinimum ||
+                                    argumentValues.first > paginationArgumentMaximum) {
+                                    context.reportError(new graphql_1.GraphQLError(buildInvalidPaginationRangeErrorMessage({
+                                        paginationArgumentMaximum,
+                                        paginationArgumentMinimum,
+                                        argumentName: 'first',
+                                        fieldName: fieldDef.name,
+                                    }), fieldNode));
+                                }
+                                else {
+                                    // eslint-disable-next-line dot-notation
+                                    nodeCost = argumentValues['first'];
+                                }
+                            }
+                            else if (!argumentValues.first && 'last' in argumentValues) {
+                                if (argumentValues.last < paginationArgumentMinimum ||
+                                    argumentValues.last > paginationArgumentMaximum) {
+                                    context.reportError(new graphql_1.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_1.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) {
+                if (totalNodeCost === 0) {
+                    totalNodeCost = 1;
+                }
+                if (totalNodeCost > params.nodeCostLimit) {
+                    context.reportError(new graphql_1.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));
+                }
+                params.reportNodeCost?.(totalNodeCost, executionArgs);
+            },
+        },
+    };
+};
+exports.ResourceLimitationValidationRule = ResourceLimitationValidationRule;
+const useResourceLimitations = (params) => {
+    const paginationArgumentMaximum = params?.paginationArgumentMaximum ?? exports.defaultPaginationArgumentMaximum;
+    const paginationArgumentMinimum = params?.paginationArgumentMinimum ?? exports.defaultPaginationArgumentMinimum;
+    const nodeCostLimit = params?.nodeCostLimit ?? exports.defaultNodeCostLimit;
+    const extensions = params?.extensions ?? 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((0, extended_validation_1.useExtendedValidation)({
+                rules: [
+                    (0, exports.ResourceLimitationValidationRule)({
+                        nodeCostLimit,
+                        paginationArgumentMaximum,
+                        paginationArgumentMinimum,
+                        paginationArgumentTypes: params?.paginationArgumentScalars,
+                        reportNodeCost: extensions
+                            ? (nodeCost, ref) => {
+                                nodeCostMap.set(ref, nodeCost);
+                            }
+                            : undefined,
+                    }),
+                ],
+                onValidationFailed: params => handleResult(params),
+            }));
+        },
+        onExecute({ args }) {
+            return {
+                onExecuteDone(payload) {
+                    return (0, core_1.handleStreamOrSingleExecutionResult)(payload, ({ result }) => handleResult({ result, args }));
+                },
+            };
+        },
+    };
+};
+exports.useResourceLimitations = useResourceLimitations;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,181 @@
+import { GraphQLError, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, isScalarType, } from 'graphql';
+import { handleStreamOrSingleExecutionResult } from '@envelop/core';
+import { useExtendedValidation } from '@envelop/extended-validation';
+import { getArgumentValues } from '@graphql-tools/utils';
+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}.`;
+export const defaultNodeCostLimit = 500000;
+export const defaultPaginationArgumentMaximum = 100;
+export const defaultPaginationArgumentMinimum = 1;
+/**
+ * Validate whether a user is allowed to execute a certain GraphQL operation.
+ */
+export 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 || undefined);
+                    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) ||
+                                (argumentValues.first === null && argumentValues.last === null)) {
+                                context.reportError(new GraphQLError(buildMissingPaginationFieldErrorMessage({
+                                    fieldName: fieldDef.name,
+                                    hasFirst,
+                                    hasLast,
+                                }), fieldNode));
+                            }
+                            else if ('first' in argumentValues && !argumentValues.last) {
+                                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 (!argumentValues.first && 'last' in argumentValues) {
+                                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) {
+                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));
+                }
+                params.reportNodeCost?.(totalNodeCost, executionArgs);
+            },
+        },
+    };
+};
+export const useResourceLimitations = (params) => {
+    const paginationArgumentMaximum = params?.paginationArgumentMaximum ?? defaultPaginationArgumentMaximum;
+    const paginationArgumentMinimum = params?.paginationArgumentMinimum ?? defaultPaginationArgumentMinimum;
+    const nodeCostLimit = params?.nodeCostLimit ?? defaultNodeCostLimit;
+    const extensions = params?.extensions ?? 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?.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 }));
+                },
+            };
+        },
+    };
+};

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "@envelop/resource-limitations",
-  "version": "8.0.1-alpha-20260116142832-a2277336f0a5a4d64d168c98cf97b7513f70b9f7",
-  "type": "module",
+  "version": "8.1.0-alpha-20260120163327-6e77ec22fc62a09ba152ed764585743e1557eaf8",
   "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 || ^16.0.0",
+    "@envelop/core": "^5.5.0-alpha-20260120163327-6e77ec22fc62a09ba152ed764585743e1557eaf8"
+  },
+  "dependencies": {
+    "@graphql-tools/utils": "^11.0.0",
+    "tslib": "^2.5.0",
+    "@envelop/extended-validation": "^7.1.0-alpha-20260120163327-6e77ec22fc62a09ba152ed764585743e1557eaf8"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/graphql-hive/graphql-yoga",
+    "url": "https://github.com/graphql-hive/envelop.git",
     "directory": "packages/plugins/resource-limitations"
   },
   "author": "Laurin Quast <laurinquast@googlemail.com>",
@@ -13,71 +22,42 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "main": "dist/index.cjs",
-  "typings": "dist/index.d.mts",
-  "module": "dist/index.mjs",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
       },
       "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       },
       "default": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
       }
     },
     "./*": {
       "require": {
-        "types": "./dist/*.d.cts",
-        "default": "./dist/*.cjs"
+        "types": "./typings/*.d.cts",
+        "default": "./cjs/*.js"
       },
       "import": {
-        "types": "./dist/*.d.mts",
-        "default": "./dist/*.mjs"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       },
       "default": {
-        "types": "./dist/*.d.mts",
-        "default": "./dist/*.mjs"
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
       }
     },
     "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsdown",
-    "check": "tsc --pretty --noEmit"
-  },
-  "peerDependencies": {
-    "@envelop/core": "workspace:^",
-    "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "dependencies": {
-    "@envelop/extended-validation": "workspace:^",
-    "@graphql-tools/utils": "^10.0.0",
-    "tslib": "^2.5.0"
-  },
-  "devDependencies": {
-    "@envelop/core": "workspace:^",
-    "@graphql-tools/schema": "10.0.30",
-    "graphql": "16.12.0",
-    "tsdown": "^0.20.0-beta.1",
-    "typescript": "5.9.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "sideEffects": false,
-  "buildOptions": {
-    "input": "./src/index.ts"
-  },
-  "typescript": {
-    "definition": "dist/index.d.mts"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,45 @@
+import { ExecutionArgs } from 'graphql';
+import { Plugin } from '@envelop/core';
+import { ExtendedValidationRule } from '@envelop/extended-validation';
+export declare const defaultNodeCostLimit = 500000;
+export declare const defaultPaginationArgumentMaximum = 100;
+export declare const defaultPaginationArgumentMinimum = 1;
+export 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;
+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) => Plugin;
+export {};

package/typings/index.d.ts

@@ -0,0 +1,45 @@
+import { ExecutionArgs } from 'graphql';
+import { Plugin } from '@envelop/core';
+import { ExtendedValidationRule } from '@envelop/extended-validation';
+export declare const defaultNodeCostLimit = 500000;
+export declare const defaultPaginationArgumentMaximum = 100;
+export declare const defaultPaginationArgumentMinimum = 1;
+export 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;
+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) => Plugin;
+export {};

package/dist/index.cjs

@@ -1,134 +0,0 @@
-let graphql = require("graphql");
-let _envelop_core = require("@envelop/core");
-let _envelop_extended_validation = require("@envelop/extended-validation");
-let _graphql_tools_utils = require("@graphql-tools/utils");
-
-//#region src/index.ts
-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 || (0, 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 = 5e5;
-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 = /* @__PURE__ */ new WeakSet();
-	return {
-		Field: {
-			enter(fieldNode) {
-				const fieldDef = context.getFieldDef();
-				if (fieldDef != null) {
-					const argumentValues = (0, _graphql_tools_utils.getArgumentValues)(fieldDef, fieldNode, executionArgs.variableValues || void 0);
-					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) console.warn("Encountered paginated field without pagination arguments.");
-						else if (hasFirst === true || hasLast === true) if ("first" in argumentValues === false && "last" in argumentValues === false || argumentValues["first"] === null && argumentValues["last"] === null) context.reportError(new graphql.GraphQLError(buildMissingPaginationFieldErrorMessage({
-							fieldName: fieldDef.name,
-							hasFirst,
-							hasLast
-						}), fieldNode));
-						else if ("first" in argumentValues && !argumentValues["last"]) if (argumentValues["first"] < paginationArgumentMinimum || argumentValues["first"] > paginationArgumentMaximum) context.reportError(new graphql.GraphQLError(buildInvalidPaginationRangeErrorMessage({
-							paginationArgumentMaximum,
-							paginationArgumentMinimum,
-							argumentName: "first",
-							fieldName: fieldDef.name
-						}), fieldNode));
-						else nodeCost = argumentValues["first"];
-						else if (!argumentValues["first"] && "last" in argumentValues) if (argumentValues["last"] < paginationArgumentMinimum || argumentValues["last"] > paginationArgumentMaximum) context.reportError(new graphql.GraphQLError(buildInvalidPaginationRangeErrorMessage({
-							paginationArgumentMaximum,
-							paginationArgumentMinimum,
-							argumentName: "last",
-							fieldName: fieldDef.name
-						}), fieldNode));
-						else 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) {
-			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));
-			params.reportNodeCost?.(totalNodeCost, executionArgs);
-		} }
-	};
-};
-const useResourceLimitations = (params) => {
-	const paginationArgumentMaximum = params?.paginationArgumentMaximum ?? defaultPaginationArgumentMaximum;
-	const paginationArgumentMinimum = params?.paginationArgumentMinimum ?? defaultPaginationArgumentMinimum;
-	const nodeCostLimit = params?.nodeCostLimit ?? defaultNodeCostLimit;
-	const extensions = params?.extensions ?? false;
-	const nodeCostMap = /* @__PURE__ */ new WeakMap();
-	const handleResult = ({ result, args }) => {
-		const nodeCost = nodeCostMap.get(args);
-		if (nodeCost != null) result.extensions = {
-			...result.extensions,
-			resourceLimitations: { nodeCost }
-		};
-	};
-	return {
-		onPluginInit({ addPlugin }) {
-			addPlugin((0, _envelop_extended_validation.useExtendedValidation)({
-				rules: [ResourceLimitationValidationRule({
-					nodeCostLimit,
-					paginationArgumentMaximum,
-					paginationArgumentMinimum,
-					paginationArgumentTypes: params?.paginationArgumentScalars,
-					reportNodeCost: extensions ? (nodeCost, ref) => {
-						nodeCostMap.set(ref, nodeCost);
-					} : void 0
-				})],
-				onValidationFailed: (params$1) => handleResult(params$1)
-			}));
-		},
-		onExecute({ args }) {
-			return { onExecuteDone(payload) {
-				return (0, _envelop_core.handleStreamOrSingleExecutionResult)(payload, ({ result }) => handleResult({
-					result,
-					args
-				}));
-			} };
-		}
-	};
-};
-
-//#endregion
-exports.ResourceLimitationValidationRule = ResourceLimitationValidationRule;
-exports.defaultNodeCostLimit = defaultNodeCostLimit;
-exports.defaultPaginationArgumentMaximum = defaultPaginationArgumentMaximum;
-exports.defaultPaginationArgumentMinimum = defaultPaginationArgumentMinimum;
-exports.useResourceLimitations = useResourceLimitations;

package/dist/index.d.cts

@@ -1,48 +0,0 @@
-import { ExecutionArgs } from "graphql";
-import { Plugin } from "@envelop/core";
-import { ExtendedValidationRule } from "@envelop/extended-validation";
-
-//#region src/index.d.ts
-declare const defaultNodeCostLimit = 500000;
-declare const defaultPaginationArgumentMaximum = 100;
-declare const defaultPaginationArgumentMinimum = 1;
-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.
- */
-declare const ResourceLimitationValidationRule: (params: ResourceLimitationValidationRuleParams) => ExtendedValidationRule;
-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;
-};
-declare const useResourceLimitations: (params?: UseResourceLimitationsParams) => Plugin;
-//#endregion
-export { ResourceLimitationValidationRule, ResourceLimitationValidationRuleParams, defaultNodeCostLimit, defaultPaginationArgumentMaximum, defaultPaginationArgumentMinimum, useResourceLimitations };

package/dist/index.d.mts

@@ -1,48 +0,0 @@
-import { ExecutionArgs } from "graphql";
-import { Plugin } from "@envelop/core";
-import { ExtendedValidationRule } from "@envelop/extended-validation";
-
-//#region src/index.d.ts
-declare const defaultNodeCostLimit = 500000;
-declare const defaultPaginationArgumentMaximum = 100;
-declare const defaultPaginationArgumentMinimum = 1;
-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.
- */
-declare const ResourceLimitationValidationRule: (params: ResourceLimitationValidationRuleParams) => ExtendedValidationRule;
-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;
-};
-declare const useResourceLimitations: (params?: UseResourceLimitationsParams) => Plugin;
-//#endregion
-export { ResourceLimitationValidationRule, ResourceLimitationValidationRuleParams, defaultNodeCostLimit, defaultPaginationArgumentMaximum, defaultPaginationArgumentMinimum, useResourceLimitations };

package/dist/index.mjs

@@ -1,130 +0,0 @@
-import { GraphQLError, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, isScalarType } from "graphql";
-import { handleStreamOrSingleExecutionResult } from "@envelop/core";
-import { useExtendedValidation } from "@envelop/extended-validation";
-import { getArgumentValues } from "@graphql-tools/utils";
-
-//#region src/index.ts
-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 = 5e5;
-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 = /* @__PURE__ */ new WeakSet();
-	return {
-		Field: {
-			enter(fieldNode) {
-				const fieldDef = context.getFieldDef();
-				if (fieldDef != null) {
-					const argumentValues = getArgumentValues(fieldDef, fieldNode, executionArgs.variableValues || void 0);
-					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) console.warn("Encountered paginated field without pagination arguments.");
-						else if (hasFirst === true || hasLast === true) if ("first" in argumentValues === false && "last" in argumentValues === false || argumentValues["first"] === null && argumentValues["last"] === null) context.reportError(new GraphQLError(buildMissingPaginationFieldErrorMessage({
-							fieldName: fieldDef.name,
-							hasFirst,
-							hasLast
-						}), fieldNode));
-						else if ("first" in argumentValues && !argumentValues["last"]) if (argumentValues["first"] < paginationArgumentMinimum || argumentValues["first"] > paginationArgumentMaximum) context.reportError(new GraphQLError(buildInvalidPaginationRangeErrorMessage({
-							paginationArgumentMaximum,
-							paginationArgumentMinimum,
-							argumentName: "first",
-							fieldName: fieldDef.name
-						}), fieldNode));
-						else nodeCost = argumentValues["first"];
-						else if (!argumentValues["first"] && "last" in argumentValues) if (argumentValues["last"] < paginationArgumentMinimum || argumentValues["last"] > paginationArgumentMaximum) context.reportError(new GraphQLError(buildInvalidPaginationRangeErrorMessage({
-							paginationArgumentMaximum,
-							paginationArgumentMinimum,
-							argumentName: "last",
-							fieldName: fieldDef.name
-						}), fieldNode));
-						else 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) {
-			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));
-			params.reportNodeCost?.(totalNodeCost, executionArgs);
-		} }
-	};
-};
-const useResourceLimitations = (params) => {
-	const paginationArgumentMaximum = params?.paginationArgumentMaximum ?? defaultPaginationArgumentMaximum;
-	const paginationArgumentMinimum = params?.paginationArgumentMinimum ?? defaultPaginationArgumentMinimum;
-	const nodeCostLimit = params?.nodeCostLimit ?? defaultNodeCostLimit;
-	const extensions = params?.extensions ?? false;
-	const nodeCostMap = /* @__PURE__ */ 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?.paginationArgumentScalars,
-					reportNodeCost: extensions ? (nodeCost, ref) => {
-						nodeCostMap.set(ref, nodeCost);
-					} : void 0
-				})],
-				onValidationFailed: (params$1) => handleResult(params$1)
-			}));
-		},
-		onExecute({ args }) {
-			return { onExecuteDone(payload) {
-				return handleStreamOrSingleExecutionResult(payload, ({ result }) => handleResult({
-					result,
-					args
-				}));
-			} };
-		}
-	};
-};
-
-//#endregion
-export { ResourceLimitationValidationRule, defaultNodeCostLimit, defaultPaginationArgumentMaximum, defaultPaginationArgumentMinimum, useResourceLimitations };