@leaven-graphql/plugins 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,20 +1,49 @@
 // @bun
 // src/manager.ts
+var HOOK_NAMES = [
+  "beforeParse",
+  "afterParse",
+  "beforeValidate",
+  "afterValidate",
+  "beforeExecute",
+  "afterExecute",
+  "onError"
+];
+
 class PluginManager {
   schema;
   plugins;
   pluginOrder;
+  hookPlugins;
+  pendingOnRegister;
+  initPromise;
+  initialized;
   constructor(config) {
     this.schema = config.schema;
     this.plugins = new Map;
     this.pluginOrder = [];
+    this.hookPlugins = {
+      beforeParse: [],
+      afterParse: [],
+      beforeValidate: [],
+      afterValidate: [],
+      beforeExecute: [],
+      afterExecute: [],
+      onError: []
+    };
+    this.pendingOnRegister = [];
+    this.initPromise = undefined;
     if (config.plugins) {
       for (const plugin of config.plugins) {
-        this.register(plugin);
+        this.addPlugin(plugin);
+        if (plugin.onRegister) {
+          this.pendingOnRegister.push(plugin);
+        }
       }
     }
+    this.initialized = this.pendingOnRegister.length === 0;
   }
-  async register(plugin) {
+  addPlugin(plugin) {
     const { name } = plugin.metadata;
     if (this.plugins.has(name)) {
       throw new Error(`Plugin "${name}" is already registered`);
@@ -28,9 +57,77 @@ class PluginManager {
     }
     this.plugins.set(name, plugin);
     this.pluginOrder.push(name);
-    await plugin.onRegister?.(this.schema);
+    for (const hook of HOOK_NAMES) {
+      if (plugin[hook]) {
+        this.hookPlugins[hook].push(plugin);
+      }
+    }
+  }
+  async init() {
+    if (this.initialized) {
+      return;
+    }
+    const attempt = this.initPromise ??= this.runPendingOnRegister();
+    try {
+      await attempt;
+    } catch (error) {
+      if (this.initPromise === attempt) {
+        this.initPromise = undefined;
+      }
+      throw error;
+    }
+  }
+  async runPendingOnRegister() {
+    const pending = this.pendingOnRegister;
+    this.pendingOnRegister = [];
+    const registered = [];
+    for (const plugin of pending) {
+      try {
+        await plugin.onRegister?.(this.schema);
+      } catch (error) {
+        for (let i = registered.length - 1;i >= 0; i--) {
+          try {
+            await registered[i].onUnregister?.();
+          } catch {}
+        }
+        this.pendingOnRegister = pending;
+        throw new Error("Plugin initialization failed", { cause: error });
+      }
+      registered.push(plugin);
+    }
+    this.initialized = true;
+  }
+  removePlugin(plugin) {
+    const { name } = plugin.metadata;
+    this.plugins.delete(name);
+    const index = this.pluginOrder.indexOf(name);
+    if (index !== -1) {
+      this.pluginOrder.splice(index, 1);
+    }
+    for (const hook of HOOK_NAMES) {
+      const list = this.hookPlugins[hook];
+      const hookIndex = list.indexOf(plugin);
+      if (hookIndex !== -1) {
+        list.splice(hookIndex, 1);
+      }
+    }
+  }
+  async register(plugin) {
+    if (!this.initialized) {
+      await this.init();
+    }
+    this.addPlugin(plugin);
+    try {
+      await plugin.onRegister?.(this.schema);
+    } catch (error) {
+      this.removePlugin(plugin);
+      throw error;
+    }
   }
   async unregister(name) {
+    if (!this.initialized) {
+      await this.init();
+    }
     const plugin = this.plugins.get(name);
     if (!plugin) {
       return false;
@@ -41,11 +138,7 @@ class PluginManager {
       }
     }
     await plugin.onUnregister?.();
-    this.plugins.delete(name);
-    const index = this.pluginOrder.indexOf(name);
-    if (index !== -1) {
-      this.pluginOrder.splice(index, 1);
-    }
+    this.removePlugin(plugin);
     return true;
   }
   get(name) {
@@ -66,78 +159,82 @@ class PluginManager {
     };
   }
   async beforeParse(query, context) {
+    if (!this.initialized) {
+      await this.init();
+    }
     let result = query;
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.beforeParse) {
-        const modified = await plugin.beforeParse(result, context);
-        if (typeof modified === "string") {
-          result = modified;
-        }
+    for (const plugin of this.hookPlugins.beforeParse) {
+      const modified = await plugin.beforeParse(result, context);
+      if (typeof modified === "string") {
+        result = modified;
       }
     }
     return result;
   }
   async afterParse(document, context) {
+    if (!this.initialized) {
+      await this.init();
+    }
     let result = document;
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.afterParse) {
-        const modified = await plugin.afterParse(result, context);
-        if (modified) {
-          result = modified;
-        }
+    for (const plugin of this.hookPlugins.afterParse) {
+      const modified = await plugin.afterParse(result, context);
+      if (modified) {
+        result = modified;
       }
     }
     return result;
   }
   async beforeValidate(document, context) {
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.beforeValidate) {
-        await plugin.beforeValidate(document, context);
-      }
+    if (!this.initialized) {
+      await this.init();
+    }
+    for (const plugin of this.hookPlugins.beforeValidate) {
+      await plugin.beforeValidate(document, context);
     }
   }
   async afterValidate(result, context) {
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.afterValidate) {
-        await plugin.afterValidate(result, context);
-      }
+    if (!this.initialized) {
+      await this.init();
+    }
+    for (const plugin of this.hookPlugins.afterValidate) {
+      await plugin.afterValidate(result, context);
     }
   }
   async beforeExecute(document, context) {
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.beforeExecute) {
-        await plugin.beforeExecute(document, context);
+    if (!this.initialized) {
+      await this.init();
+    }
+    for (const plugin of this.hookPlugins.beforeExecute) {
+      const response = await plugin.beforeExecute(document, context);
+      if (response) {
+        return response;
       }
     }
+    return;
   }
   async afterExecute(response, context) {
+    if (!this.initialized) {
+      await this.init();
+    }
     let result = response;
-    for (let i = this.pluginOrder.length - 1;i >= 0; i--) {
-      const name = this.pluginOrder[i];
-      const plugin = this.plugins.get(name);
-      if (plugin.afterExecute) {
-        const modified = await plugin.afterExecute(result, context);
-        if (modified) {
-          result = modified;
-        }
+    const list = this.hookPlugins.afterExecute;
+    for (let i = list.length - 1;i >= 0; i--) {
+      const modified = await list[i].afterExecute(result, context);
+      if (modified) {
+        result = modified;
       }
     }
     return result;
   }
   async onError(error, context) {
+    if (!this.initialized) {
+      await this.init();
+    }
     let result = error;
-    for (const name of this.pluginOrder) {
-      const plugin = this.plugins.get(name);
-      if (plugin.onError) {
-        const modified = await plugin.onError(result, context);
-        if (modified instanceof Error) {
-          result = modified;
-        }
+    for (const plugin of this.hookPlugins.onError) {
+      const modified = await plugin.onError(result, context);
+      if (modified instanceof Error) {
+        result = modified;
       }
     }
     return result;
@@ -154,59 +251,9 @@ class PluginManager {
 function createPluginManager(config) {
   return new PluginManager(config);
 }
-// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/language/kinds.mjs
-var Kind;
-(function(Kind2) {
-  Kind2["NAME"] = "Name";
-  Kind2["DOCUMENT"] = "Document";
-  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
-  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
-  Kind2["SELECTION_SET"] = "SelectionSet";
-  Kind2["FIELD"] = "Field";
-  Kind2["ARGUMENT"] = "Argument";
-  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
-  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
-  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
-  Kind2["VARIABLE"] = "Variable";
-  Kind2["INT"] = "IntValue";
-  Kind2["FLOAT"] = "FloatValue";
-  Kind2["STRING"] = "StringValue";
-  Kind2["BOOLEAN"] = "BooleanValue";
-  Kind2["NULL"] = "NullValue";
-  Kind2["ENUM"] = "EnumValue";
-  Kind2["LIST"] = "ListValue";
-  Kind2["OBJECT"] = "ObjectValue";
-  Kind2["OBJECT_FIELD"] = "ObjectField";
-  Kind2["DIRECTIVE"] = "Directive";
-  Kind2["NAMED_TYPE"] = "NamedType";
-  Kind2["LIST_TYPE"] = "ListType";
-  Kind2["NON_NULL_TYPE"] = "NonNullType";
-  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
-  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
-  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
-  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
-  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
-  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
-  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
-  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
-  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
-  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
-  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
-  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
-  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
-  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
-  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
-  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
-  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
-  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
-  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
-  Kind2["TYPE_COORDINATE"] = "TypeCoordinate";
-  Kind2["MEMBER_COORDINATE"] = "MemberCoordinate";
-  Kind2["ARGUMENT_COORDINATE"] = "ArgumentCoordinate";
-  Kind2["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
-  Kind2["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
-})(Kind || (Kind = {}));
 // src/builtin.ts
+import { Kind } from "graphql";
+import { ComplexityError, DepthLimitError } from "@leaven-graphql/errors";
 function createPlugin(metadata, hooks) {
   return {
     metadata,
@@ -214,21 +261,8 @@ function createPlugin(metadata, hooks) {
   };
 }
 function composePlugins(name, ...plugins) {
-  return {
-    metadata: {
-      name,
-      description: `Composed plugin from: ${plugins.map((p) => p.metadata.name).join(", ")}`
-    },
-    async onRegister(schema) {
-      for (const plugin of plugins) {
-        await plugin.onRegister?.(schema);
-      }
-    },
-    async onUnregister() {
-      for (const plugin of plugins) {
-        await plugin.onUnregister?.();
-      }
-    },
+  const reversed = [...plugins].reverse();
+  const hooks = {
     async beforeParse(query, context) {
       let result = query;
       for (const plugin of plugins) {
@@ -253,14 +287,28 @@ function composePlugins(name, ...plugins) {
       }
       return result;
     },
+    async beforeValidate(document, context) {
+      for (const plugin of plugins) {
+        await plugin.beforeValidate?.(document, context);
+      }
+    },
+    async afterValidate(result, context) {
+      for (const plugin of plugins) {
+        await plugin.afterValidate?.(result, context);
+      }
+    },
     async beforeExecute(document, context) {
       for (const plugin of plugins) {
-        await plugin.beforeExecute?.(document, context);
+        const response = await plugin.beforeExecute?.(document, context);
+        if (response) {
+          return response;
+        }
       }
+      return;
     },
     async afterExecute(response, context) {
       let result = response;
-      for (const plugin of plugins.slice().reverse()) {
+      for (const plugin of reversed) {
         if (plugin.afterExecute) {
           const modified = await plugin.afterExecute(result, context);
           if (modified) {
@@ -283,27 +331,59 @@ function composePlugins(name, ...plugins) {
       return result;
     }
   };
+  return {
+    metadata: {
+      name,
+      description: `Composed plugin from: ${plugins.map((p) => p.metadata.name).join(", ")}`
+    },
+    async onRegister(schema) {
+      for (const plugin of plugins) {
+        await plugin.onRegister?.(schema);
+      }
+    },
+    async onUnregister() {
+      for (const plugin of plugins) {
+        await plugin.onUnregister?.();
+      }
+    },
+    ...hooks
+  };
 }
 function createCachingPlugin(options) {
   const cache = new Map;
   const maxSize = options?.maxSize ?? 100;
   const ttl = options?.ttl ?? 60000;
+  const keyFn = options?.keyFn;
+  if (!keyFn && options?.allowSharedCache !== true) {
+    throw new TypeError("createCachingPlugin requires an explicit cache-identity decision: pass a " + "`keyFn` that incorporates the caller identity (recommended), or set " + "`allowSharedCache: true` to serve one cached response to every caller. " + "A cache hit skips execution, so without caller identity in the key one " + "user can receive another user's response.");
+  }
+  const makeKey = (context) => keyFn ? keyFn(context) : JSON.stringify({
+    query: context.request.query,
+    operationName: context.request.operationName ?? null,
+    variables: context.request.variables ?? null
+  });
   return {
     metadata: {
       name: "caching",
       version: "1.0.0",
-      description: "Caches query results"
+      description: "Caches successful query responses and serves them on subsequent requests"
     },
-    async beforeExecute(document, context) {
-      const key = JSON.stringify({
-        query: context.request.query,
-        variables: context.request.variables
-      });
+    async beforeExecute(_document, context) {
+      const key = makeKey(context);
+      context.state.set("cacheKey", key);
       const cached = cache.get(key);
-      if (cached && cached.expires > Date.now()) {
-        context.state.set("cacheHit", true);
-        context.state.set("cachedResponse", cached.data);
+      if (!cached) {
+        return;
+      }
+      if (cached.expires <= Date.now()) {
+        cache.delete(key);
+        return;
       }
+      cache.delete(key);
+      cache.set(key, cached);
+      context.state.set("cacheHit", true);
+      context.state.set("cachedResponse", cached.data);
+      return cached.data;
     },
     async afterExecute(response, context) {
       if (context.state.get("cacheHit")) {
@@ -312,30 +392,28 @@ function createCachingPlugin(options) {
       if (response.errors && response.errors.length > 0) {
         return response;
       }
-      const key = JSON.stringify({
-        query: context.request.query,
-        variables: context.request.variables
-      });
-      if (cache.size >= maxSize) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey)
-          cache.delete(firstKey);
+      const key = context.state.get("cacheKey") ?? makeKey(context);
+      const now = Date.now();
+      while (!cache.has(key) && cache.size >= maxSize) {
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey === undefined)
+          break;
+        cache.delete(oldestKey);
       }
       cache.set(key, {
         data: response,
-        expires: Date.now() + ttl
+        expires: now + ttl
       });
       return response;
     }
   };
 }
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
 function createLoggingPlugin(options) {
   const logger = options?.logger ?? console;
   const level = options?.level ?? "info";
-  const shouldLog = (msgLevel) => {
-    const levels = ["debug", "info", "warn", "error"];
-    return levels.indexOf(msgLevel) >= levels.indexOf(level);
-  };
+  const threshold = LOG_LEVELS[level];
+  const shouldLog = (msgLevel) => LOG_LEVELS[msgLevel] >= threshold;
   return {
     metadata: {
       name: "logging",
@@ -384,119 +462,297 @@ function createLoggingPlugin(options) {
   };
 }
 function createTracingPlugin() {
+  const TRACE_KEY = "tracing";
+  const ensureTrace = (context) => {
+    let trace = context.state.get(TRACE_KEY);
+    if (!trace) {
+      trace = {
+        startTime: new Date().toISOString(),
+        startNs: Bun.nanoseconds()
+      };
+      context.state.set(TRACE_KEY, trace);
+    }
+    return trace;
+  };
   return {
     metadata: {
       name: "tracing",
       version: "1.0.0",
       description: "Adds tracing information to responses"
     },
-    async beforeExecute(document, context) {
-      context.state.set("tracing", {
-        version: 1,
-        startTime: new Date().toISOString(),
-        startHrTime: process.hrtime.bigint(),
-        parsing: { startOffset: 0, duration: 0 },
-        validation: { startOffset: 0, duration: 0 },
-        execution: { startOffset: 0, duration: 0 }
-      });
+    async beforeParse(_query, context) {
+      const trace = ensureTrace(context);
+      trace.parsingStartNs = Bun.nanoseconds();
+    },
+    async afterParse(document, context) {
+      const trace = ensureTrace(context);
+      if (trace.parsingStartNs !== undefined) {
+        trace.parsing = {
+          startOffset: trace.parsingStartNs - trace.startNs,
+          duration: Bun.nanoseconds() - trace.parsingStartNs
+        };
+      }
+      return document;
+    },
+    async beforeValidate(_document, context) {
+      const trace = ensureTrace(context);
+      trace.validationStartNs = Bun.nanoseconds();
+    },
+    async afterValidate(_result, context) {
+      const trace = ensureTrace(context);
+      if (trace.validationStartNs !== undefined) {
+        trace.validation = {
+          startOffset: trace.validationStartNs - trace.startNs,
+          duration: Bun.nanoseconds() - trace.validationStartNs
+        };
+      }
+    },
+    async beforeExecute(_document, context) {
+      const trace = ensureTrace(context);
+      trace.executionStartNs = Bun.nanoseconds();
     },
     async afterExecute(response, context) {
-      const tracing = context.state.get("tracing");
-      if (!tracing)
+      const trace = context.state.get(TRACE_KEY);
+      if (!trace)
         return response;
-      const endHrTime = process.hrtime.bigint();
-      const duration = Number(endHrTime - tracing.startHrTime);
+      const endNs = Bun.nanoseconds();
+      const duration = endNs - trace.startNs;
+      const tracing = {
+        version: 1,
+        startTime: trace.startTime,
+        endTime: new Date().toISOString(),
+        duration
+      };
+      if (trace.parsing) {
+        tracing["parsing"] = trace.parsing;
+      }
+      if (trace.validation) {
+        tracing["validation"] = trace.validation;
+      }
+      if (trace.executionStartNs !== undefined) {
+        tracing["execution"] = {
+          startOffset: trace.executionStartNs - trace.startNs,
+          duration: endNs - trace.executionStartNs
+        };
+      }
       return {
         ...response,
         extensions: {
           ...response.extensions,
-          tracing: {
-            version: tracing.version,
-            startTime: tracing.startTime,
-            endTime: new Date().toISOString(),
-            duration,
-            parsing: tracing.parsing,
-            validation: tracing.validation,
-            execution: {
-              ...tracing.execution,
-              duration
-            }
-          }
+          tracing
         }
       };
     }
   };
 }
-function createDepthLimitPlugin(maxDepth) {
-  function calculateDepth(node, currentDepth = 0) {
-    if (!node || typeof node !== "object")
+var MAX_WALKER_VISITS = 1e5;
+function collectFragments(definitions) {
+  const fragments = new Map;
+  for (const definition of definitions) {
+    const typed = definition;
+    if (typed.kind === Kind.FRAGMENT_DEFINITION && typed.name) {
+      fragments.set(typed.name.value, definition);
+    }
+  }
+  return fragments;
+}
+function fragmentDepthContribution(walker, name) {
+  const memoized = walker.fragmentDepths.get(name);
+  if (memoized !== undefined) {
+    return memoized;
+  }
+  const fragment = walker.fragments.get(name);
+  if (!fragment || walker.inProgress.has(name)) {
+    return 0;
+  }
+  walker.inProgress.add(name);
+  const contribution = walkDepth(walker, fragment, 0);
+  walker.inProgress.delete(name);
+  walker.fragmentDepths.set(name, contribution);
+  return contribution;
+}
+function walkDepth(walker, node, currentDepth) {
+  if (!node || typeof node !== "object")
+    return currentDepth;
+  if (++walker.budget.visits > MAX_WALKER_VISITS) {
+    throw new DepthLimitError(walker.limit + 1, walker.limit, {
+      extensions: {
+        reason: "ANALYSIS_BUDGET_EXCEEDED",
+        maxNodesVisited: MAX_WALKER_VISITS
+      }
+    });
+  }
+  const typedNode = node;
+  if (typedNode.kind === Kind.FRAGMENT_SPREAD) {
+    const fragmentName = typedNode.name?.value;
+    if (fragmentName === undefined) {
       return currentDepth;
-    const typedNode = node;
-    let maxFoundDepth = currentDepth;
-    if (typedNode.kind === Kind.FIELD) {
-      maxFoundDepth = currentDepth + 1;
-    }
-    if (typedNode.selectionSet) {
-      for (const selection of typedNode.selectionSet.selections) {
-        const depth = calculateDepth(selection, maxFoundDepth);
-        if (depth > maxFoundDepth) {
-          maxFoundDepth = depth;
-        }
+    }
+    return currentDepth + fragmentDepthContribution(walker, fragmentName);
+  }
+  const childDepth = typedNode.kind === Kind.FIELD ? currentDepth + 1 : currentDepth;
+  let maxFoundDepth = childDepth;
+  if (typedNode.selectionSet) {
+    for (const selection of typedNode.selectionSet.selections) {
+      const depth = walkDepth(walker, selection, childDepth);
+      if (depth > maxFoundDepth) {
+        maxFoundDepth = depth;
       }
     }
-    return maxFoundDepth;
+  }
+  return maxFoundDepth;
+}
+function createDepthLimitPlugin(maxDepth) {
+  const limit = typeof maxDepth === "number" ? maxDepth : maxDepth?.maxDepth;
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    throw new TypeError(`createDepthLimitPlugin requires a finite numeric maxDepth; received ${JSON.stringify(maxDepth)}. ` + "Pass a number or an object of the form { maxDepth: number }.");
   }
   return {
     metadata: {
       name: "depth-limit",
       version: "1.0.0",
-      description: `Limits query depth to ${maxDepth}`
+      description: `Limits query depth to ${limit}`
     },
     async afterParse(document, _context) {
+      const walker = {
+        fragments: collectFragments(document.definitions),
+        fragmentDepths: new Map,
+        inProgress: new Set,
+        budget: { visits: 0 },
+        limit
+      };
       let depth = 0;
       for (const definition of document.definitions) {
         if (definition.kind === Kind.OPERATION_DEFINITION) {
-          const opDepth = calculateDepth(definition, 0);
+          const opDepth = walkDepth(walker, definition, 0);
           if (opDepth > depth) {
             depth = opDepth;
           }
         }
       }
-      if (depth > maxDepth) {
-        throw new Error(`Query depth of ${depth} exceeds maximum allowed depth of ${maxDepth}`);
+      if (depth > limit) {
+        throw new DepthLimitError(depth, limit);
       }
       return document;
     }
   };
 }
-function createComplexityPlugin(options) {
-  const { maxComplexity, defaultComplexity = 1 } = options;
-  function calculateComplexity(node, depth = 0) {
-    if (!node || typeof node !== "object")
-      return 0;
-    const typedNode = node;
-    let complexity = 0;
-    if (typedNode.kind === Kind.FIELD) {
-      let multiplier = 1;
-      if (typedNode.arguments) {
-        for (const arg of typedNode.arguments) {
-          if (arg.name.value === "first" || arg.name.value === "last" || arg.name.value === "limit") {
-            const value = parseInt(arg.value.value ?? "10", 10);
-            if (!isNaN(value)) {
-              multiplier = value;
-            }
-          }
+var LIST_SIZE_ARGUMENTS = new Set(["first", "last", "limit"]);
+var NO_VARIABLE_DEFAULTS = new Map;
+function toPositiveMultiplier(raw) {
+  const numeric = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : Number.NaN;
+  return Number.isFinite(numeric) && numeric > 0 ? numeric : undefined;
+}
+function collectVariableDefaults(operation) {
+  const definitions = operation.variableDefinitions;
+  if (!definitions || definitions.length === 0) {
+    return NO_VARIABLE_DEFAULTS;
+  }
+  const defaults = new Map;
+  for (const definition of definitions) {
+    const name = definition.variable?.name?.value;
+    const defaultValue = definition.defaultValue;
+    if (name === undefined || !defaultValue)
+      continue;
+    if (defaultValue.kind !== Kind.INT && defaultValue.kind !== Kind.FLOAT) {
+      continue;
+    }
+    const numeric = toPositiveMultiplier(defaultValue.value);
+    if (numeric !== undefined) {
+      defaults.set(name, numeric);
+    }
+  }
+  return defaults;
+}
+function resolveListSizeMultiplier(walker, value) {
+  if (value.kind === Kind.INT || value.kind === Kind.FLOAT) {
+    return toPositiveMultiplier(value.value);
+  }
+  if (value.kind === Kind.VARIABLE) {
+    const name = value.name?.value;
+    if (name !== undefined) {
+      const supplied = walker.variables?.[name];
+      if (supplied !== undefined) {
+        const fromRequest = toPositiveMultiplier(supplied);
+        if (fromRequest !== undefined) {
+          return fromRequest;
         }
       }
-      complexity = defaultComplexity * multiplier;
+      const declaredDefault = walker.variableDefaults.get(name);
+      if (declaredDefault !== undefined) {
+        return declaredDefault;
+      }
+    }
+    return walker.unknownMultiplier;
+  }
+  return;
+}
+function fragmentComplexityContribution(walker, name) {
+  const memoized = walker.fragmentComplexities.get(name);
+  if (memoized !== undefined) {
+    return memoized;
+  }
+  const fragment = walker.fragments.get(name);
+  if (!fragment || walker.inProgress.has(name)) {
+    return 0;
+  }
+  walker.inProgress.add(name);
+  const contribution = walkComplexity(walker, fragment);
+  walker.inProgress.delete(name);
+  walker.fragmentComplexities.set(name, contribution);
+  return contribution;
+}
+function walkComplexity(walker, node) {
+  if (!node || typeof node !== "object")
+    return 0;
+  if (++walker.budget.visits > MAX_WALKER_VISITS) {
+    throw new ComplexityError(walker.maxComplexity + 1, walker.maxComplexity, {
+      extensions: {
+        reason: "ANALYSIS_BUDGET_EXCEEDED",
+        maxNodesVisited: MAX_WALKER_VISITS
+      }
+    });
+  }
+  const typedNode = node;
+  if (typedNode.kind === Kind.FRAGMENT_SPREAD) {
+    const fragmentName = typedNode.name?.value;
+    if (fragmentName === undefined) {
+      return 0;
+    }
+    return fragmentComplexityContribution(walker, fragmentName);
+  }
+  let childComplexity = 0;
+  if (typedNode.selectionSet) {
+    for (const selection of typedNode.selectionSet.selections) {
+      childComplexity += walkComplexity(walker, selection);
+    }
+  }
+  if (typedNode.kind === Kind.FIELD) {
+    if (walker.calculator) {
+      return walker.calculator(node, childComplexity);
     }
-    if (typedNode.selectionSet) {
-      for (const selection of typedNode.selectionSet.selections) {
-        complexity += calculateComplexity(selection, depth + 1);
+    let multiplier = 1;
+    if (typedNode.arguments) {
+      for (const arg of typedNode.arguments) {
+        if (!LIST_SIZE_ARGUMENTS.has(arg.name.value))
+          continue;
+        const resolved = resolveListSizeMultiplier(walker, arg.value);
+        if (resolved !== undefined) {
+          multiplier = resolved;
+        }
       }
     }
-    return complexity;
+    return (walker.defaultComplexity + childComplexity) * multiplier;
   }
+  return childComplexity;
+}
+function createComplexityPlugin(options) {
+  const {
+    maxComplexity,
+    defaultComplexity = 1,
+    unknownMultiplier = 100,
+    calculator
+  } = options;
   return {
     metadata: {
       name: "complexity",
@@ -504,28 +760,42 @@ function createComplexityPlugin(options) {
       description: `Limits query complexity to ${maxComplexity}`
     },
     async afterParse(document, context) {
+      const fragments = collectFragments(document.definitions);
+      const budget = { visits: 0 };
       let totalComplexity = 0;
       for (const definition of document.definitions) {
         if (definition.kind === Kind.OPERATION_DEFINITION) {
-          totalComplexity += calculateComplexity(definition, 0);
+          const walker = {
+            fragments,
+            fragmentComplexities: new Map,
+            inProgress: new Set,
+            budget,
+            maxComplexity,
+            defaultComplexity,
+            calculator,
+            variables: context.request.variables,
+            variableDefaults: collectVariableDefaults(definition),
+            unknownMultiplier
+          };
+          totalComplexity += walkComplexity(walker, definition);
         }
       }
       context.state.set("complexity", totalComplexity);
       if (totalComplexity > maxComplexity) {
-        throw new Error(`Query complexity of ${totalComplexity} exceeds maximum allowed complexity of ${maxComplexity}`);
+        throw new ComplexityError(totalComplexity, maxComplexity);
       }
       return document;
     }
   };
 }
 export {
-  createTracingPlugin,
-  createPluginManager,
-  createPlugin,
-  createLoggingPlugin,
-  createDepthLimitPlugin,
-  createComplexityPlugin,
-  createCachingPlugin,
+  PluginManager,
   composePlugins,
-  PluginManager
+  createCachingPlugin,
+  createComplexityPlugin,
+  createDepthLimitPlugin,
+  createLoggingPlugin,
+  createPlugin,
+  createPluginManager,
+  createTracingPlugin
 };