@leaven-graphql/plugins 0.1.0 → 0.2.0

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,6 +251,77 @@ class PluginManager {
 function createPluginManager(config) {
   return new PluginManager(config);
 }
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/jsutils/invariant.mjs
+function invariant(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : "Unexpected invariant triggered.");
+  }
+}
+
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/language/location.mjs
+var LineRegExp = /\r\n|[\n\r]/g;
+function getLocation(source, position) {
+  let lastLineStart = 0;
+  let line = 1;
+  for (const match of source.body.matchAll(LineRegExp)) {
+    typeof match.index === "number" || invariant(false);
+    if (match.index >= position) {
+      break;
+    }
+    lastLineStart = match.index + match[0].length;
+    line += 1;
+  }
+  return {
+    line,
+    column: position + 1 - lastLineStart
+  };
+}
+
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/language/printLocation.mjs
+function printLocation(location) {
+  return printSourceLocation(location.source, getLocation(location.source, location.start));
+}
+function printSourceLocation(source, sourceLocation) {
+  const firstLineColumnOffset = source.locationOffset.column - 1;
+  const body = "".padStart(firstLineColumnOffset) + source.body;
+  const lineIndex = sourceLocation.line - 1;
+  const lineOffset = source.locationOffset.line - 1;
+  const lineNum = sourceLocation.line + lineOffset;
+  const columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
+  const columnNum = sourceLocation.column + columnOffset;
+  const locationStr = `${source.name}:${lineNum}:${columnNum}
+`;
+  const lines = body.split(/\r\n|[\n\r]/g);
+  const locationLine = lines[lineIndex];
+  if (locationLine.length > 120) {
+    const subLineIndex = Math.floor(columnNum / 80);
+    const subLineColumnNum = columnNum % 80;
+    const subLines = [];
+    for (let i = 0;i < locationLine.length; i += 80) {
+      subLines.push(locationLine.slice(i, i + 80));
+    }
+    return locationStr + printPrefixedLines([
+      [`${lineNum} |`, subLines[0]],
+      ...subLines.slice(1, subLineIndex + 1).map((subLine) => ["|", subLine]),
+      ["|", "^".padStart(subLineColumnNum)],
+      ["|", subLines[subLineIndex + 1]]
+    ]);
+  }
+  return locationStr + printPrefixedLines([
+    [`${lineNum - 1} |`, lines[lineIndex - 1]],
+    [`${lineNum} |`, locationLine],
+    ["|", "^".padStart(columnNum)],
+    [`${lineNum + 1} |`, lines[lineIndex + 1]]
+  ]);
+}
+function printPrefixedLines(lines) {
+  const existingLines = lines.filter(([_, line]) => line !== undefined);
+  const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+  return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join(`
+`);
+}
+
 // ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/language/kinds.mjs
 var Kind;
 (function(Kind2) {
@@ -206,6 +374,276 @@ var Kind;
   Kind2["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
   Kind2["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
 })(Kind || (Kind = {}));
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/jsutils/isObjectLike.mjs
+function isObjectLike(value) {
+  return typeof value == "object" && value !== null;
+}
+
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/error/GraphQLError.mjs
+function toNormalizedOptions(args) {
+  const firstArg = args[0];
+  if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
+    return {
+      nodes: firstArg,
+      source: args[1],
+      positions: args[2],
+      path: args[3],
+      originalError: args[4],
+      extensions: args[5]
+    };
+  }
+  return firstArg;
+}
+
+class GraphQLError extends Error {
+  constructor(message, ...rawArgs) {
+    var _this$nodes, _nodeLocations$, _ref;
+    const { nodes, source, positions, path, originalError, extensions } = toNormalizedOptions(rawArgs);
+    super(message);
+    this.name = "GraphQLError";
+    this.path = path !== null && path !== undefined ? path : undefined;
+    this.originalError = originalError !== null && originalError !== undefined ? originalError : undefined;
+    this.nodes = undefinedIfEmpty(Array.isArray(nodes) ? nodes : nodes ? [nodes] : undefined);
+    const nodeLocations = undefinedIfEmpty((_this$nodes = this.nodes) === null || _this$nodes === undefined ? undefined : _this$nodes.map((node) => node.loc).filter((loc) => loc != null));
+    this.source = source !== null && source !== undefined ? source : nodeLocations === null || nodeLocations === undefined ? undefined : (_nodeLocations$ = nodeLocations[0]) === null || _nodeLocations$ === undefined ? undefined : _nodeLocations$.source;
+    this.positions = positions !== null && positions !== undefined ? positions : nodeLocations === null || nodeLocations === undefined ? undefined : nodeLocations.map((loc) => loc.start);
+    this.locations = positions && source ? positions.map((pos) => getLocation(source, pos)) : nodeLocations === null || nodeLocations === undefined ? undefined : nodeLocations.map((loc) => getLocation(loc.source, loc.start));
+    const originalExtensions = isObjectLike(originalError === null || originalError === undefined ? undefined : originalError.extensions) ? originalError === null || originalError === undefined ? undefined : originalError.extensions : undefined;
+    this.extensions = (_ref = extensions !== null && extensions !== undefined ? extensions : originalExtensions) !== null && _ref !== undefined ? _ref : Object.create(null);
+    Object.defineProperties(this, {
+      message: {
+        writable: true,
+        enumerable: true
+      },
+      name: {
+        enumerable: false
+      },
+      nodes: {
+        enumerable: false
+      },
+      source: {
+        enumerable: false
+      },
+      positions: {
+        enumerable: false
+      },
+      originalError: {
+        enumerable: false
+      }
+    });
+    if (originalError !== null && originalError !== undefined && originalError.stack) {
+      Object.defineProperty(this, "stack", {
+        value: originalError.stack,
+        writable: true,
+        configurable: true
+      });
+    } else if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, GraphQLError);
+    } else {
+      Object.defineProperty(this, "stack", {
+        value: Error().stack,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let output = this.message;
+    if (this.nodes) {
+      for (const node of this.nodes) {
+        if (node.loc) {
+          output += `
+
+` + printLocation(node.loc);
+        }
+      }
+    } else if (this.source && this.locations) {
+      for (const location of this.locations) {
+        output += `
+
+` + printSourceLocation(this.source, location);
+      }
+    }
+    return output;
+  }
+  toJSON() {
+    const formattedError = {
+      message: this.message
+    };
+    if (this.locations != null) {
+      formattedError.locations = this.locations;
+    }
+    if (this.path != null) {
+      formattedError.path = this.path;
+    }
+    if (this.extensions != null && Object.keys(this.extensions).length > 0) {
+      formattedError.extensions = this.extensions;
+    }
+    return formattedError;
+  }
+}
+function undefinedIfEmpty(array) {
+  return array === undefined || array.length === 0 ? undefined : array;
+}
+// ../errors/src/codes.ts
+var ErrorCode;
+((ErrorCode2) => {
+  ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+  ErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+  ErrorCode2["PAYLOAD_TOO_LARGE"] = "PAYLOAD_TOO_LARGE";
+  ErrorCode2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+  ErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
+  ErrorCode2["UNAUTHENTICATED"] = "UNAUTHENTICATED";
+  ErrorCode2["FORBIDDEN"] = "FORBIDDEN";
+  ErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  ErrorCode2["ALREADY_EXISTS"] = "ALREADY_EXISTS";
+  ErrorCode2["RATE_LIMITED"] = "RATE_LIMITED";
+  ErrorCode2["COMPLEXITY_LIMIT"] = "COMPLEXITY_LIMIT";
+  ErrorCode2["DEPTH_LIMIT"] = "DEPTH_LIMIT";
+  ErrorCode2["PERSISTED_QUERY_NOT_FOUND"] = "PERSISTED_QUERY_NOT_FOUND";
+  ErrorCode2["PERSISTED_QUERY_INVALID"] = "PERSISTED_QUERY_INVALID";
+  ErrorCode2["INVALID_INPUT"] = "INVALID_INPUT";
+  ErrorCode2["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
+})(ErrorCode ||= {});
+var ERROR_CODES = {
+  ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: {
+    status: 500,
+    message: "An internal error occurred"
+  },
+  ["BAD_REQUEST" /* BAD_REQUEST */]: {
+    status: 400,
+    message: "Bad request"
+  },
+  ["PAYLOAD_TOO_LARGE" /* PAYLOAD_TOO_LARGE */]: {
+    status: 413,
+    message: "Request payload is too large"
+  },
+  ["VALIDATION_ERROR" /* VALIDATION_ERROR */]: {
+    status: 400,
+    message: "Validation failed"
+  },
+  ["PARSE_ERROR" /* PARSE_ERROR */]: {
+    status: 400,
+    message: "Failed to parse GraphQL query"
+  },
+  ["UNAUTHENTICATED" /* UNAUTHENTICATED */]: {
+    status: 401,
+    message: "Authentication required"
+  },
+  ["FORBIDDEN" /* FORBIDDEN */]: {
+    status: 403,
+    message: "Access denied"
+  },
+  ["NOT_FOUND" /* NOT_FOUND */]: {
+    status: 404,
+    message: "Resource not found"
+  },
+  ["ALREADY_EXISTS" /* ALREADY_EXISTS */]: {
+    status: 409,
+    message: "Resource already exists"
+  },
+  ["RATE_LIMITED" /* RATE_LIMITED */]: {
+    status: 429,
+    message: "Rate limit exceeded"
+  },
+  ["COMPLEXITY_LIMIT" /* COMPLEXITY_LIMIT */]: {
+    status: 400,
+    message: "Query complexity limit exceeded"
+  },
+  ["DEPTH_LIMIT" /* DEPTH_LIMIT */]: {
+    status: 400,
+    message: "Query depth limit exceeded"
+  },
+  ["PERSISTED_QUERY_NOT_FOUND" /* PERSISTED_QUERY_NOT_FOUND */]: {
+    status: 400,
+    message: "Persisted query not found"
+  },
+  ["PERSISTED_QUERY_INVALID" /* PERSISTED_QUERY_INVALID */]: {
+    status: 400,
+    message: "Invalid persisted query"
+  },
+  ["INVALID_INPUT" /* INVALID_INPUT */]: {
+    status: 400,
+    message: "Invalid input provided"
+  },
+  ["MISSING_REQUIRED_FIELD" /* MISSING_REQUIRED_FIELD */]: {
+    status: 400,
+    message: "Required field is missing"
+  }
+};
+var ERROR_CODE_SET = new Set(Object.values(ErrorCode));
+
+// ../errors/src/errors.ts
+class LeavenError extends Error {
+  code;
+  statusCode;
+  extensions;
+  originalError;
+  constructor(message, code = "INTERNAL_ERROR" /* INTERNAL_ERROR */, options) {
+    super(message);
+    this.name = "LeavenError";
+    this.code = code;
+    this.statusCode = options?.statusCode ?? ERROR_CODES[code]?.status ?? 500;
+    this.extensions = {
+      ...options?.extensions,
+      code
+    };
+    this.originalError = options?.originalError;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toGraphQLError() {
+    return new GraphQLError(this.message, {
+      extensions: this.extensions,
+      originalError: this
+    });
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      code: this.code,
+      statusCode: this.statusCode,
+      extensions: this.extensions
+    };
+  }
+}
+class ComplexityError extends LeavenError {
+  complexity;
+  maxComplexity;
+  constructor(complexity, maxComplexity, options) {
+    super(`Query complexity of ${complexity} exceeds maximum allowed complexity of ${maxComplexity}`, "COMPLEXITY_LIMIT" /* COMPLEXITY_LIMIT */, {
+      statusCode: 400,
+      extensions: {
+        ...options?.extensions,
+        complexity,
+        maxComplexity
+      }
+    });
+    this.name = "ComplexityError";
+    this.complexity = complexity;
+    this.maxComplexity = maxComplexity;
+  }
+}
+
+class DepthLimitError extends LeavenError {
+  depth;
+  maxDepth;
+  constructor(depth, maxDepth, options) {
+    super(`Query depth of ${depth} exceeds maximum allowed depth of ${maxDepth}`, "DEPTH_LIMIT" /* DEPTH_LIMIT */, {
+      statusCode: 400,
+      extensions: {
+        ...options?.extensions,
+        depth,
+        maxDepth
+      }
+    });
+    this.name = "DepthLimitError";
+    this.depth = depth;
+    this.maxDepth = maxDepth;
+  }
+}
 // src/builtin.ts
 function createPlugin(metadata, hooks) {
   return {
@@ -214,21 +652,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 +678,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 +722,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 +783,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 +853,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;
+      }
     }
-    if (typedNode.selectionSet) {
-      for (const selection of typedNode.selectionSet.selections) {
-        complexity += calculateComplexity(selection, depth + 1);
+    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);
+    }
+    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,15 +1151,29 @@ 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;
     }