@leaven-graphql/nestjs 0.1.0 → 0.2.1

package/dist/index.js

@@ -14,358 +14,219 @@ var __legacyMetadataTS = (k, v) => {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-var __require = import.meta.require;
 
 // src/module.ts
 import {
   Module,
-  Global
+  Global,
+  Inject as Inject5,
+  Optional
 } from "@nestjs/common";
 
-// src/driver.ts
-import { Injectable } from "@nestjs/common";
-import { LeavenExecutor } from "@leaven-graphql/core";
-class LeavenDriver {
-  executor = null;
-  schema = null;
-  options;
-  constructor(options) {
-    this.options = options;
+// src/types.ts
+var LEAVEN_MODULE_OPTIONS = "LEAVEN_MODULE_OPTIONS";
+var LEAVEN_DRIVER = "LEAVEN_DRIVER";
+var LEAVEN_PUBSUB = "LEAVEN_PUBSUB";
+
+// src/module.ts
+import { createPubSub } from "@leaven-graphql/ws";
+
+// src/guards.ts
+import {
+  Injectable,
+  UnauthorizedException,
+  ForbiddenException,
+  SetMetadata,
+  Inject
+} from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+
+// src/execution-context.ts
+var GQL_RESOLVER_ARGS = {
+  ROOT: 0,
+  ARGS: 1,
+  CONTEXT: 2,
+  INFO: 3
+};
+
+class GqlExecutionContext {
+  host;
+  args;
+  constructor(host) {
+    this.host = host;
+    this.args = host.getArgs();
   }
-  async onModuleInit() {
-    if (this.options.schema) {
-      this.schema = this.options.schema;
-      this.initializeExecutor();
-    }
+  static create(context) {
+    return new GqlExecutionContext(context);
   }
-  async onModuleDestroy() {
-    if (this.executor) {
-      this.executor.clearCaches();
-      this.executor = null;
-    }
+  getContext() {
+    return this.args[GQL_RESOLVER_ARGS.CONTEXT];
   }
-  setSchema(schema) {
-    this.schema = schema;
-    this.initializeExecutor();
+  getRoot() {
+    return this.args[GQL_RESOLVER_ARGS.ROOT];
   }
-  getSchema() {
-    return this.schema;
+  getArgs() {
+    return this.args[GQL_RESOLVER_ARGS.ARGS];
   }
-  getExecutor() {
-    return this.executor;
+  getInfo() {
+    return this.args[GQL_RESOLVER_ARGS.INFO];
   }
-  initializeExecutor() {
-    if (!this.schema) {
-      throw new Error("Schema must be set before initializing executor");
-    }
-    const config = {
-      schema: this.schema,
-      cache: this.options.cache,
-      metrics: this.options.metrics,
-      maxComplexity: this.options.maxComplexity
-    };
-    this.executor = new LeavenExecutor(config);
+  getArg(name) {
+    const args = this.getArgs();
+    return args[name];
   }
-  async execute(query, variables, context, operationName) {
-    if (!this.executor) {
-      throw new Error("Executor not initialized. Set schema first.");
-    }
-    const queryString = typeof query === "string" ? query : this.documentToString(query);
-    try {
-      const result = await this.executor.execute({
-        query: queryString,
-        variables,
-        operationName
-      }, context);
-      const response = result.response;
-      let formattedErrors = response.errors;
-      if (formattedErrors && this.options.formatError) {
-        formattedErrors = formattedErrors.map(this.options.formatError);
-      }
-      let extensions = response.extensions;
-      if (this.options.metrics && result.metrics) {
-        extensions = {
-          ...extensions,
-          metrics: result.metrics
-        };
-      }
-      return {
-        data: response.data,
-        errors: formattedErrors,
-        extensions
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Execution failed";
-      const formattedError = {
-        message,
-        extensions: {
-          code: "INTERNAL_SERVER_ERROR",
-          ...this.options.includeStacktraceInErrorResponses && error instanceof Error ? { stacktrace: error.stack?.split(`
-`) } : {}
-        }
-      };
-      return {
-        errors: [
-          this.options.formatError ? this.options.formatError(formattedError) : formattedError
-        ]
-      };
-    }
+  getContextProperty(name) {
+    const ctx = this.getContext();
+    return ctx[name];
   }
-  async handleRequest(request, response) {
-    const body = await this.parseRequestBody(request);
-    const context = await this.createContext(request, response);
-    return this.execute(body.query, body.variables, context, body.operationName);
+  getHost() {
+    return this.host;
   }
-  async parseRequestBody(request) {
-    const contentType = request.headers.get("content-type") ?? "";
-    if (contentType.includes("application/json")) {
-      const body = await request.json();
-      return {
-        query: body.query,
-        variables: body.variables,
-        operationName: body.operationName
-      };
-    }
-    const url = new URL(request.url);
-    const query = url.searchParams.get("query");
-    const variables = url.searchParams.get("variables");
-    const operationName = url.searchParams.get("operationName");
-    if (!query) {
-      throw new Error("Query is required");
+  getType() {
+    return this.host.getType?.() ?? "unknown";
+  }
+  isGraphQL() {
+    return this.getType() === "graphql";
+  }
+  getHandler() {
+    return this.host.getHandler?.();
+  }
+  getClass() {
+    return this.host.getClass?.();
+  }
+  getFieldName() {
+    const info = this.getInfo();
+    return info?.fieldName;
+  }
+  getParentTypeName() {
+    const info = this.getInfo();
+    return info?.parentType?.name;
+  }
+  getReturnTypeName() {
+    const info = this.getInfo();
+    return info?.returnType?.toString();
+  }
+  getOperationName() {
+    const info = this.getInfo();
+    return info?.operation?.name?.value;
+  }
+  getOperationType() {
+    const info = this.getInfo();
+    return info?.operation?.operation;
+  }
+  getVariables() {
+    const info = this.getInfo();
+    return info?.variableValues ?? {};
+  }
+  getPath() {
+    return this.getFullPath().filter((segment) => typeof segment === "string");
+  }
+  getFullPath() {
+    const info = this.getInfo();
+    if (!info?.path)
+      return [];
+    const path = [];
+    let current = info.path;
+    while (current) {
+      path.unshift(current.key);
+      current = current.prev;
     }
-    return {
-      query,
-      variables: variables ? JSON.parse(variables) : undefined,
-      operationName: operationName ?? undefined
-    };
+    return path;
   }
-  async createContext(request, response) {
-    const baseContext = {
-      req: request,
-      res: response
+  getSelectedFields() {
+    const info = this.getInfo();
+    if (!info?.fieldNodes?.length)
+      return [];
+    const fields = new Set;
+    const visitedFragments = new Set;
+    const collect = (selectionSet) => {
+      if (!selectionSet?.selections)
+        return;
+      for (const selection of selectionSet.selections) {
+        if (selection.kind === "Field") {
+          fields.add(selection.name.value);
+        } else if (selection.kind === "InlineFragment") {
+          collect(selection.selectionSet);
+        } else if (selection.kind === "FragmentSpread") {
+          const fragmentName = selection.name.value;
+          if (visitedFragments.has(fragmentName))
+            continue;
+          visitedFragments.add(fragmentName);
+          collect(info.fragments?.[fragmentName]?.selectionSet);
+        }
+      }
     };
-    if (this.options.context) {
-      const customContext = await this.options.context(request, response);
-      return { ...baseContext, ...customContext };
+    for (const fieldNode of info.fieldNodes) {
+      collect(fieldNode?.selectionSet);
     }
-    return baseContext;
+    return [...fields];
   }
-  documentToString(document) {
-    const { print } = __require("graphql");
-    return print(document);
+}
+var executionContextCache = new WeakMap;
+function getCachedGqlExecutionContext(context) {
+  let gqlContext = executionContextCache.get(context);
+  if (!gqlContext) {
+    gqlContext = GqlExecutionContext.create(context);
+    executionContextCache.set(context, gqlContext);
   }
-  isPlaygroundEnabled() {
-    if (this.options.playground !== undefined) {
-      return this.options.playground;
-    }
-    return true;
+  return gqlContext;
+}
+function getGqlContext(context) {
+  return getCachedGqlExecutionContext(context).getContext();
+}
+function getGqlArgs(context) {
+  return getCachedGqlExecutionContext(context).getArgs();
+}
+function getGqlInfo(context) {
+  return getCachedGqlExecutionContext(context).getInfo();
+}
+function getGqlRoot(context) {
+  return getCachedGqlExecutionContext(context).getRoot();
+}
+
+// src/guards.ts
+var IS_PUBLIC_KEY = "leaven:isPublic";
+var ROLES_KEY = "leaven:roles";
+var PERMISSIONS_KEY = "leaven:permissions";
+var LEAVEN_MAX_COMPLEXITY = "LEAVEN_MAX_COMPLEXITY";
+var LEAVEN_MAX_DEPTH = "LEAVEN_MAX_DEPTH";
+var Public = () => SetMetadata(IS_PUBLIC_KEY, true);
+var Roles = (...roles) => SetMetadata(ROLES_KEY, roles);
+var Permissions = (...permissions) => SetMetadata(PERMISSIONS_KEY, permissions);
+
+class AuthGuard {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
   }
-  isIntrospectionEnabled() {
-    if (this.options.introspection !== undefined) {
-      return this.options.introspection;
+  canActivate(context) {
+    const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (isPublic) {
+      return true;
+    }
+    const gqlContext = this.getGqlContext(context);
+    const user = this.extractUser(gqlContext);
+    if (!user) {
+      throw new UnauthorizedException("Authentication required");
     }
     return true;
   }
-  getPath() {
-    return this.options.path ?? "/graphql";
-  }
-  getCacheStats() {
-    return this.executor?.getCacheStats() ?? null;
+  getGqlContext(context) {
+    return getGqlContext(context);
   }
-  clearCaches() {
-    this.executor?.clearCaches();
+  extractUser(context) {
+    return context.user ?? context.req?.user ?? null;
   }
 }
-LeavenDriver = __legacyDecorateClassTS([
+AuthGuard = __legacyDecorateClassTS([
   Injectable(),
   __legacyMetadataTS("design:paramtypes", [
-    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions
+    typeof Reflector === "undefined" ? Object : Reflector
   ])
-], LeavenDriver);
-
-// src/module.ts
-var LEAVEN_MODULE_OPTIONS = "LEAVEN_MODULE_OPTIONS";
-var LEAVEN_DRIVER = "LEAVEN_DRIVER";
-
-class LeavenModule {
-  static forRoot(options = {}) {
-    const optionsProvider = {
-      provide: LEAVEN_MODULE_OPTIONS,
-      useValue: options
-    };
-    const driverProvider = {
-      provide: LEAVEN_DRIVER,
-      useFactory: (opts) => new LeavenDriver(opts),
-      inject: [LEAVEN_MODULE_OPTIONS]
-    };
-    return {
-      module: LeavenModule,
-      providers: [optionsProvider, driverProvider],
-      exports: [LEAVEN_MODULE_OPTIONS, LEAVEN_DRIVER]
-    };
-  }
-  static forRootAsync(options) {
-    const asyncProviders = this.createAsyncProviders(options);
-    const driverProvider = {
-      provide: LEAVEN_DRIVER,
-      useFactory: (opts) => new LeavenDriver(opts),
-      inject: [LEAVEN_MODULE_OPTIONS]
-    };
-    return {
-      module: LeavenModule,
-      imports: options.imports ?? [],
-      providers: [...asyncProviders, driverProvider],
-      exports: [LEAVEN_MODULE_OPTIONS, LEAVEN_DRIVER]
-    };
-  }
-  static createAsyncProviders(options) {
-    if (options.useExisting || options.useFactory) {
-      return [this.createAsyncOptionsProvider(options)];
-    }
-    const useClass = options.useClass;
-    return [
-      this.createAsyncOptionsProvider(options),
-      {
-        provide: useClass,
-        useClass
-      }
-    ];
-  }
-  static createAsyncOptionsProvider(options) {
-    if (options.useFactory) {
-      return {
-        provide: LEAVEN_MODULE_OPTIONS,
-        useFactory: options.useFactory,
-        inject: options.inject ?? []
-      };
-    }
-    const inject = [
-      options.useClass ?? options.useExisting
-    ];
-    return {
-      provide: LEAVEN_MODULE_OPTIONS,
-      useFactory: async (optionsFactory) => optionsFactory.createLeavenOptions(),
-      inject
-    };
-  }
-}
-LeavenModule = __legacyDecorateClassTS([
-  Global(),
-  Module({})
-], LeavenModule);
-// src/decorators.ts
-import {
-  createParamDecorator,
-  SetMetadata,
-  applyDecorators
-} from "@nestjs/common";
-var COMPLEXITY_KEY = "leaven:complexity";
-var DEPRECATED_KEY = "leaven:deprecated";
-var DESCRIPTION_KEY = "leaven:description";
-var CACHE_KEY = "leaven:cache";
-var SUBSCRIPTION_FILTER_KEY = "leaven:subscription:filter";
-var Context = createParamDecorator((data, ctx) => {
-  const gqlContext = getGqlContext(ctx);
-  if (data) {
-    return gqlContext[data];
-  }
-  return gqlContext;
-});
-var Info = createParamDecorator((_data, ctx) => {
-  const args = ctx.getArgs();
-  return args[3];
-});
-var Root = createParamDecorator((_data, ctx) => {
-  const args = ctx.getArgs();
-  return args[0];
-});
-var Parent = Root;
-var Args = createParamDecorator((data, ctx) => {
-  const args = ctx.getArgs();
-  const gqlArgs = args[1];
-  if (data) {
-    return gqlArgs?.[data];
-  }
-  return gqlArgs;
-});
-function Complexity(value) {
-  return SetMetadata(COMPLEXITY_KEY, value);
-}
-function Deprecated(reason) {
-  return SetMetadata(DEPRECATED_KEY, reason);
-}
-function Description(text) {
-  return SetMetadata(DESCRIPTION_KEY, text);
-}
-function CacheHint(options) {
-  return SetMetadata(CACHE_KEY, options);
-}
-function SubscriptionFilter(filter) {
-  return SetMetadata(SUBSCRIPTION_FILTER_KEY, filter);
-}
-function Decorators(...decorators) {
-  return applyDecorators(...decorators);
-}
-function getGqlContext(ctx) {
-  const args = ctx.getArgs();
-  return args[2];
-}
-function createContextDecorator(key) {
-  return () => createParamDecorator((_data, ctx) => {
-    const gqlContext = getGqlContext(ctx);
-    return gqlContext[key];
-  })();
-}
-// src/guards.ts
-import {
-  Injectable as Injectable2,
-  UnauthorizedException,
-  ForbiddenException,
-  SetMetadata as SetMetadata2,
-  Inject
-} from "@nestjs/common";
-import { Reflector } from "@nestjs/core";
-var IS_PUBLIC_KEY = "leaven:isPublic";
-var ROLES_KEY = "leaven:roles";
-var PERMISSIONS_KEY = "leaven:permissions";
-var Public = () => SetMetadata2(IS_PUBLIC_KEY, true);
-var Roles = (...roles) => SetMetadata2(ROLES_KEY, roles);
-var Permissions = (...permissions) => SetMetadata2(PERMISSIONS_KEY, permissions);
-
-class AuthGuard {
-  reflector;
-  constructor(reflector) {
-    this.reflector = reflector;
-  }
-  canActivate(context) {
-    const isPublic = this.reflector.getAllAndOverride(IS_PUBLIC_KEY, [
-      context.getHandler(),
-      context.getClass()
-    ]);
-    if (isPublic) {
-      return true;
-    }
-    const gqlContext = this.getGqlContext(context);
-    const user = this.extractUser(gqlContext);
-    if (!user) {
-      throw new UnauthorizedException("Authentication required");
-    }
-    return true;
-  }
-  getGqlContext(context) {
-    const args = context.getArgs();
-    return args[2];
-  }
-  extractUser(context) {
-    return context.user ?? context.req?.user ?? null;
-  }
-}
-AuthGuard = __legacyDecorateClassTS([
-  Injectable2(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof Reflector === "undefined" ? Object : Reflector
-  ])
-], AuthGuard);
+], AuthGuard);
 
 class RolesGuard {
   reflector;
@@ -393,8 +254,7 @@ class RolesGuard {
     return true;
   }
   getGqlContext(context) {
-    const args = context.getArgs();
-    return args[2];
+    return getGqlContext(context);
   }
   extractUser(context) {
     return context.user ?? context.req?.user ?? null;
@@ -412,7 +272,7 @@ class RolesGuard {
   }
 }
 RolesGuard = __legacyDecorateClassTS([
-  Injectable2(),
+  Injectable(),
   __legacyMetadataTS("design:paramtypes", [
     typeof Reflector === "undefined" ? Object : Reflector
   ])
@@ -441,8 +301,7 @@ class PermissionsGuard {
     return true;
   }
   getGqlContext(context) {
-    const args = context.getArgs();
-    return args[2];
+    return getGqlContext(context);
   }
   extractUser(context) {
     return context.user ?? context.req?.user ?? null;
@@ -460,7 +319,7 @@ class PermissionsGuard {
   }
 }
 PermissionsGuard = __legacyDecorateClassTS([
-  Injectable2(),
+  Injectable(),
   __legacyMetadataTS("design:paramtypes", [
     typeof Reflector === "undefined" ? Object : Reflector
   ])
@@ -472,21 +331,23 @@ class ComplexityGuard {
     this.maxComplexity = maxComplexity;
   }
   canActivate(context) {
-    const gqlContext = this.getGqlContext(context);
-    const currentComplexity = gqlContext._queryComplexity;
-    if (currentComplexity !== undefined && currentComplexity > this.maxComplexity) {
+    if (this.maxComplexity === Number.POSITIVE_INFINITY) {
+      return true;
+    }
+    const gqlContext = getGqlContext(context);
+    const currentComplexity = gqlContext?._queryComplexity;
+    if (typeof currentComplexity !== "number" || Number.isNaN(currentComplexity)) {
+      throw new ForbiddenException("Query complexity could not be determined; rejecting the request");
+    }
+    if (currentComplexity > this.maxComplexity) {
       throw new ForbiddenException(`Query complexity ${currentComplexity} exceeds maximum allowed ${this.maxComplexity}`);
     }
     return true;
   }
-  getGqlContext(context) {
-    const args = context.getArgs();
-    return args[2];
-  }
 }
 ComplexityGuard = __legacyDecorateClassTS([
-  Injectable2(),
-  __legacyDecorateParamTS(0, Inject("LEAVEN_MAX_COMPLEXITY")),
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(LEAVEN_MAX_COMPLEXITY)),
   __legacyMetadataTS("design:paramtypes", [
     Number
   ])
@@ -498,188 +359,305 @@ class DepthGuard {
     this.maxDepth = maxDepth;
   }
   canActivate(context) {
-    const gqlContext = this.getGqlContext(context);
-    const currentDepth = gqlContext._queryDepth;
-    if (currentDepth !== undefined && currentDepth > this.maxDepth) {
+    if (this.maxDepth === Number.POSITIVE_INFINITY) {
+      return true;
+    }
+    const gqlContext = getGqlContext(context);
+    const currentDepth = gqlContext?._queryDepth;
+    if (typeof currentDepth !== "number" || Number.isNaN(currentDepth)) {
+      throw new ForbiddenException("Query depth could not be determined; rejecting the request");
+    }
+    if (currentDepth > this.maxDepth) {
       throw new ForbiddenException(`Query depth ${currentDepth} exceeds maximum allowed ${this.maxDepth}`);
     }
     return true;
   }
-  getGqlContext(context) {
-    const args = context.getArgs();
-    return args[2];
-  }
 }
 DepthGuard = __legacyDecorateClassTS([
-  Injectable2(),
-  __legacyDecorateParamTS(0, Inject("LEAVEN_MAX_DEPTH")),
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(LEAVEN_MAX_DEPTH)),
   __legacyMetadataTS("design:paramtypes", [
     Number
   ])
 ], DepthGuard);
-// src/interceptors.ts
+
+// src/driver.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
 import {
-  Injectable as Injectable3
-} from "@nestjs/common";
-import { tap, catchError, throwError } from "rxjs";
-import { Reflector as Reflector2 } from "@nestjs/core";
-class LoggingInterceptor {
-  intercept(context, next) {
-    const className = context.getClass().name;
-    const methodName = context.getHandler().name;
-    const start = performance.now();
-    return next.handle().pipe(tap(() => {
-      const duration = (performance.now() - start).toFixed(2);
-      console.log(`[GraphQL] ${className}.${methodName} - ${duration}ms`);
-    }));
+  GraphQLError,
+  parse,
+  print
+} from "graphql";
+import {
+  LeavenExecutor,
+  calculateQueryDepth,
+  compileQuery
+} from "@leaven-graphql/core";
+import { ValidationError, formatError, isLeavenError } from "@leaven-graphql/errors";
+class LeavenDriver {
+  executor = null;
+  schema = null;
+  options;
+  static MAX_ANALYSIS_ENTRIES = 1000;
+  analysisCache = new Map;
+  constructor(options) {
+    this.options = options;
   }
-}
-LoggingInterceptor = __legacyDecorateClassTS([
-  Injectable3()
-], LoggingInterceptor);
-
-class ErrorFormattingInterceptor {
-  intercept(_context, next) {
-    return next.handle().pipe(catchError((error) => {
-      const formattedError = this.formatError(error);
-      return throwError(() => formattedError);
-    }));
+  async onModuleInit() {
+    if (this.options.schema) {
+      this.schema = this.options.schema;
+      this.initializeExecutor();
+    }
   }
-  formatError(error) {
-    if (error instanceof Error) {
-      if (false) {}
-      return error;
+  async onModuleDestroy() {
+    if (this.executor) {
+      await this.executor.clearCaches();
+      this.executor = null;
     }
-    return new Error(String(error));
+    this.analysisCache.clear();
   }
-}
-ErrorFormattingInterceptor = __legacyDecorateClassTS([
-  Injectable3()
-], ErrorFormattingInterceptor);
-
-class ComplexityInterceptor {
-  reflector;
-  constructor(reflector) {
-    this.reflector = reflector;
+  setSchema(schema) {
+    this.schema = schema;
+    this.initializeExecutor();
   }
-  intercept(context, next) {
-    const complexity = this.reflector.get(COMPLEXITY_KEY, context.getHandler());
-    if (complexity !== undefined) {
-      const args = context.getArgs();
-      const gqlContext = args[2];
-      if (gqlContext) {
-        gqlContext._fieldComplexity = complexity;
-      }
-    }
-    return next.handle();
+  getSchema() {
+    return this.schema;
   }
-}
-ComplexityInterceptor = __legacyDecorateClassTS([
-  Injectable3(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof Reflector2 === "undefined" ? Object : Reflector2
-  ])
-], ComplexityInterceptor);
-
-class CachingInterceptor {
-  reflector;
-  constructor(reflector) {
-    this.reflector = reflector;
+  getExecutor() {
+    return this.executor;
   }
-  intercept(context, next) {
-    const cacheHint = this.reflector.get(CACHE_KEY, context.getHandler());
-    return next.handle().pipe(tap(() => {
-      if (cacheHint) {
-        const args = context.getArgs();
-        const gqlInfo = args[3];
-        if (gqlInfo?.cacheControl) {
-          gqlInfo.cacheControl.setCacheHint({
-            maxAge: cacheHint.maxAge,
-            scope: cacheHint.scope
-          });
-        }
-      }
-    }));
+  initializeExecutor() {
+    if (!this.schema) {
+      throw new Error("Schema must be set before initializing executor");
+    }
+    const config = {
+      schema: this.schema,
+      cache: this.options.cache,
+      metrics: this.options.metrics,
+      maxComplexity: this.options.maxComplexity,
+      maxDepth: this.options.maxDepth,
+      introspection: this.isIntrospectionEnabled()
+    };
+    this.analysisCache.clear();
+    this.executor = new LeavenExecutor(config);
   }
-}
-CachingInterceptor = __legacyDecorateClassTS([
-  Injectable3(),
-  __legacyMetadataTS("design:paramtypes", [
-    typeof Reflector2 === "undefined" ? Object : Reflector2
-  ])
-], CachingInterceptor);
-
-class MetricsInterceptor {
-  metrics = new Map;
-  intercept(context, next) {
-    const className = context.getClass().name;
-    const methodName = context.getHandler().name;
-    const key = `${className}.${methodName}`;
-    const start = performance.now();
-    return next.handle().pipe(tap(() => {
-      const duration = performance.now() - start;
-      this.recordSuccess(key, duration);
-    }), catchError((error) => {
-      const duration = performance.now() - start;
-      this.recordError(key, duration);
-      return throwError(() => error);
-    }));
+  async execute(query, variables, context, operationName) {
+    if (!this.executor) {
+      throw new Error("Executor not initialized. Set schema first.");
+    }
+    const queryString = typeof query === "string" ? query : print(query);
+    if (context) {
+      this.attachQueryAnalysis(query, queryString, context, operationName);
+    }
+    try {
+      const result = await this.executor.execute({
+        query: queryString,
+        variables,
+        operationName
+      }, context);
+      const response = result.response;
+      let formattedErrors = response.errors;
+      if (formattedErrors && this.options.formatError) {
+        const formatErrorFn = this.options.formatError;
+        formattedErrors = formattedErrors.map((error) => formatErrorFn(error));
+      }
+      let extensions = response.extensions;
+      if (this.options.metrics && result.metrics) {
+        extensions = {
+          ...extensions,
+          metrics: result.metrics
+        };
+      }
+      return {
+        data: response.data,
+        errors: formattedErrors,
+        extensions
+      };
+    } catch (error) {
+      return { errors: [this.formatThrownError(error)] };
+    }
   }
-  recordSuccess(key, duration) {
-    const metrics = this.getOrCreateMetrics(key);
-    metrics.totalCount++;
-    metrics.successCount++;
-    metrics.totalDuration += duration;
-    metrics.lastDuration = duration;
-    metrics.minDuration = Math.min(metrics.minDuration, duration);
-    metrics.maxDuration = Math.max(metrics.maxDuration, duration);
+  formatThrownError(error) {
+    const isProduction = false;
+    const includeStack = this.options.includeStacktraceInErrorResponses ?? false;
+    const formattedError = formatError(error, {
+      maskErrors: !isLeavenError(error) && isProduction && !includeStack,
+      includeStackTrace: includeStack
+    });
+    return this.options.formatError ? this.options.formatError(formattedError) : formattedError;
   }
-  recordError(key, duration) {
-    const metrics = this.getOrCreateMetrics(key);
-    metrics.totalCount++;
-    metrics.errorCount++;
-    metrics.totalDuration += duration;
-    metrics.lastDuration = duration;
+  async subscribe(query, variables, context, operationName) {
+    if (!this.executor) {
+      throw new Error("Executor not initialized. Set schema first.");
+    }
+    const queryString = typeof query === "string" ? query : print(query);
+    if (context) {
+      this.attachQueryAnalysis(query, queryString, context, operationName);
+    }
+    try {
+      const result = await this.executor.subscribe({ query: queryString, variables, operationName }, context);
+      if (!(Symbol.asyncIterator in result)) {
+        let errors = result.errors;
+        if (errors && this.options.formatError) {
+          const formatErrorFn = this.options.formatError;
+          errors = errors.map((error) => formatErrorFn(error));
+        }
+        return { errors };
+      }
+      return result;
+    } catch (error) {
+      return { errors: [this.formatThrownError(error)] };
+    }
   }
-  getOrCreateMetrics(key) {
-    let metrics = this.metrics.get(key);
-    if (!metrics) {
-      metrics = {
-        totalCount: 0,
-        successCount: 0,
-        errorCount: 0,
-        totalDuration: 0,
-        lastDuration: 0,
-        minDuration: Infinity,
-        maxDuration: 0
-      };
-      this.metrics.set(key, metrics);
+  async handleRequest(request, response) {
+    const body = await this.parseRequestBody(request);
+    const context = await this.createContext(request, response);
+    return this.execute(body.query, body.variables, context, body.operationName);
+  }
+  async parseRequestBody(request) {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (request.method === "POST") {
+      if (contentType.includes("application/json")) {
+        const body = await request.json();
+        return {
+          query: body.query,
+          variables: body.variables,
+          operationName: body.operationName
+        };
+      }
+      if (contentType.includes("application/graphql")) {
+        const query = await request.text();
+        if (!query) {
+          throw new ValidationError("Query is required");
+        }
+        return { query };
+      }
+      throw new ValidationError(`Unsupported content type "${contentType || "(none)"}": use application/json or application/graphql`);
     }
-    return metrics;
+    const url = new URL(request.url);
+    const query = url.searchParams.get("query");
+    const variables = url.searchParams.get("variables");
+    const operationName = url.searchParams.get("operationName");
+    if (!query) {
+      throw new ValidationError("Query is required");
+    }
+    let parsedVariables;
+    if (variables) {
+      try {
+        parsedVariables = JSON.parse(variables);
+      } catch {
+        throw new ValidationError('The "variables" query parameter contains malformed JSON');
+      }
+    }
+    return {
+      query,
+      variables: parsedVariables,
+      operationName: operationName ?? undefined
+    };
   }
-  getMetrics() {
-    return new Map(this.metrics);
+  async createContext(request, response) {
+    const baseContext = {
+      req: request,
+      res: response
+    };
+    if (this.options.context) {
+      const customContext = await this.options.context(request, response);
+      return { ...baseContext, ...customContext };
+    }
+    return baseContext;
   }
-  getSummary() {
-    return Array.from(this.metrics.entries()).map(([operation, metrics]) => ({
-      operation,
-      ...metrics,
-      averageDuration: metrics.totalCount > 0 ? metrics.totalDuration / metrics.totalCount : 0,
-      errorRate: metrics.totalCount > 0 ? metrics.errorCount / metrics.totalCount : 0
-    }));
+  attachQueryAnalysis(query, queryString, context, operationName) {
+    if (this.options.maxComplexity === undefined && this.options.maxDepth === undefined) {
+      return;
+    }
+    const target = context;
+    const cacheKey = `${queryString}\x00${operationName ?? ""}`;
+    const memoized = this.analysisCache.get(cacheKey);
+    if (memoized) {
+      this.analysisCache.delete(cacheKey);
+      this.analysisCache.set(cacheKey, memoized);
+      target._queryDepth = memoized.depth;
+      target._queryComplexity = memoized.complexity;
+      return;
+    }
+    let document;
+    try {
+      document = typeof query === "string" ? parse(query) : query;
+    } catch (error) {
+      if (error instanceof GraphQLError) {
+        return;
+      }
+      this.recordAnalysisFailure(target, error);
+      return;
+    }
+    try {
+      const depth = calculateQueryDepth(document);
+      if (!this.schema) {
+        throw new Error("Schema is not set; query complexity cannot be computed");
+      }
+      const complexity = compileQuery(this.schema, document, operationName, {
+        calculateComplexity: true
+      }).complexity;
+      target._queryDepth = depth;
+      target._queryComplexity = complexity;
+      this.memoizeAnalysis(cacheKey, { depth, complexity });
+    } catch (error) {
+      this.recordAnalysisFailure(target, error);
+    }
   }
-  reset() {
-    this.metrics.clear();
+  memoizeAnalysis(key, analysis) {
+    if (this.analysisCache.size >= LeavenDriver.MAX_ANALYSIS_ENTRIES) {
+      const oldest = this.analysisCache.keys().next().value;
+      if (oldest !== undefined) {
+        this.analysisCache.delete(oldest);
+      }
+    }
+    this.analysisCache.set(key, analysis);
+  }
+  recordAnalysisFailure(target, error) {
+    console.error("[Leaven] Query analysis failed; failing closed:", error);
+    target._queryDepth = Number.POSITIVE_INFINITY;
+    target._queryComplexity = Number.POSITIVE_INFINITY;
+  }
+  isPlaygroundEnabled() {
+    if (this.options.playground !== undefined) {
+      return this.options.playground;
+    }
+    return true;
+  }
+  isIntrospectionEnabled() {
+    if (this.options.introspection !== undefined) {
+      return this.options.introspection;
+    }
+    return true;
+  }
+  getPath() {
+    return this.options.path ?? "/graphql";
+  }
+  getCacheStats() {
+    return this.executor?.getCacheStats() ?? null;
+  }
+  async clearCaches() {
+    this.analysisCache.clear();
+    await this.executor?.clearCaches();
   }
 }
-MetricsInterceptor = __legacyDecorateClassTS([
-  Injectable3()
-], MetricsInterceptor);
+LeavenDriver = __legacyDecorateClassTS([
+  Injectable2(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions
+  ])
+], LeavenDriver);
+
 // src/middleware.ts
 import {
-  Injectable as Injectable4,
+  Injectable as Injectable3,
   Inject as Inject2
 } from "@nestjs/common";
+import { formatError as formatError2, isLeavenError as isLeavenError2 } from "@leaven-graphql/errors";
+import { renderGraphiQL } from "@leaven-graphql/playground";
+var VALID_HOST = /^[a-z0-9.-]+(:\d+)?$/i;
+
 class GraphQLMiddleware {
   driver;
   options;
@@ -701,12 +679,16 @@ class GraphQLMiddleware {
       return;
     }
     if (req.method === "OPTIONS") {
-      this.handleCorsPreFlight(res);
+      if (this.resolveCorsOptions() === null) {
+        return next();
+      }
+      this.handleCorsPreFlight(req, res);
       return;
     }
     next();
   }
   async handleGraphQLRequest(req, res) {
+    this.applyCorsHeaders(req, res);
     try {
       const { query, variables, operationName } = req.body ?? {};
       if (!query) {
@@ -718,74 +700,127 @@ class GraphQLMiddleware {
       const context = {
         req,
         res,
-        ...this.options.context ? await this.options.context(req, res) : {}
+        ...this.options.context ? await this.options.context(this.toFetchRequest(req), res) : {}
       };
       const result = await this.driver.execute(query, variables, context, operationName);
-      const status = result.errors?.length ? 200 : 200;
-      res.status(status).json(result);
+      res.status(200).json(result);
     } catch (error) {
-      const message = error instanceof Error ? error.message : "Internal server error";
-      res.status(500).json({
-        errors: [{ message }]
+      const isProduction = false;
+      const includeStack = this.options.includeStacktraceInErrorResponses ?? false;
+      const formattedError = formatError2(error, {
+        maskErrors: !isLeavenError2(error) && isProduction && !includeStack,
+        includeStackTrace: includeStack
+      });
+      res.status(isLeavenError2(error) ? error.statusCode : 500).json({
+        errors: [formattedError]
       });
     }
   }
   servePlayground(res) {
-    const path = this.driver.getPath();
-    const html = this.getPlaygroundHtml(path);
+    const html = renderGraphiQL({ endpoint: this.driver.getPath() });
     res.setHeader("Content-Type", "text/html");
     res.send(html);
   }
-  handleCorsPreFlight(res) {
+  handleCorsPreFlight(req, res) {
+    this.applyCorsHeaders(req, res);
+    res.status(204).end();
+  }
+  resolveCorsOptions() {
     const corsOptions = this.options.cors;
-    if (corsOptions === false) {
-      res.status(204).end();
+    if (corsOptions === undefined || corsOptions === false) {
+      return null;
+    }
+    return corsOptions === true ? {} : corsOptions;
+  }
+  applyCorsHeaders(req, res) {
+    const options = this.resolveCorsOptions();
+    if (options === null) {
       return;
     }
-    const options = corsOptions === true ? {} : corsOptions ?? {};
-    res.setHeader("Access-Control-Allow-Origin", Array.isArray(options.origin) ? options.origin.join(", ") : typeof options.origin === "string" ? options.origin : "*");
+    const requestOrigin = typeof req.headers.origin === "string" ? req.headers.origin : undefined;
+    const allowOrigin = this.resolveAllowedOrigin(options, requestOrigin);
+    if (allowOrigin.value !== undefined) {
+      res.setHeader("Access-Control-Allow-Origin", allowOrigin.value);
+    }
+    if (allowOrigin.varies) {
+      res.setHeader("Vary", "Origin");
+    }
     res.setHeader("Access-Control-Allow-Methods", Array.isArray(options.methods) ? options.methods.join(", ") : options.methods ?? "GET, POST, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", Array.isArray(options.allowedHeaders) ? options.allowedHeaders.join(", ") : options.allowedHeaders ?? "Content-Type, Authorization");
+    if (options.exposedHeaders) {
+      res.setHeader("Access-Control-Expose-Headers", Array.isArray(options.exposedHeaders) ? options.exposedHeaders.join(", ") : options.exposedHeaders);
+    }
     if (options.credentials) {
       res.setHeader("Access-Control-Allow-Credentials", "true");
     }
     if (options.maxAge) {
       res.setHeader("Access-Control-Max-Age", String(options.maxAge));
     }
-    res.status(204).end();
   }
-  getPlaygroundHtml(endpoint) {
-    return `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Leaven GraphQL Playground</title>
-  <link rel="stylesheet" href="https://unpkg.com/graphiql@3.0.9/graphiql.min.css" />
-  <style>
-    body { margin: 0; height: 100vh; }
-    #graphiql { height: 100vh; }
-  </style>
-</head>
-<body>
-  <div id="graphiql">Loading...</div>
-  <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
-  <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
-  <script crossorigin src="https://unpkg.com/graphiql@3.0.9/graphiql.min.js"></script>
-  <script>
-    const fetcher = GraphiQL.createFetcher({ url: '${endpoint}' });
-    ReactDOM.createRoot(document.getElementById('graphiql')).render(
-      React.createElement(GraphiQL, { fetcher })
-    );
-  </script>
-</body>
-</html>
-    `.trim();
+  resolveAllowedOrigin(options, requestOrigin) {
+    const { origin, credentials } = options;
+    if (origin === false) {
+      return { varies: false };
+    }
+    if (Array.isArray(origin)) {
+      return requestOrigin !== undefined && origin.includes(requestOrigin) ? { value: requestOrigin, varies: true } : { varies: true };
+    }
+    if (typeof origin === "string" && origin !== "*") {
+      return { value: origin, varies: false };
+    }
+    if (credentials) {
+      return requestOrigin !== undefined ? { value: requestOrigin, varies: true } : { varies: true };
+    }
+    if (origin === true) {
+      return requestOrigin !== undefined ? { value: requestOrigin, varies: true } : { value: "*", varies: true };
+    }
+    return { value: "*", varies: false };
+  }
+  toFetchRequest(req) {
+    const headers = new Headers;
+    for (const [name, value] of Object.entries(req.headers)) {
+      if (value === undefined) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const entry of value) {
+          headers.append(name, entry);
+        }
+      } else {
+        headers.set(name, value);
+      }
+    }
+    const path = req.originalUrl ?? req.url ?? req.path;
+    const url = `${this.resolveOrigin(req)}${path}`;
+    const init = { method: req.method, headers };
+    if (req.body !== undefined && req.method !== "GET" && req.method !== "HEAD") {
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+      init.body = JSON.stringify(req.body);
+    }
+    try {
+      return new globalThis.Request(url, init);
+    } catch {
+      return new globalThis.Request(`${this.canonicalOrigin(req)}${this.driver.getPath()}`, init);
+    }
+  }
+  resolveOrigin(req) {
+    if (this.options.publicUrl) {
+      return this.canonicalOrigin(req);
+    }
+    const host = req.headers.host;
+    if (typeof host === "string" && VALID_HOST.test(host)) {
+      return `${req.secure ? "https" : "http"}://${host}`;
+    }
+    return this.canonicalOrigin(req);
+  }
+  canonicalOrigin(req) {
+    return this.options.publicUrl?.replace(/\/+$/, "") ?? (req.secure ? "https://localhost" : "http://localhost");
   }
 }
 GraphQLMiddleware = __legacyDecorateClassTS([
-  Injectable4(),
+  Injectable3(),
   __legacyDecorateParamTS(0, Inject2(LEAVEN_DRIVER)),
   __legacyDecorateParamTS(1, Inject2(LEAVEN_MODULE_OPTIONS)),
   __legacyMetadataTS("design:paramtypes", [
@@ -796,111 +831,112 @@ GraphQLMiddleware = __legacyDecorateClassTS([
 function createGraphQLMiddleware() {
   return GraphQLMiddleware;
 }
-// src/execution-context.ts
-class GqlExecutionContext {
-  host;
-  args;
-  constructor(host) {
-    this.host = host;
-    this.args = host.getArgs();
-  }
-  static create(context) {
-    return new GqlExecutionContext(context);
+
+// src/schema-builder.ts
+import { Injectable as Injectable4, Inject as Inject3 } from "@nestjs/common";
+import {
+  buildSchema as buildSchemaFromSDL,
+  lexicographicSortSchema,
+  parse as parse2,
+  print as print2,
+  printSchema,
+  visit
+} from "graphql";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+
+// src/decorators.ts
+import {
+  createParamDecorator,
+  SetMetadata as SetMetadata2,
+  applyDecorators
+} from "@nestjs/common";
+var COMPLEXITY_KEY = "leaven:complexity";
+var DEPRECATED_KEY = "leaven:deprecated";
+var DESCRIPTION_KEY = "leaven:description";
+var CACHE_KEY = "leaven:cache";
+var SUBSCRIPTION_FILTER_KEY = "leaven:subscription:filter";
+function contextExtractor(data, ctx) {
+  const gqlContext = getGqlContext(ctx);
+  if (data) {
+    return gqlContext[data];
   }
-  getContext() {
-    return this.args[2];
+  return gqlContext;
+}
+var Context = createParamDecorator(contextExtractor);
+function infoExtractor(_data, ctx) {
+  return ctx.getArgs()[GQL_RESOLVER_ARGS.INFO];
+}
+var Info = createParamDecorator(infoExtractor);
+function rootExtractor(_data, ctx) {
+  return ctx.getArgs()[GQL_RESOLVER_ARGS.ROOT];
+}
+var Root = createParamDecorator(rootExtractor);
+var Parent = Root;
+function argsExtractor(data, ctx) {
+  const gqlArgs = ctx.getArgs()[GQL_RESOLVER_ARGS.ARGS];
+  if (data) {
+    return gqlArgs?.[data];
   }
-  getRoot() {
-    return this.args[0];
-  }
-  getArgs() {
-    return this.args[1];
-  }
-  getInfo() {
-    return this.args[3];
-  }
-  getArg(name) {
-    const args = this.getArgs();
-    return args[name];
-  }
-  getContextProperty(name) {
-    const ctx = this.getContext();
-    return ctx[name];
-  }
-  getHost() {
-    return this.host;
-  }
-  getType() {
-    return this.host.getType?.() ?? "unknown";
-  }
-  isGraphQL() {
-    return this.getType() === "graphql";
-  }
-  getHandler() {
-    return this.host.getHandler?.();
-  }
-  getClass() {
-    return this.host.getClass?.();
-  }
-  getFieldName() {
-    const info = this.getInfo();
-    return info?.fieldName;
-  }
-  getParentTypeName() {
-    const info = this.getInfo();
-    return info?.parentType?.name;
-  }
-  getReturnTypeName() {
-    const info = this.getInfo();
-    return info?.returnType?.toString();
-  }
-  getOperationName() {
-    const info = this.getInfo();
-    return info?.operation?.name?.value;
-  }
-  getOperationType() {
-    const info = this.getInfo();
-    return info?.operation?.operation;
-  }
-  getVariables() {
-    const info = this.getInfo();
-    return info?.variableValues ?? {};
-  }
-  getPath() {
-    const info = this.getInfo();
-    if (!info?.path)
-      return [];
-    const path = [];
-    let current = info.path;
-    while (current) {
-      if (typeof current.key === "string") {
-        path.unshift(current.key);
-      }
-      current = current.prev;
-    }
-    return path;
-  }
-  getSelectedFields() {
-    const info = this.getInfo();
-    if (!info?.fieldNodes?.[0]?.selectionSet?.selections)
-      return [];
-    return info.fieldNodes[0].selectionSet.selections.filter((selection) => selection.kind === "Field").map((field) => field.name.value);
+  return gqlArgs;
+}
+var Args = createParamDecorator(argsExtractor);
+function Complexity(value) {
+  return SetMetadata2(COMPLEXITY_KEY, value);
+}
+function Deprecated(reason) {
+  return SetMetadata2(DEPRECATED_KEY, reason);
+}
+function Description(text) {
+  return SetMetadata2(DESCRIPTION_KEY, text);
+}
+function CacheHint(options) {
+  return SetMetadata2(CACHE_KEY, options);
+}
+async function* filterAsyncIterator(source, predicate) {
+  for await (const payload of source) {
+    let accepted;
+    try {
+      accepted = await predicate(payload);
+    } catch (error) {
+      console.error("Subscription filter threw; dropping event:", error);
+      continue;
+    }
+    if (accepted) {
+      yield payload;
+    }
   }
 }
-function getGqlContext2(context) {
-  return GqlExecutionContext.create(context).getContext();
+function wrapWithFilter(descriptor, filter) {
+  const original = descriptor.value;
+  if (typeof original !== "function") {
+    return;
+  }
+  descriptor.value = function(...args) {
+    const source = original.apply(this, args);
+    const variables = args[GQL_RESOLVER_ARGS.ARGS];
+    const context = args[GQL_RESOLVER_ARGS.CONTEXT];
+    const predicate = (payload) => filter(payload, variables, context);
+    return source instanceof Promise ? source.then((resolved) => filterAsyncIterator(resolved, predicate)) : filterAsyncIterator(source, predicate);
+  };
 }
-function getGqlArgs(context) {
-  return GqlExecutionContext.create(context).getArgs();
+function SubscriptionFilter(filter) {
+  return (target, propertyKey, descriptor) => {
+    wrapWithFilter(descriptor, filter);
+    return SetMetadata2(SUBSCRIPTION_FILTER_KEY, filter)(target, propertyKey, descriptor);
+  };
 }
-function getGqlInfo(context) {
-  return GqlExecutionContext.create(context).getInfo();
+function Decorators(...decorators) {
+  return applyDecorators(...decorators);
 }
-function getGqlRoot(context) {
-  return GqlExecutionContext.create(context).getRoot();
+function createContextDecorator(key) {
+  const decorator = createParamDecorator((_data, ctx) => {
+    const gqlContext = getGqlContext(ctx);
+    return gqlContext[key];
+  });
+  return () => decorator();
 }
+
 // src/schema-builder.ts
-import { Injectable as Injectable5, Inject as Inject3 } from "@nestjs/common";
 class SchemaBuilderService {
   options;
   driver;
@@ -916,72 +952,54 @@ class SchemaBuilderService {
       this.driver.setSchema(schema);
     }
   }
-  async buildSchema() {
-    if (this.options.schema) {
-      return this.options.schema;
+  resolveSchemaSource() {
+    const { schema, typeDefs, resolvers, autoSchemaFile, buildSchemaOptions } = this.options;
+    if (schema) {
+      return { type: "provided", schema };
     }
-    if (this.options.typeDefs) {
-      return this.buildFromTypeDefs();
+    if (typeDefs) {
+      return { type: "typeDefs", typeDefs, resolvers };
     }
-    if (this.options.autoSchemaFile) {
-      return null;
+    if (autoSchemaFile) {
+      return { type: "autoSchema", options: buildSchemaOptions ?? {} };
     }
     return null;
   }
-  buildFromTypeDefs() {
-    const { typeDefs, resolvers } = this.options;
-    if (!typeDefs || !resolvers) {
+  async buildSchema() {
+    const source = this.resolveSchemaSource();
+    if (!source) {
       return null;
     }
-    try {
-      const { buildSchema } = __require("graphql");
-      const { addResolversToSchema, makeExecutableSchema } = (()=>{throw new Error("Cannot require module "+"@graphql-tools/schema");})();
-      if (makeExecutableSchema) {
-        return makeExecutableSchema({
-          typeDefs,
-          resolvers
-        });
-      }
-      const schema = buildSchema(typeof typeDefs === "string" ? typeDefs : this.mergeTypeDefs(typeDefs));
-      if (addResolversToSchema) {
-        return addResolversToSchema({
-          schema,
-          resolvers: Array.isArray(resolvers) ? this.mergeResolvers(resolvers) : resolvers
-        });
-      }
-      return schema;
-    } catch (error) {
-      console.warn("Failed to build schema from typeDefs. Install @graphql-tools/schema for full support.", error);
-      return null;
+    switch (source.type) {
+      case "provided":
+        return source.schema;
+      case "typeDefs":
+        return this.buildFromTypeDefs(source.typeDefs, source.resolvers);
+      case "autoSchema":
+        throw new Error("Failed to build the GraphQL schema: 'autoSchemaFile' was configured, but code-first " + "schema generation is not implemented. Supply a pre-built executable schema via the " + "'schema' option, or SDL via 'typeDefs' (optionally with 'resolvers').");
+    }
+  }
+  async buildFromTypeDefs(typeDefs, resolvers) {
+    const sdl = this.mergeTypeDefs(typeDefs);
+    if (!resolvers) {
+      return buildSchemaFromSDL(sdl);
     }
+    const schema = makeExecutableSchema({
+      typeDefs: sdl,
+      resolvers
+    });
+    applyResolverFieldMetadata(schema, resolvers);
+    return schema;
   }
   mergeTypeDefs(typeDefs) {
     if (typeof typeDefs === "string") {
       return typeDefs;
     }
     if (Array.isArray(typeDefs)) {
-      return typeDefs.map((td) => {
-        if (typeof td === "string") {
-          return td;
-        }
-        const { print: print2 } = __require("graphql");
-        return print2(td);
-      }).join(`
+      return typeDefs.map((td) => typeof td === "string" ? td : print2(td)).join(`
 `);
     }
-    const { print } = __require("graphql");
-    return print(typeDefs);
-  }
-  mergeResolvers(resolvers) {
-    return resolvers.reduce((merged, resolver) => {
-      for (const [typeName, fields] of Object.entries(resolver)) {
-        merged[typeName] = {
-          ...merged[typeName] || {},
-          ...fields
-        };
-      }
-      return merged;
-    }, {});
+    return print2(typeDefs);
   }
   getSchema() {
     return this.builtSchema;
@@ -995,7 +1013,7 @@ class SchemaBuilderService {
   }
 }
 SchemaBuilderService = __legacyDecorateClassTS([
-  Injectable5(),
+  Injectable4(),
   __legacyDecorateParamTS(0, Inject3(LEAVEN_MODULE_OPTIONS)),
   __legacyDecorateParamTS(1, Inject3(LEAVEN_DRIVER)),
   __legacyMetadataTS("design:paramtypes", [
@@ -1003,15 +1021,71 @@ SchemaBuilderService = __legacyDecorateClassTS([
     typeof LeavenDriver === "undefined" ? Object : LeavenDriver
   ])
 ], SchemaBuilderService);
+function collectResolverFunctions(container) {
+  const functions = new Map;
+  let current = container;
+  while (current && current !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(current)) {
+      if (key === "constructor" || functions.has(key))
+        continue;
+      const descriptor = Object.getOwnPropertyDescriptor(current, key);
+      if (descriptor && typeof descriptor.value === "function") {
+        functions.set(key, descriptor.value);
+      }
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return functions;
+}
+function applyResolverFieldMetadata(schema, resolvers) {
+  if (typeof Reflect.getMetadata !== "function") {
+    return;
+  }
+  const maps = Array.isArray(resolvers) ? resolvers : [resolvers];
+  for (const map of maps) {
+    for (const [typeName, container] of Object.entries(map ?? {})) {
+      if (!container || typeof container !== "object")
+        continue;
+      const type = schema.getType(typeName);
+      if (!type || typeof type.getFields !== "function") {
+        continue;
+      }
+      const fields = type.getFields();
+      for (const [fieldName, fn] of collectResolverFunctions(container)) {
+        const field = fields[fieldName];
+        if (!field)
+          continue;
+        const description = Reflect.getMetadata(DESCRIPTION_KEY, fn);
+        if (typeof description === "string") {
+          field.description = description;
+        }
+        const deprecationReason = Reflect.getMetadata(DEPRECATED_KEY, fn);
+        if (typeof deprecationReason === "string") {
+          field.deprecationReason = deprecationReason;
+        }
+      }
+    }
+  }
+}
+function stripDescriptions(sdl) {
+  const strippedAst = visit(parse2(sdl), {
+    enter(node) {
+      if ("description" in node && node.description) {
+        const { description: _description, ...rest } = node;
+        return rest;
+      }
+      return;
+    }
+  });
+  return print2(strippedAst);
+}
 async function generateSchemaFile(schema, options) {
-  const { printSchema, lexicographicSortSchema } = __require("graphql");
-  const { writeFile } = __require("fs/promises");
-  let schemaToWrite = schema;
-  if (options.sortSchema) {
-    schemaToWrite = lexicographicSortSchema(schema);
-  }
-  const sdl = printSchema(schemaToWrite);
-  await writeFile(options.path, sdl, "utf-8");
+  const schemaToWrite = options.sortSchema ? lexicographicSortSchema(schema) : schema;
+  let sdl = printSchema(schemaToWrite);
+  if (options.includeDescriptions === false) {
+    sdl = stripDescriptions(sdl);
+  }
+  await Bun.write(options.path, sdl);
 }
 var resolverMetadataStorage = [];
 function getResolverMetadata() {
@@ -1023,8 +1097,17 @@ function registerResolverMetadata(metadata) {
 function clearResolverMetadata() {
   resolverMetadataStorage.length = 0;
 }
+
 // src/subscriptions.ts
-import { Injectable as Injectable6, Inject as Inject4 } from "@nestjs/common";
+import {
+  Injectable as Injectable5,
+  Inject as Inject4,
+  SetMetadata as SetMetadata3
+} from "@nestjs/common";
+import { parse as parse3, getOperationAST } from "graphql";
+var SOCKET_OPEN = 1;
+var ITERATOR_TEARDOWN_TIMEOUT_MS = 1000;
+
 class SubscriptionManager {
   options;
   driver;
@@ -1037,20 +1120,55 @@ class SubscriptionManager {
   }
   async onModuleInit() {}
   async onModuleDestroy() {
-    for (const [socket] of this.connections) {
+    const sockets = [...this.connections.keys()];
+    await Promise.all(sockets.map((socket) => this.handleClose(socket)));
+    for (const socket of sockets) {
       socket.close(1000, "Server shutdown");
     }
     this.connections.clear();
   }
   normalizeConfig() {
+    const userConfig = this.options.subscriptions ?? {};
+    return {
+      ...userConfig,
+      path: userConfig.path ?? this.options.path ?? "/graphql",
+      keepAlive: userConfig.keepAlive ?? 12000,
+      connectionInitWaitTimeout: userConfig.connectionInitWaitTimeout ?? 3000,
+      maxSubscriptionsPerConnection: userConfig.maxSubscriptionsPerConnection ?? 100
+    };
+  }
+  getPath() {
+    return this.config.path ?? "/graphql";
+  }
+  getWebSocketConfig() {
     return {
-      path: this.options.path ?? "/graphql",
-      keepAlive: 12000,
-      connectionInitWaitTimeout: 3000,
-      maxSubscriptionsPerConnection: 100
+      open: (socket) => {
+        this.handleOpen(socket);
+      },
+      message: (socket, message) => {
+        this.handleMessage(socket, message).catch((error) => console.error("WebSocket message handling failed:", error));
+      },
+      close: (socket) => {
+        this.handleClose(socket).catch((error) => console.error("WebSocket close handling failed:", error));
+      }
     };
   }
+  handleOpen(socket, request) {
+    this.openConnection(socket, request);
+  }
   async handleConnection(socket, request) {
+    this.openConnection(socket, request);
+    socket.addEventListener("message", (event) => {
+      this.handleMessage(socket, event.data).catch((error) => console.error("WebSocket message handling failed:", error));
+    });
+    socket.addEventListener("close", () => {
+      this.handleClose(socket).catch((e) => console.error("WebSocket close handling failed:", e));
+    });
+    socket.addEventListener("error", (error) => {
+      this.handleError(socket, error);
+    });
+  }
+  openConnection(socket, request) {
     const state = {
       socket,
       request,
@@ -1058,30 +1176,36 @@ class SubscriptionManager {
       initialized: false,
       connectionParams: undefined,
       context: undefined,
-      keepAliveInterval: undefined
+      keepAliveInterval: undefined,
+      initTimeout: undefined
     };
     this.connections.set(socket, state);
-    socket.addEventListener("message", (event) => {
-      this.handleMessage(socket, event.data);
-    });
-    socket.addEventListener("close", () => {
-      this.handleClose(socket);
-    });
-    socket.addEventListener("error", (error) => {
-      this.handleError(socket, error);
-    });
-    setTimeout(() => {
+    state.initTimeout = setTimeout(() => {
+      state.initTimeout = undefined;
       if (!state.initialized) {
         socket.close(4408, "Connection initialization timeout");
       }
     }, this.config.connectionInitWaitTimeout);
+    return state;
   }
   async handleMessage(socket, data) {
     const state = this.connections.get(socket);
     if (!state)
       return;
+    let message;
+    try {
+      const parsed = JSON.parse(typeof data === "string" ? data : new TextDecoder().decode(data));
+      if (parsed === null || typeof parsed !== "object" || typeof parsed.type !== "string") {
+        socket.close(4400, "Bad Request");
+        return;
+      }
+      message = parsed;
+    } catch (error) {
+      console.error("Error parsing WebSocket message:", error);
+      socket.close(4400, "Bad Request");
+      return;
+    }
     try {
-      const message = JSON.parse(data);
       switch (message.type) {
         case "connection_init":
           await this.handleConnectionInit(socket, state, message);
@@ -1098,10 +1222,18 @@ class SubscriptionManager {
           await this.handleComplete(socket, state, message);
           break;
         default:
+          socket.close(4400, "Bad Request");
           break;
       }
     } catch (error) {
       console.error("Error handling WebSocket message:", error);
+      const type = message.type;
+      const id = message.id;
+      if ((type === "subscribe" || type === "complete") && typeof id === "string") {
+        this.sendError(socket, id, "Internal server error");
+      } else {
+        socket.close(1011, "Internal server error");
+      }
     }
   }
   async handleConnectionInit(socket, state, message) {
@@ -1124,6 +1256,10 @@ class SubscriptionManager {
     }
     state.initialized = true;
     state.context = ctx;
+    if (state.initTimeout) {
+      clearTimeout(state.initTimeout);
+      state.initTimeout = undefined;
+    }
     this.send(socket, { type: "connection_ack" });
     if (this.config.keepAlive) {
       state.keepAliveInterval = setInterval(() => {
@@ -1136,50 +1272,150 @@ class SubscriptionManager {
       socket.close(4401, "Unauthorized");
       return;
     }
+    if (typeof message.id !== "string" || typeof message.payload?.query !== "string") {
+      socket.close(4400, "Bad Request");
+      return;
+    }
+    if (state.subscriptions.has(message.id)) {
+      socket.close(4409, `Subscriber already exists: ${message.id}`);
+      return;
+    }
     if (state.subscriptions.size >= (this.config.maxSubscriptionsPerConnection ?? 100)) {
       this.sendError(socket, message.id, "Too many subscriptions");
       return;
     }
-    if (this.config.onSubscribe && state.context) {
-      await this.config.onSubscribe(state.context, message);
+    const streaming = this.isSubscriptionOperation(message.payload.query, message.payload.operationName);
+    let registration;
+    if (streaming) {
+      registration = { clientId: message.id };
+      state.subscriptions.set(message.id, registration);
     }
     try {
+      if (this.config.onSubscribe && state.context) {
+        await this.config.onSubscribe(state.context, message);
+      }
       const schema = this.driver.getSchema();
       if (!schema) {
+        if (registration && state.subscriptions.get(message.id) === registration) {
+          state.subscriptions.delete(message.id);
+        }
         this.sendError(socket, message.id, "Schema not available");
         return;
       }
       let context = {
         req: state.request,
         res: {},
-        ...state.connectionParams
+        connectionParams: state.connectionParams
       };
       if (this.config.context && state.context) {
         context = await this.config.context(state.context);
       }
-      const result = await this.driver.execute(message.payload.query, message.payload.variables, context, message.payload.operationName);
-      if (result.data || result.errors) {
-        this.send(socket, {
-          id: message.id,
-          type: "next",
-          payload: result
-        });
-        this.send(socket, { id: message.id, type: "complete" });
+      let args = {
+        schema,
+        document: message.payload.query,
+        contextValue: context,
+        variableValues: message.payload.variables,
+        operationName: message.payload.operationName
+      };
+      if (this.config.onOperation && state.context) {
+        args = await this.config.onOperation(state.context, message, args);
+      }
+      if (registration) {
+        await this.startStream(socket, state, message.id, args, registration);
         return;
       }
-      state.subscriptions.set(message.id, {
-        message,
-        context
+      const result = await this.driver.execute(args.document, args.variableValues, args.contextValue, args.operationName);
+      this.send(socket, {
+        id: message.id,
+        type: "next",
+        payload: result
       });
+      this.send(socket, { id: message.id, type: "complete" });
     } catch (error) {
+      if (registration && state.subscriptions.get(message.id) === registration) {
+        state.subscriptions.delete(message.id);
+      }
       const errorMessage = error instanceof Error ? error.message : "Subscription failed";
       this.sendError(socket, message.id, errorMessage);
     }
   }
+  async startStream(socket, state, id, args, registration) {
+    const result = await this.driver.subscribe(args.document, args.variableValues, args.contextValue, args.operationName);
+    if (!(Symbol.asyncIterator in result)) {
+      if (state.subscriptions.get(id) === registration) {
+        state.subscriptions.delete(id);
+      }
+      const errors = result.errors ?? [{ message: "Subscription failed" }];
+      this.send(socket, { id, type: "error", payload: [...errors] });
+      return;
+    }
+    const iterator = result;
+    if (state.subscriptions.get(id) !== registration) {
+      await this.closeIterator(iterator);
+      return;
+    }
+    registration.iterator = iterator;
+    this.pumpStream(socket, state, id, registration, iterator).catch((error) => {
+      console.error(`Subscription pump failed for operation ${id}:`, error);
+      state.subscriptions.delete(id);
+    });
+  }
+  async pumpStream(socket, state, id, registration, iterator) {
+    const owns = () => state.subscriptions.get(id) === registration;
+    try {
+      for await (const payload of iterator) {
+        if (!owns()) {
+          return;
+        }
+        this.send(socket, { id, type: "next", payload });
+      }
+      if (owns()) {
+        this.send(socket, { id, type: "complete" });
+      }
+    } catch (error) {
+      if (owns()) {
+        const message = error instanceof Error ? error.message : "Subscription failed";
+        this.sendError(socket, id, message);
+      }
+    } finally {
+      if (owns()) {
+        state.subscriptions.delete(id);
+      }
+    }
+  }
+  async closeIterator(iterator) {
+    if (!iterator?.return) {
+      return;
+    }
+    const teardown = Promise.resolve().then(() => iterator.return?.()).then(() => "settled").catch((error) => {
+      console.error("Subscription iterator teardown failed:", error);
+      return "settled";
+    });
+    let timer;
+    const deadline = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("timeout"), ITERATOR_TEARDOWN_TIMEOUT_MS);
+    });
+    try {
+      if (await Promise.race([teardown, deadline]) === "timeout") {
+        console.error(`Subscription iterator did not finish teardown within ${ITERATOR_TEARDOWN_TIMEOUT_MS}ms; ` + "abandoning it. The resolver is most likely an async generator suspended " + "awaiting an event that never arrives, which cancellation cannot resume.");
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  isSubscriptionOperation(query, operationName) {
+    try {
+      const document = parse3(query);
+      return getOperationAST(document, operationName)?.operation === "subscription";
+    } catch {
+      return false;
+    }
+  }
   async handleComplete(socket, state, message) {
     const subscription = state.subscriptions.get(message.id);
     if (subscription) {
       state.subscriptions.delete(message.id);
+      await this.closeIterator(subscription.iterator);
       if (this.config.onComplete && state.context) {
         await this.config.onComplete(state.context, message);
       }
@@ -1191,21 +1427,32 @@ class SubscriptionManager {
       return;
     if (state.keepAliveInterval) {
       clearInterval(state.keepAliveInterval);
+      state.keepAliveInterval = undefined;
     }
-    if (this.config.onDisconnect && state.context) {
-      await this.config.onDisconnect(state.context);
+    if (state.initTimeout) {
+      clearTimeout(state.initTimeout);
+      state.initTimeout = undefined;
     }
+    const subscriptions = [...state.subscriptions.values()];
     state.subscriptions.clear();
     this.connections.delete(ws);
+    await Promise.all(subscriptions.map((s) => this.closeIterator(s.iterator)));
+    if (this.config.onDisconnect && state.context) {
+      try {
+        await this.config.onDisconnect(state.context);
+      } catch (error) {
+        console.error("onDisconnect hook failed:", error);
+      }
+    }
   }
   handleError(ws, _error) {
     const state = this.connections.get(ws);
     if (state) {
-      this.handleClose(ws);
+      this.handleClose(ws).catch((e) => console.error("WebSocket close handling failed:", e));
     }
   }
   send(socket, message) {
-    if (socket.readyState === WebSocket.OPEN) {
+    if (socket.readyState === SOCKET_OPEN) {
       socket.send(JSON.stringify(message));
     }
   }
@@ -1216,18 +1463,36 @@ class SubscriptionManager {
       payload: [{ message }]
     });
   }
-  publish(id, payload) {
+  registerSubscription(socket, clientId, topic, context) {
+    const state = this.connections.get(socket);
+    if (!state || !state.initialized) {
+      return false;
+    }
+    if (state.subscriptions.has(clientId)) {
+      return false;
+    }
+    if (state.subscriptions.size >= (this.config.maxSubscriptionsPerConnection ?? 100)) {
+      return false;
+    }
+    state.subscriptions.set(clientId, { clientId, topic, context });
+    return true;
+  }
+  publishToTopic(topic, payload) {
     for (const [socket, state] of this.connections) {
-      const subscription = state.subscriptions.get(id);
-      if (subscription) {
-        this.send(socket, {
-          id,
-          type: "next",
-          payload: { data: payload }
-        });
+      for (const subscription of state.subscriptions.values()) {
+        if (subscription.topic === topic) {
+          this.send(socket, {
+            id: subscription.clientId,
+            type: "next",
+            payload: { data: payload }
+          });
+        }
       }
     }
   }
+  publish(topic, payload) {
+    this.publishToTopic(topic, payload);
+  }
   getConnectionCount() {
     return this.connections.size;
   }
@@ -1240,7 +1505,7 @@ class SubscriptionManager {
   }
 }
 SubscriptionManager = __legacyDecorateClassTS([
-  Injectable6(),
+  Injectable5(),
   __legacyDecorateParamTS(0, Inject4(LEAVEN_MODULE_OPTIONS)),
   __legacyDecorateParamTS(1, Inject4(LEAVEN_DRIVER)),
   __legacyMetadataTS("design:paramtypes", [
@@ -1249,73 +1514,593 @@ SubscriptionManager = __legacyDecorateClassTS([
   ])
 ], SubscriptionManager);
 function Subscription(returns, options) {
-  return (_target, _propertyKey, descriptor) => {
-    if (descriptor.value) {
+  return (target, propertyKey, descriptor) => {
+    const filter = options?.filter;
+    if (filter) {
+      wrapWithFilter(descriptor, filter);
+      SetMetadata3(SUBSCRIPTION_FILTER_KEY, filter)(target, propertyKey, descriptor);
+    }
+    if (descriptor.value && typeof Reflect.defineMetadata === "function") {
       Reflect.defineMetadata("leaven:subscription", { returns, options }, descriptor.value);
     }
     return descriptor;
   };
 }
 function InjectPubSub() {
-  return (_target, propertyKey, parameterIndex) => {
-    if (_target && propertyKey !== undefined) {
-      const existingParams = Reflect.getMetadata("leaven:inject:pubsub", _target, propertyKey) || [];
-      existingParams.push(parameterIndex);
-      Reflect.defineMetadata("leaven:inject:pubsub", existingParams, _target, propertyKey);
-    }
-  };
+  return Inject4(LEAVEN_PUBSUB);
 }
-export {
-  registerResolverMetadata,
-  getResolverMetadata,
-  getGqlRoot,
-  getGqlInfo,
-  getGqlContext2 as getGqlContext,
-  getGqlArgs,
-  generateSchemaFile,
-  createGraphQLMiddleware,
-  createContextDecorator,
-  clearResolverMetadata,
-  SubscriptionManager,
-  SubscriptionFilter,
-  Subscription,
-  SchemaBuilderService,
-  SUBSCRIPTION_FILTER_KEY,
-  Root,
-  RolesGuard,
-  Roles,
-  ROLES_KEY,
-  Public,
-  PermissionsGuard,
-  Permissions,
-  Parent,
-  PERMISSIONS_KEY,
-  MetricsInterceptor,
-  LoggingInterceptor,
-  LeavenModule,
-  LeavenDriver,
-  LEAVEN_MODULE_OPTIONS,
-  LEAVEN_DRIVER,
-  InjectPubSub,
-  Info,
-  IS_PUBLIC_KEY,
-  GraphQLMiddleware,
-  GqlExecutionContext,
-  ErrorFormattingInterceptor,
-  Description,
-  DepthGuard,
-  Deprecated,
-  Decorators,
-  DESCRIPTION_KEY,
-  DEPRECATED_KEY,
-  Context,
-  ComplexityInterceptor,
-  ComplexityGuard,
-  Complexity,
-  CachingInterceptor,
-  CacheHint,
-  COMPLEXITY_KEY,
-  CACHE_KEY,
-  AuthGuard,
-  Args
+
+// src/module.ts
+class LeavenModule {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  configure(consumer) {
+    if (!this.options) {
+      return;
+    }
+    consumer.apply(GraphQLMiddleware).forRoutes(this.options.path ?? "/graphql");
+  }
+  static forRoot(options = {}) {
+    const optionsProvider = {
+      provide: LEAVEN_MODULE_OPTIONS,
+      useValue: options
+    };
+    const driverProvider = {
+      provide: LEAVEN_DRIVER,
+      useFactory: (opts) => new LeavenDriver(opts),
+      inject: [LEAVEN_MODULE_OPTIONS]
+    };
+    return {
+      module: LeavenModule,
+      providers: [
+        optionsProvider,
+        driverProvider,
+        ...LeavenModule.createLimitProviders(),
+        LeavenModule.createPubSubProvider(),
+        SchemaBuilderService,
+        SubscriptionManager,
+        GraphQLMiddleware
+      ],
+      exports: [
+        LEAVEN_MODULE_OPTIONS,
+        LEAVEN_DRIVER,
+        LEAVEN_MAX_COMPLEXITY,
+        LEAVEN_MAX_DEPTH,
+        LEAVEN_PUBSUB,
+        SchemaBuilderService,
+        SubscriptionManager
+      ]
+    };
+  }
+  static createLimitProviders() {
+    return [
+      {
+        provide: LEAVEN_MAX_COMPLEXITY,
+        useFactory: (opts) => opts.maxComplexity ?? Infinity,
+        inject: [LEAVEN_MODULE_OPTIONS]
+      },
+      {
+        provide: LEAVEN_MAX_DEPTH,
+        useFactory: (opts) => opts.maxDepth ?? Infinity,
+        inject: [LEAVEN_MODULE_OPTIONS]
+      }
+    ];
+  }
+  static createPubSubProvider() {
+    return {
+      provide: LEAVEN_PUBSUB,
+      useFactory: (opts) => opts.pubSub ?? createPubSub(),
+      inject: [LEAVEN_MODULE_OPTIONS]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    const driverProvider = {
+      provide: LEAVEN_DRIVER,
+      useFactory: (opts) => new LeavenDriver(opts),
+      inject: [LEAVEN_MODULE_OPTIONS]
+    };
+    return {
+      module: LeavenModule,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        driverProvider,
+        ...LeavenModule.createLimitProviders(),
+        LeavenModule.createPubSubProvider(),
+        SchemaBuilderService,
+        SubscriptionManager,
+        GraphQLMiddleware
+      ],
+      exports: [
+        LEAVEN_MODULE_OPTIONS,
+        LEAVEN_DRIVER,
+        LEAVEN_MAX_COMPLEXITY,
+        LEAVEN_MAX_DEPTH,
+        LEAVEN_PUBSUB,
+        SchemaBuilderService,
+        SubscriptionManager
+      ]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (!options.useFactory && !options.useClass && !options.useExisting) {
+      throw new Error("LeavenModule.forRootAsync requires one of useFactory, useClass, or useExisting");
+    }
+    if (options.useExisting || options.useFactory) {
+      return [this.createAsyncOptionsProvider(options)];
+    }
+    const useClass = options.useClass;
+    return [
+      this.createAsyncOptionsProvider(options),
+      {
+        provide: useClass,
+        useClass
+      }
+    ];
+  }
+  static createAsyncOptionsProvider(options) {
+    if (options.useFactory) {
+      return {
+        provide: LEAVEN_MODULE_OPTIONS,
+        useFactory: options.useFactory,
+        inject: options.inject ?? []
+      };
+    }
+    const inject = [
+      options.useClass ?? options.useExisting
+    ];
+    return {
+      provide: LEAVEN_MODULE_OPTIONS,
+      useFactory: async (optionsFactory) => optionsFactory.createLeavenOptions(),
+      inject
+    };
+  }
+}
+LeavenModule = __legacyDecorateClassTS([
+  Global(),
+  Module({}),
+  __legacyDecorateParamTS(0, Optional()),
+  __legacyDecorateParamTS(0, Inject5(LEAVEN_MODULE_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions
+  ])
+], LeavenModule);
+// src/graphql-driver.ts
+import { HttpException } from "@nestjs/common";
+import { AbstractGraphQLDriver } from "@nestjs/graphql";
+import { LeavenExecutor as LeavenExecutor2 } from "@leaven-graphql/core";
+import {
+  ERROR_CODES,
+  ErrorCode,
+  formatError as formatError3,
+  getErrorCode,
+  isLeavenError as isLeavenError3
+} from "@leaven-graphql/errors";
+import { renderGraphiQL as renderGraphiQL2 } from "@leaven-graphql/playground";
+var HTTP_STATUS_TO_ERROR_CODE = {
+  400: ErrorCode.BAD_REQUEST,
+  401: ErrorCode.UNAUTHENTICATED,
+  403: ErrorCode.FORBIDDEN,
+  404: ErrorCode.NOT_FOUND,
+  409: ErrorCode.ALREADY_EXISTS,
+  413: ErrorCode.PAYLOAD_TOO_LARGE,
+  429: ErrorCode.RATE_LIMITED
+};
+
+class LeavenGraphQLDriver extends AbstractGraphQLDriver {
+  executor = null;
+  options = null;
+  async start(options) {
+    if (!options.schema) {
+      throw new Error("LeavenGraphQLDriver: no schema was provided to start(). This is normally supplied by GraphQLModule.");
+    }
+    this.options = options;
+    this.executor = new LeavenExecutor2({
+      schema: options.schema,
+      cache: options.cache,
+      metrics: options.metrics,
+      maxComplexity: options.maxComplexity,
+      maxDepth: options.maxDepth,
+      introspection: options.introspection ?? true,
+      formatExecutionError: LeavenGraphQLDriver.formatExecutionError
+    });
+    const path = this.getNormalizedPath(options);
+    const httpAdapter = this.httpAdapterHost.httpAdapter;
+    httpAdapter.post(path, (req, res) => this.handleOperation(req, res));
+    if (options.playground) {
+      httpAdapter.get(path, (_req, res) => {
+        this.servePlayground(res, path);
+      });
+    }
+  }
+  async stop() {
+    if (this.executor) {
+      await this.executor.clearCaches();
+      this.executor = null;
+    }
+  }
+  getExecutor() {
+    return this.executor;
+  }
+  async handleOperation(req, res) {
+    if (!this.executor) {
+      res.status(503).json({
+        errors: [
+          {
+            message: "GraphQL server is not running",
+            extensions: { code: ErrorCode.INTERNAL_ERROR }
+          }
+        ]
+      });
+      return;
+    }
+    let body;
+    try {
+      body = await LeavenGraphQLDriver.readBody(req);
+    } catch {
+      this.respond(res, {
+        errors: [
+          {
+            message: "Malformed request body: expected JSON",
+            extensions: { code: ErrorCode.BAD_REQUEST }
+          }
+        ]
+      });
+      return;
+    }
+    if (!body.query) {
+      this.respond(res, {
+        errors: [
+          {
+            message: "Query is required",
+            extensions: { code: ErrorCode.BAD_REQUEST }
+          }
+        ]
+      });
+      return;
+    }
+    const context = await this.buildContext(req, res);
+    try {
+      const result = await this.executor.execute({
+        query: body.query,
+        variables: body.variables,
+        operationName: body.operationName
+      }, context);
+      const extensions = this.options?.metrics && result.metrics ? { ...result.response.extensions, metrics: result.metrics } : result.response.extensions;
+      this.respond(res, {
+        data: result.response.data,
+        errors: result.response.errors,
+        extensions
+      });
+    } catch (error) {
+      this.respond(res, { errors: [this.formatThrownError(error)] });
+    }
+  }
+  servePlayground(res, path) {
+    const html = renderGraphiQL2({
+      endpoint: path,
+      subscriptionEndpoint: this.options?.subscriptionEndpoint
+    });
+    res.setHeader("Content-Type", "text/html; charset=utf-8");
+    res.send(html);
+  }
+  async buildContext(req, res) {
+    const base = { req, res };
+    const factory = this.options?.context;
+    if (typeof factory === "function") {
+      const produced = await factory(base);
+      return { ...base, ...produced };
+    }
+    if (factory && typeof factory === "object") {
+      return { ...base, ...factory };
+    }
+    return base;
+  }
+  respond(res, response) {
+    const errors = response.errors?.map((error) => this.finalizeError(error));
+    const hasErrors = errors !== undefined && errors.length > 0;
+    const totalFailure = response.data === undefined || response.data === null;
+    let status = 200;
+    if (hasErrors && totalFailure) {
+      const code = errors[0]?.extensions?.code;
+      const known = typeof code === "string" ? getErrorCode(code) : null;
+      status = known ? ERROR_CODES[known].status : 500;
+    }
+    const body = {};
+    if (response.data !== undefined) {
+      body.data = response.data;
+    }
+    if (hasErrors) {
+      body.errors = errors;
+    }
+    if (response.extensions !== undefined) {
+      body.extensions = response.extensions;
+    }
+    res.status(status).json(body);
+  }
+  finalizeError(error) {
+    const rawCode = error.extensions?.code;
+    const code = typeof rawCode === "string" ? getErrorCode(rawCode) : null;
+    const resolved = code ?? ErrorCode.INTERNAL_ERROR;
+    const includeStack = this.options?.includeStacktraceInErrorResponses ?? false;
+    const mask = resolved === ErrorCode.INTERNAL_ERROR && false;
+    const finalized = mask ? {
+      message: "An unexpected error occurred",
+      extensions: { code: ErrorCode.INTERNAL_ERROR }
+    } : {
+      ...error,
+      extensions: { ...error.extensions, code: resolved }
+    };
+    return this.options?.formatError ? this.options.formatError(finalized) : finalized;
+  }
+  formatThrownError(error) {
+    const includeStack = this.options?.includeStacktraceInErrorResponses ?? false;
+    const formatted = formatError3(error, {
+      maskErrors: !isLeavenError3(error) && false,
+      includeStackTrace: includeStack
+    });
+    return this.options?.formatError ? this.options.formatError(formatted) : formatted;
+  }
+  static async readBody(req) {
+    const raw = req.body;
+    if (typeof raw === "string") {
+      return JSON.parse(raw);
+    }
+    if (raw !== null && typeof raw === "object" && !(raw instanceof ArrayBuffer)) {
+      return raw;
+    }
+    const json = req.raw?.json;
+    if (json) {
+      return await json.call(req.raw);
+    }
+    return {};
+  }
+  static formatExecutionError(error) {
+    const formatted = error.toJSON();
+    const original = error.originalError;
+    if (!(original instanceof HttpException)) {
+      return formatted;
+    }
+    const status = original.getStatus();
+    const code = HTTP_STATUS_TO_ERROR_CODE[status] ?? (status >= 400 && status < 500 ? ErrorCode.BAD_REQUEST : ErrorCode.INTERNAL_ERROR);
+    return {
+      ...formatted,
+      extensions: { ...formatted.extensions, code, statusCode: status }
+    };
+  }
+}
+// src/interceptors.ts
+import {
+  Injectable as Injectable6
+} from "@nestjs/common";
+import { tap, catchError, throwError } from "rxjs";
+import { Reflector as Reflector2 } from "@nestjs/core";
+import { GraphQLError as GraphQLError2 } from "graphql";
+import { errorToGraphQL, maskError } from "@leaven-graphql/errors";
+class LoggingInterceptor {
+  intercept(context, next) {
+    const className = context.getClass().name;
+    const methodName = context.getHandler().name;
+    const start = performance.now();
+    return next.handle().pipe(tap(() => {
+      const duration = (performance.now() - start).toFixed(2);
+      console.log(`[GraphQL] ${className}.${methodName} - ${duration}ms`);
+    }), catchError((error) => {
+      const duration = (performance.now() - start).toFixed(2);
+      console.error(`[GraphQL] ${className}.${methodName} - ${duration}ms - failed:`, error);
+      return throwError(() => error);
+    }));
+  }
+}
+LoggingInterceptor = __legacyDecorateClassTS([
+  Injectable6()
+], LoggingInterceptor);
+
+class ErrorFormattingInterceptor {
+  intercept(_context, next) {
+    return next.handle().pipe(catchError((error) => {
+      const formattedError = this.formatError(error);
+      return throwError(() => formattedError);
+    }));
+  }
+  formatError(error) {
+    const isProduction = false;
+    const source = errorToGraphQL(error);
+    const formatted = maskError(source, {
+      maskErrors: isProduction,
+      includeStackTrace: !isProduction
+    });
+    const keepLocations = formatted.locations !== undefined;
+    return new GraphQLError2(formatted.message, {
+      nodes: keepLocations ? source.nodes : undefined,
+      source: keepLocations ? source.source : undefined,
+      positions: keepLocations ? source.positions : undefined,
+      path: formatted.path,
+      extensions: formatted.extensions
+    });
+  }
+}
+ErrorFormattingInterceptor = __legacyDecorateClassTS([
+  Injectable6()
+], ErrorFormattingInterceptor);
+
+class ComplexityInterceptor {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  intercept(context, next) {
+    const complexity = this.reflector.get(COMPLEXITY_KEY, context.getHandler());
+    if (complexity !== undefined) {
+      const gqlContext = getGqlContext(context);
+      if (gqlContext) {
+        const current = typeof gqlContext._resolvedFieldComplexity === "number" ? gqlContext._resolvedFieldComplexity : 0;
+        gqlContext._resolvedFieldComplexity = current + complexity;
+      }
+    }
+    return next.handle();
+  }
+}
+ComplexityInterceptor = __legacyDecorateClassTS([
+  Injectable6(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Reflector2 === "undefined" ? Object : Reflector2
+  ])
+], ComplexityInterceptor);
+
+class CachingInterceptor {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  intercept(context, next) {
+    const cacheHint = this.reflector.get(CACHE_KEY, context.getHandler());
+    return next.handle().pipe(tap(() => {
+      if (cacheHint) {
+        const gqlInfo = getGqlInfo(context);
+        if (gqlInfo?.cacheControl) {
+          gqlInfo.cacheControl.setCacheHint({
+            maxAge: cacheHint.maxAge,
+            scope: cacheHint.scope
+          });
+        }
+      }
+    }));
+  }
+}
+CachingInterceptor = __legacyDecorateClassTS([
+  Injectable6(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Reflector2 === "undefined" ? Object : Reflector2
+  ])
+], CachingInterceptor);
+
+class MetricsInterceptor {
+  metrics = new Map;
+  intercept(context, next) {
+    const className = context.getClass().name;
+    const methodName = context.getHandler().name;
+    const key = `${className}.${methodName}`;
+    const start = performance.now();
+    return next.handle().pipe(tap(() => {
+      const duration = performance.now() - start;
+      this.recordSuccess(key, duration);
+    }), catchError((error) => {
+      const duration = performance.now() - start;
+      this.recordError(key, duration);
+      return throwError(() => error);
+    }));
+  }
+  recordSuccess(key, duration) {
+    const metrics = this.getOrCreateMetrics(key);
+    metrics.totalCount++;
+    metrics.successCount++;
+    metrics.totalDuration += duration;
+    metrics.lastDuration = duration;
+    metrics.minDuration = Math.min(metrics.minDuration, duration);
+    metrics.maxDuration = Math.max(metrics.maxDuration, duration);
+  }
+  recordError(key, duration) {
+    const metrics = this.getOrCreateMetrics(key);
+    metrics.totalCount++;
+    metrics.errorCount++;
+    metrics.totalDuration += duration;
+    metrics.lastDuration = duration;
+    metrics.minDuration = Math.min(metrics.minDuration, duration);
+    metrics.maxDuration = Math.max(metrics.maxDuration, duration);
+  }
+  getOrCreateMetrics(key) {
+    let metrics = this.metrics.get(key);
+    if (!metrics) {
+      metrics = {
+        totalCount: 0,
+        successCount: 0,
+        errorCount: 0,
+        totalDuration: 0,
+        lastDuration: 0,
+        minDuration: Infinity,
+        maxDuration: 0
+      };
+      this.metrics.set(key, metrics);
+    }
+    return metrics;
+  }
+  getMetrics() {
+    return new Map(this.metrics);
+  }
+  getSummary() {
+    return Array.from(this.metrics.entries()).map(([operation, metrics]) => ({
+      operation,
+      ...metrics,
+      averageDuration: metrics.totalCount > 0 ? metrics.totalDuration / metrics.totalCount : 0,
+      errorRate: metrics.totalCount > 0 ? metrics.errorCount / metrics.totalCount : 0
+    }));
+  }
+  reset() {
+    this.metrics.clear();
+  }
+}
+MetricsInterceptor = __legacyDecorateClassTS([
+  Injectable6()
+], MetricsInterceptor);
+export {
+  Args,
+  AuthGuard,
+  CACHE_KEY,
+  COMPLEXITY_KEY,
+  CacheHint,
+  CachingInterceptor,
+  Complexity,
+  ComplexityGuard,
+  ComplexityInterceptor,
+  Context,
+  DEPRECATED_KEY,
+  DESCRIPTION_KEY,
+  Decorators,
+  Deprecated,
+  DepthGuard,
+  Description,
+  ErrorFormattingInterceptor,
+  GqlExecutionContext,
+  GraphQLMiddleware,
+  IS_PUBLIC_KEY,
+  Info,
+  InjectPubSub,
+  LEAVEN_DRIVER,
+  LEAVEN_MAX_COMPLEXITY,
+  LEAVEN_MAX_DEPTH,
+  LEAVEN_MODULE_OPTIONS,
+  LEAVEN_PUBSUB,
+  LeavenDriver,
+  LeavenGraphQLDriver,
+  LeavenModule,
+  LoggingInterceptor,
+  MetricsInterceptor,
+  PERMISSIONS_KEY,
+  Parent,
+  Permissions,
+  PermissionsGuard,
+  Public,
+  ROLES_KEY,
+  Roles,
+  RolesGuard,
+  Root,
+  SUBSCRIPTION_FILTER_KEY,
+  SchemaBuilderService,
+  Subscription,
+  SubscriptionFilter,
+  SubscriptionManager,
+  clearResolverMetadata,
+  createContextDecorator,
+  createGraphQLMiddleware,
+  generateSchemaFile,
+  getGqlArgs,
+  getGqlContext,
+  getGqlInfo,
+  getGqlRoot,
+  getResolverMetadata,
+  registerResolverMetadata
 };