@nxgt/graphql-validation 0.6.0 → 0.8.0

package/README.md

@@ -241,19 +241,24 @@ The codes, and `fieldsError`, are in
 A schema with list cycles (`Folder.items` returns items, `Item.folder` returns
 its folder) lets a client nest a query whose cost grows exponentially.
 `maxDepth` and `maxListCost` are graphql-js validation rules that refuse such a
-query before any resolver runs.
+query before any resolver runs; `maxFields` bounds the breadth they leave open
+(thousands of aliases of a cheap field).
 
 ```ts
-import { maxDepth, maxListCost } from '@nxgt/graphql-validation';
+import { maxDepth, maxFields, maxListCost } from '@nxgt/graphql-validation';
 import { parse, specifiedRules, validate } from 'graphql';
 
-const rules = [maxDepth({ depth: 8 }), maxListCost({ budget: 10_000, defaultFirst: 50 })];
+const rules = [
+  maxDepth({ depth: 8 }),
+  maxListCost({ budget: 10_000, defaultFirst: 50 }),
+  maxFields({ limit: 500 }),
+];
 const errors = validate(schema, parse(query), [...specifiedRules, ...rules]);
 ```
 
 ```ts
 // graphql-yoga
-import { maxDepth, maxListCost } from '@nxgt/graphql-validation';
+import { maxDepth, maxFields, maxListCost } from '@nxgt/graphql-validation';
 import { createYoga } from 'graphql-yoga';
 
 const yoga = createYoga({
@@ -263,6 +268,7 @@ const yoga = createYoga({
       onValidate: ({ addValidationRule }) => {
         addValidationRule(maxDepth({ depth: 8 }));
         addValidationRule(maxListCost({ budget: 10_000, defaultFirst: 50 }));
+        addValidationRule(maxFields({ limit: 500 }));
       },
     },
   ],
@@ -270,13 +276,30 @@ const yoga = createYoga({
 ```
 
 One `GraphQLError` per operation: `extensions: { code: 'QUERY_TOO_DEEP', depth,
-limit }` or `{ code: 'QUERY_TOO_COSTLY', cost, limit }`. A list field is sized by
-its `first`, `last` or `limit` argument; a variable, a negative number or no
-argument uses the argument's SDL default, else `defaultFirst`. A size is an
+limit }`, `{ code: 'QUERY_TOO_COSTLY', cost, limit }` or `{ code: 'QUERY_TOO_WIDE',
+fields, limit }`. `maxFields` counts every field selection in the document, aliases and
+`__typename` included, at each spread of a fragment. A list field is sized by
+its `first`, `last` or `limit` argument. An argument not given says its SDL
+default; with no argument and no default the size is `defaultFirst`. A variable
+or an unusable literal (a negative number) counts as the largest of that
+default (else `defaultFirst`), the argument's declared `@constraint(max)` or
+`exclusiveMax`, and `variableSize` where some definition declares no bound; the
+operation's own variable default is ignored. A code-first argument has no SDL
+node, so only `variableSize` applies to it. A size is an
 Int, a canonical-integer string or an integral Float; the largest of several
-size arguments wins. Introspection is
-counted too; add `ignoreIntrospection: true` where it is trusted (GraphiQL in
-development). See
+size arguments wins. On a Relay connection the `first` on the object field
+sizes the `edges` and `nodes` lists directly under it (not lists further down,
+nor lists declaring their own size argument):
+
+```graphql
+{ items(first: 100) { edges { node { id } } } }
+```
+
+Trap: any non-list field stating a size sizes the lists declaring none directly
+under it, so an argument that means something else (`limit`, say) and is named in
+`sizeArguments` now sizes them: leave it out of `sizeArguments`.
+Introspection is counted too; add `ignoreIntrospection: true` where it is
+trusted (GraphiQL in development). See
 [Limiting the depth and cost of a query](docs/guide/query-limits.md).
 
 ## IDE support
@@ -331,8 +354,9 @@ the directive declared is this package's. Both at once throw
 | `FieldIssue`, `FieldError`, `IssueParams`, `Translate`, `InvalidInputOptions`, `FieldsErrorOptions` | their types: an issue you write, a `fields` entry, its params, your translator, the options |
 | `ValidationIssue`, `ConstraintValue`, `BadUserInputExtensions` | the types of `extensions.issues`, of an issue's `value`, and of `extensions` |
 | `maxDepth({ depth, ignoreIntrospection? })` | a graphql-js validation rule refusing an operation nested deeper than `depth` fields, `extensions.code` `QUERY_TOO_DEEP`; introspection counts (the standard query is 15 levels) unless `ignoreIntrospection` |
-| `maxListCost({ budget, defaultFirst, sizeArguments?, ignoreIntrospection? })` | a graphql-js validation rule refusing an operation whose list-weighted cost is over `budget`, `extensions.code` `QUERY_TOO_COSTLY`; `sizeArguments` names the arguments sizing a list (default `first`, `last`, `limit`, the largest wins); `ignoreIntrospection` skips `__schema` and `__type` |
-| `MaxDepthOptions`, `MaxListCostOptions` | their options |
+| `maxListCost({ budget, defaultFirst, sizeArguments?, ignoreIntrospection?, variableSize? })` | a graphql-js validation rule refusing an operation whose list-weighted cost is over `budget`, `extensions.code` `QUERY_TOO_COSTLY`; `sizeArguments` names the arguments sizing a list (default `first`, `last`, `limit`, the largest wins); `ignoreIntrospection` skips `__schema` and `__type`; `variableSize` is the size assumed for any size argument (`first`, `last`, `limit`, custom `sizeArguments`) sent as a variable or an unusable literal; see [Variables](docs/guide/query-limits.md#variables) for how a declared bound and `variableSize` combine |
+| `maxFields({ limit, ignoreIntrospection? })` | a graphql-js validation rule refusing an operation that selects more than `limit` fields (aliases, `__typename` and every fragment spread counted, `@skip`/`@include` not evaluated), `extensions.code` `QUERY_TOO_WIDE`; introspection counts (the standard query selects 220 fields) unless `ignoreIntrospection` |
+| `MaxDepthOptions`, `MaxListCostOptions`, `MaxFieldsOptions` | their options |
 | `ConstraintArgument` | the type of `issues[].constraint`: `'minLength' \| 'format' \| ...` |
 | `ArgsSchema`, `ArgsSchemaFor`, `SchemaOf` | the types `validated` accepts: the schema or shape, and that or the function building it from the context |
 | `WithValidationOptions`, `FormatSchemas`, `OwnFormats`, `StringSchema`, `FormatName` | the types of `withValidation`'s options: a record of string schemas, with no built-in format name (`FormatName`) |

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export type { StringSchema } from './formats/format.js';
 export type { FormatSchemas, OwnFormats } from './formats/registry.js';
 export { type FieldError, type FieldIssue, type FieldsErrorOptions, fieldsError, INVALID_INPUT, type InvalidInputOptions, type IssueParams, inputPath, invalidInputError, type Translate, } from './invalid-input.js';
 export { type MaxDepthOptions, maxDepth } from './limits/max-depth.js';
+export { type MaxFieldsOptions, maxFields } from './limits/max-fields.js';
 export { type MaxListCostOptions, maxListCost } from './limits/max-list-cost.js';
 export type { ConstraintArgument } from './rules/index.js';
 export { type ArgsSchema, type ArgsSchemaFor, type SchemaOf, validated, } from './validated.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,sBAAsB,EAC3B,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,eAAe,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EACN,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,WAAW,EACX,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,SAAS,EACT,iBAAiB,EACjB,KAAK,SAAS,GACd,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,KAAK,kBAAkB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC9E,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EACN,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,SAAS,GACT,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,KAAK,qBAAqB,EAC1B,cAAc,GACd,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,sBAAsB,EAC3B,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,eAAe,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EACN,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,WAAW,EACX,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,SAAS,EACT,iBAAiB,EACjB,KAAK,SAAS,GACd,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,KAAK,kBAAkB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC9E,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EACN,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,SAAS,GACT,MAAM,aAAa,CAAC;AACrB,OAAO,EACN,KAAK,qBAAqB,EAC1B,cAAc,GACd,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -137,15 +137,42 @@ import {
 } from "graphql";
 
 // src/limits/describe.ts
+var CEILING = Number.MAX_SAFE_INTEGER;
+var add = (a, b) => Math.min(CEILING, a + b);
 function operationLabel(operation) {
   return operation.name ? `Operation "${operation.name.value}"` : "Operation";
 }
-function assertInteger(option, value, min, max = Number.MAX_SAFE_INTEGER) {
+function assertInteger(option, value, min, max = CEILING) {
   if (!Number.isInteger(value) || value < min || value >= max) {
     throw new RangeError(`${option} must be an integer from ${min} to ${max - 1}.`);
   }
 }
 
+// src/limits/fragments.ts
+var NO_KEY = -1;
+function newFragmentWalk(getFragment) {
+  return { getFragment, values: new Map, visiting: new Set };
+}
+function fragmentValue(walk, name, key, compute) {
+  let known = walk.values.get(name);
+  if (!known) {
+    known = new Map;
+    walk.values.set(name, known);
+  }
+  const at = typeof key === "number" ? key : key(known);
+  const memo = known.get(at);
+  if (memo !== undefined)
+    return memo;
+  const fragment = walk.getFragment(name);
+  if (!fragment || walk.visiting.has(name))
+    return 0;
+  walk.visiting.add(name);
+  const result = compute(fragment, at);
+  walk.visiting.delete(name);
+  known.set(at, result);
+  return result;
+}
+
 // src/limits/introspection.ts
 import {
   isEnumType,
@@ -230,26 +257,14 @@ function depthOf(depth, selectionSet) {
   return deepest;
 }
 function fragmentDepth(depth, name) {
-  const known = depth.fragmentDepths.get(name);
-  if (known !== undefined)
-    return known;
-  const fragment = depth.getFragment(name);
-  if (!fragment || depth.measuring.has(name))
-    return 0;
-  depth.measuring.add(name);
-  const result = depthOf(depth, fragment.selectionSet);
-  depth.measuring.delete(name);
-  depth.fragmentDepths.set(name, result);
-  return result;
+  return fragmentValue(depth, name, NO_KEY, (fragment) => depthOf(depth, fragment.selectionSet));
 }
 function maxDepth(options) {
   const limit = options.depth;
   assertInteger("maxDepth: depth", limit, 1);
   return (context) => {
     const walk = {
-      getFragment: (name) => context.getFragment(name),
-      fragmentDepths: new Map,
-      measuring: new Set,
+      ...newFragmentWalk((name) => context.getFragment(name)),
       ignoreIntrospection: options.ignoreIntrospection ?? false
     };
     return {
@@ -266,21 +281,94 @@ function maxDepth(options) {
     };
   };
 }
+// src/limits/max-fields.ts
+import {
+  GraphQLError as GraphQLError4
+} from "graphql";
+function countOf(walk, selectionSet) {
+  let total = 0;
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === "Field") {
+      if (walk.ignoreIntrospection && isIntrospectionRoot(selection.name.value))
+        continue;
+      total = add(total, 1);
+      if (selection.selectionSet)
+        total = add(total, countOf(walk, selection.selectionSet));
+    } else if (selection.kind === "InlineFragment") {
+      total = add(total, countOf(walk, selection.selectionSet));
+    } else {
+      total = add(total, fragmentCount(walk, selection.name.value));
+    }
+  }
+  return total;
+}
+function fragmentCount(walk, name) {
+  return fragmentValue(walk, name, NO_KEY, (fragment) => countOf(walk, fragment.selectionSet));
+}
+function maxFields(options) {
+  const limit = options.limit;
+  assertInteger("maxFields: limit", limit, 1);
+  return (context) => {
+    const walk = {
+      ...newFragmentWalk((name) => context.getFragment(name)),
+      ignoreIntrospection: options.ignoreIntrospection ?? false
+    };
+    return {
+      OperationDefinition(operation) {
+        const fields = countOf(walk, operation.selectionSet);
+        if (fields > limit) {
+          context.reportError(new GraphQLError4(`${operationLabel(operation)} selects ${fields} fields, more than the ${limit} allowed`, {
+            nodes: [operation],
+            extensions: { code: "QUERY_TOO_WIDE", fields, limit }
+          }));
+        }
+        return false;
+      }
+    };
+  };
+}
 // src/limits/max-list-cost.ts
 import {
-  GraphQLError as GraphQLError4,
+  GraphQLError as GraphQLError5,
   getNamedType,
   getNullableType,
+  isListType
+} from "graphql";
+
+// src/limits/cost-context.ts
+import {
   isInterfaceType as isInterfaceType2,
-  isListType,
   isObjectType as isObjectType2
 } from "graphql";
+var multiply = (a, b) => Math.min(CEILING, a * b);
+function fieldOf(cost, parent, name) {
+  if (parent === cost.schema.getQueryType() && isIntrospectionRoot(name)) {
+    return introspectionRoot(name);
+  }
+  return isObjectType2(parent) || isInterfaceType2(parent) ? parent.getFields()[name] : undefined;
+}
+function rootType(schema, operation) {
+  const type = operation.operation === "query" ? schema.getQueryType() : operation.operation === "mutation" ? schema.getMutationType() : schema.getSubscriptionType();
+  return type ?? undefined;
+}
+var EXACT_SIZES = 8;
+var NO_PENDING = NO_KEY;
+function memoSize(known, pending) {
+  if (pending === undefined || known.has(pending) || known.size < EXACT_SIZES) {
+    return pending;
+  }
+  let rounded = 2 ** Math.ceil(Math.log2(Math.max(pending, 1)));
+  if (rounded < pending)
+    rounded *= 2;
+  return Math.min(CEILING, rounded);
+}
 
 // src/limits/list-size.ts
 import {
   isAbstractType
 } from "graphql";
-var CEILING = Number.MAX_SAFE_INTEGER;
+
+// src/limits/size-reading.ts
 var CANONICAL_INTEGER = /^(0|[1-9]\d*)$/;
 function sizeOf(value) {
   if (typeof value === "string") {
@@ -318,6 +406,30 @@ function defaultSizeOf(argument) {
   }
   return;
 }
+function boundOf(value) {
+  if (value.kind === "StringValue")
+    return literalSize(value);
+  if (value.kind !== "IntValue" && value.kind !== "FloatValue")
+    return;
+  const number = Number(value.value);
+  return Number.isFinite(number) && number >= 0 ? Math.min(Math.ceil(number), CEILING) : undefined;
+}
+function constraintMaxOf(argument) {
+  const directive = argument?.astNode?.directives?.find((node) => node.name.value === "constraint");
+  let largest;
+  for (const node of directive?.arguments ?? []) {
+    if (node.name.value !== "max" && node.name.value !== "exclusiveMax") {
+      continue;
+    }
+    const bound = boundOf(node.value);
+    if (bound !== undefined && (largest === undefined || bound > largest)) {
+      largest = bound;
+    }
+  }
+  return largest;
+}
+
+// src/limits/list-size.ts
 var profiles = new WeakMap;
 function profileOf(cost, parent, definition) {
   let bySizes = profiles.get(cost.schema);
@@ -346,13 +458,25 @@ function profileOf(cost, parent, definition) {
     largest: cost.sizeArguments.map(() => {
       return;
     }),
+    maxima: cost.sizeArguments.map(() => {
+      return;
+    }),
+    someNoMax: cost.sizeArguments.map(() => false),
     someLack: cost.sizeArguments.map(() => false),
-    someBare: false
+    someBare: false,
+    declares: false,
+    someUndeclared: false
   };
   for (const field of definitions) {
     let any = false;
     cost.sizeArguments.forEach((name, index) => {
-      const size = defaultSizeOf(field.args.find((arg) => arg.name === name));
+      const argument = field.args.find((arg) => arg.name === name);
+      const max = constraintMaxOf(argument);
+      if (max === undefined)
+        profile.someNoMax[index] = true;
+      else
+        profile.maxima[index] = Math.max(profile.maxima[index] ?? 0, max);
+      const size = defaultSizeOf(argument);
       if (size === undefined) {
         profile.someLack[index] = true;
         return;
@@ -362,6 +486,11 @@ function profileOf(cost, parent, definition) {
     });
     if (!any)
       profile.someBare = true;
+    if (field.args.some((arg) => cost.sizeArguments.includes(arg.name))) {
+      profile.declares = true;
+    } else {
+      profile.someUndeclared = true;
+    }
   }
   byField.set(key, profile);
   return profile;
@@ -373,9 +502,18 @@ function argumentSize(cost, profile, index, node) {
   const literal = literalSize(node.value);
   if (literal !== undefined)
     return literal;
-  return profile.someLack[index] ? Math.max(largest ?? 0, cost.defaultFirst) : largest;
-}
-function listSize(cost, parent, definition, args) {
+  const today = profile.someLack[index] ? Math.max(largest ?? 0, cost.defaultFirst) : largest;
+  const bound = unusableBound(cost, profile, index);
+  return bound === undefined ? today : Math.max(today ?? 0, bound);
+}
+function unusableBound(cost, profile, index) {
+  const assumed = profile.someNoMax[index] ? cost.variableSize : undefined;
+  const declared = profile.maxima[index];
+  if (assumed === undefined)
+    return declared;
+  return Math.max(declared ?? 0, assumed);
+}
+function statedSize(cost, parent, definition, args) {
   const profile = profileOf(cost, parent, definition);
   let size;
   let given = false;
@@ -387,23 +525,50 @@ function listSize(cost, parent, definition, args) {
     if (said !== undefined)
       size = Math.max(size ?? 0, said);
   });
-  if (!given && profile.someBare)
-    size = Math.max(size ?? 0, cost.defaultFirst);
-  return size ?? cost.defaultFirst;
+  if (size !== undefined && !given && profile.someBare) {
+    return Math.max(size, cost.defaultFirst);
+  }
+  return size;
+}
+function declaration(cost, parent, definition) {
+  const { declares, someUndeclared } = profileOf(cost, parent, definition);
+  if (!declares)
+    return "none";
+  return someUndeclared ? "some" : "all";
 }
 
-// src/limits/max-list-cost.ts
+// src/limits/max-list-cost-options.ts
 var DEFAULT_SIZE_ARGUMENTS = ["first", "last", "limit"];
-var CEILING2 = Number.MAX_SAFE_INTEGER;
-var add = (a, b) => Math.min(CEILING2, a + b);
-var multiply = (a, b) => Math.min(CEILING2, a * b);
-function fieldOf(cost, parent, name) {
-  if (parent === cost.schema.getQueryType() && isIntrospectionRoot(name)) {
-    return introspectionRoot(name);
+
+// src/limits/pending-size.ts
+function listSizeUnder(cost, parent, definition, args, pending) {
+  const own = () => statedSize(cost, parent, definition, args) ?? cost.defaultFirst;
+  if (pending === undefined)
+    return own();
+  const declared = declaration(cost, parent, definition);
+  if (declared === "none")
+    return pending;
+  if (declared === "all")
+    return own();
+  return Math.max(pending, own());
+}
+
+// src/limits/max-list-cost.ts
+function fieldCost(cost, parent, selection, definition, pending) {
+  if (!selection.selectionSet)
+    return 1;
+  const name = selection.name.value;
+  const type = getNamedType(definition.type);
+  if (!isListType(getNullableType(definition.type))) {
+    const stated = statedSize(cost, parent, definition, selection.arguments);
+    const inner = costOf(cost, selection.selectionSet, type, stated);
+    return add(1, inner);
   }
-  return isObjectType2(parent) || isInterfaceType2(parent) ? parent.getFields()[name] : undefined;
+  const inner = costOf(cost, selection.selectionSet, type, undefined);
+  const size = parent?.name.startsWith("__") ? introspectionSize(cost.schema, name) : listSizeUnder(cost, parent, definition, selection.arguments, pending);
+  return add(1, multiply(inner, size));
 }
-function costOf(cost, selectionSet, parent) {
+function costOf(cost, selectionSet, parent, pending) {
   let total = 0;
   for (const selection of selectionSet.selections) {
     if (selection.kind === "Field") {
@@ -415,40 +580,19 @@ function costOf(cost, selectionSet, parent) {
       const definition = fieldOf(cost, parent, name);
       if (!definition)
         continue;
-      let inner = 0;
-      if (selection.selectionSet) {
-        inner = costOf(cost, selection.selectionSet, getNamedType(definition.type));
-        if (isListType(getNullableType(definition.type))) {
-          const size = parent?.name.startsWith("__") ? introspectionSize(cost.schema, name) : listSize(cost, parent, definition, selection.arguments);
-          inner = multiply(inner, size);
-        }
-      }
-      total = add(total, add(1, inner));
+      total = add(total, fieldCost(cost, parent, selection, definition, pending));
     } else if (selection.kind === "InlineFragment") {
       const condition = selection.typeCondition ? cost.schema.getType(selection.typeCondition.name.value) : parent;
-      total = add(total, costOf(cost, selection.selectionSet, condition));
+      total = add(total, costOf(cost, selection.selectionSet, condition, pending));
     } else {
-      total = add(total, fragmentCost(cost, selection.name.value));
+      total = add(total, fragmentCost(cost, selection.name.value, pending));
     }
   }
   return total;
 }
-function fragmentCost(cost, name) {
-  const known = cost.fragmentCosts.get(name);
-  if (known !== undefined)
-    return known;
-  const fragment = cost.getFragment(name);
-  if (!fragment || cost.costing.has(name))
-    return 0;
-  cost.costing.add(name);
-  const result = costOf(cost, fragment.selectionSet, cost.schema.getType(fragment.typeCondition.name.value));
-  cost.costing.delete(name);
-  cost.fragmentCosts.set(name, result);
-  return result;
-}
-function rootType(schema, operation) {
-  const type = operation.operation === "query" ? schema.getQueryType() : operation.operation === "mutation" ? schema.getMutationType() : schema.getSubscriptionType();
-  return type ?? undefined;
+function fragmentCost(cost, name, pending) {
+  const key = (known) => memoSize(known, pending) ?? NO_PENDING;
+  return fragmentValue(cost, name, key, (fragment, at) => costOf(cost, fragment.selectionSet, cost.schema.getType(fragment.typeCondition.name.value), at === NO_PENDING ? undefined : at));
 }
 function maxListCost(options) {
   const { budget, defaultFirst } = options;
@@ -457,22 +601,25 @@ function maxListCost(options) {
   ]);
   assertInteger("maxListCost: budget", budget, 0);
   assertInteger("maxListCost: defaultFirst", defaultFirst, 0);
+  const { variableSize } = options;
+  if (variableSize !== undefined) {
+    assertInteger("maxListCost: variableSize", variableSize, 0);
+  }
   return (context) => {
     const schema = context.getSchema();
     const cost = {
       schema,
       sizeArguments,
       defaultFirst,
+      variableSize,
       ignoreIntrospection: options.ignoreIntrospection ?? false,
-      getFragment: (name) => context.getFragment(name),
-      fragmentCosts: new Map,
-      costing: new Set
+      ...newFragmentWalk((name) => context.getFragment(name))
     };
     return {
       OperationDefinition(operation) {
-        const total = costOf(cost, operation.selectionSet, rootType(schema, operation));
+        const total = costOf(cost, operation.selectionSet, rootType(schema, operation), undefined);
         if (total > budget) {
-          context.reportError(new GraphQLError4(`${operationLabel(operation)} costs ${total}, more than the ${budget} allowed`, {
+          context.reportError(new GraphQLError5(`${operationLabel(operation)} costs ${total}, more than the ${budget} allowed`, {
             nodes: [operation],
             extensions: {
               code: "QUERY_TOO_COSTLY",
@@ -561,10 +708,11 @@ export {
   inputPath,
   invalidInputError,
   maxDepth,
+  maxFields,
   maxListCost,
   validated,
   withValidation
 };
 
-//# debugId=E43868C11AE8F6A464756E2164756E21
+//# debugId=B1856E23719B140164756E2164756E21
 //# sourceMappingURL=index.js.map