@leaven-graphql/nestjs 0.1.0

package/dist/index.js

@@ -0,0 +1,1321 @@
+// @bun
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+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
+} 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;
+  }
+  async onModuleInit() {
+    if (this.options.schema) {
+      this.schema = this.options.schema;
+      this.initializeExecutor();
+    }
+  }
+  async onModuleDestroy() {
+    if (this.executor) {
+      this.executor.clearCaches();
+      this.executor = null;
+    }
+  }
+  setSchema(schema) {
+    this.schema = schema;
+    this.initializeExecutor();
+  }
+  getSchema() {
+    return this.schema;
+  }
+  getExecutor() {
+    return this.executor;
+  }
+  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);
+  }
+  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
+        ]
+      };
+    }
+  }
+  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 (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");
+    }
+    return {
+      query,
+      variables: variables ? JSON.parse(variables) : undefined,
+      operationName: operationName ?? undefined
+    };
+  }
+  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;
+  }
+  documentToString(document) {
+    const { print } = __require("graphql");
+    return print(document);
+  }
+  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;
+  }
+  clearCaches() {
+    this.executor?.clearCaches();
+  }
+}
+LeavenDriver = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions
+  ])
+], 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);
+
+class RolesGuard {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  canActivate(context) {
+    const requiredRoles = this.reflector.getAllAndOverride(ROLES_KEY, [
+      context.getHandler(),
+      context.getClass()
+    ]);
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
+    }
+    const gqlContext = this.getGqlContext(context);
+    const user = this.extractUser(gqlContext);
+    if (!user) {
+      throw new UnauthorizedException("Authentication required");
+    }
+    const userRoles = this.extractRoles(user);
+    const hasRole = requiredRoles.some((role) => userRoles.includes(role));
+    if (!hasRole) {
+      throw new ForbiddenException(`Required roles: ${requiredRoles.join(", ")}`);
+    }
+    return true;
+  }
+  getGqlContext(context) {
+    const args = context.getArgs();
+    return args[2];
+  }
+  extractUser(context) {
+    return context.user ?? context.req?.user ?? null;
+  }
+  extractRoles(user) {
+    const userObj = user;
+    const roles = userObj?.roles ?? userObj?.role;
+    if (Array.isArray(roles)) {
+      return roles.map(String);
+    }
+    if (typeof roles === "string") {
+      return [roles];
+    }
+    return [];
+  }
+}
+RolesGuard = __legacyDecorateClassTS([
+  Injectable2(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector
+  ])
+], RolesGuard);
+
+class PermissionsGuard {
+  reflector;
+  constructor(reflector) {
+    this.reflector = reflector;
+  }
+  canActivate(context) {
+    const requiredPermissions = this.reflector.getAllAndOverride(PERMISSIONS_KEY, [context.getHandler(), context.getClass()]);
+    if (!requiredPermissions || requiredPermissions.length === 0) {
+      return true;
+    }
+    const gqlContext = this.getGqlContext(context);
+    const user = this.extractUser(gqlContext);
+    if (!user) {
+      throw new UnauthorizedException("Authentication required");
+    }
+    const userPermissions = this.extractPermissions(user);
+    const hasAllPermissions = requiredPermissions.every((permission) => userPermissions.includes(permission));
+    if (!hasAllPermissions) {
+      throw new ForbiddenException(`Required permissions: ${requiredPermissions.join(", ")}`);
+    }
+    return true;
+  }
+  getGqlContext(context) {
+    const args = context.getArgs();
+    return args[2];
+  }
+  extractUser(context) {
+    return context.user ?? context.req?.user ?? null;
+  }
+  extractPermissions(user) {
+    const userObj = user;
+    const permissions = userObj?.permissions ?? userObj?.scopes;
+    if (Array.isArray(permissions)) {
+      return permissions.map(String);
+    }
+    if (typeof permissions === "string") {
+      return permissions.split(" ");
+    }
+    return [];
+  }
+}
+PermissionsGuard = __legacyDecorateClassTS([
+  Injectable2(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Reflector === "undefined" ? Object : Reflector
+  ])
+], PermissionsGuard);
+
+class ComplexityGuard {
+  maxComplexity;
+  constructor(maxComplexity) {
+    this.maxComplexity = maxComplexity;
+  }
+  canActivate(context) {
+    const gqlContext = this.getGqlContext(context);
+    const currentComplexity = gqlContext._queryComplexity;
+    if (currentComplexity !== undefined && 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")),
+  __legacyMetadataTS("design:paramtypes", [
+    Number
+  ])
+], ComplexityGuard);
+
+class DepthGuard {
+  maxDepth;
+  constructor(maxDepth) {
+    this.maxDepth = maxDepth;
+  }
+  canActivate(context) {
+    const gqlContext = this.getGqlContext(context);
+    const currentDepth = gqlContext._queryDepth;
+    if (currentDepth !== undefined && 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")),
+  __legacyMetadataTS("design:paramtypes", [
+    Number
+  ])
+], DepthGuard);
+// src/interceptors.ts
+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`);
+    }));
+  }
+}
+LoggingInterceptor = __legacyDecorateClassTS([
+  Injectable3()
+], LoggingInterceptor);
+
+class ErrorFormattingInterceptor {
+  intercept(_context, next) {
+    return next.handle().pipe(catchError((error) => {
+      const formattedError = this.formatError(error);
+      return throwError(() => formattedError);
+    }));
+  }
+  formatError(error) {
+    if (error instanceof Error) {
+      if (false) {}
+      return error;
+    }
+    return new Error(String(error));
+  }
+}
+ErrorFormattingInterceptor = __legacyDecorateClassTS([
+  Injectable3()
+], 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 args = context.getArgs();
+      const gqlContext = args[2];
+      if (gqlContext) {
+        gqlContext._fieldComplexity = complexity;
+      }
+    }
+    return next.handle();
+  }
+}
+ComplexityInterceptor = __legacyDecorateClassTS([
+  Injectable3(),
+  __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 args = context.getArgs();
+        const gqlInfo = args[3];
+        if (gqlInfo?.cacheControl) {
+          gqlInfo.cacheControl.setCacheHint({
+            maxAge: cacheHint.maxAge,
+            scope: cacheHint.scope
+          });
+        }
+      }
+    }));
+  }
+}
+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);
+    }));
+  }
+  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;
+  }
+  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([
+  Injectable3()
+], MetricsInterceptor);
+// src/middleware.ts
+import {
+  Injectable as Injectable4,
+  Inject as Inject2
+} from "@nestjs/common";
+class GraphQLMiddleware {
+  driver;
+  options;
+  constructor(driver, options) {
+    this.driver = driver;
+    this.options = options;
+  }
+  async use(req, res, next) {
+    const path = this.driver.getPath();
+    if (!req.path.endsWith(path)) {
+      return next();
+    }
+    if (req.method === "GET" && this.driver.isPlaygroundEnabled()) {
+      this.servePlayground(res);
+      return;
+    }
+    if (req.method === "POST") {
+      await this.handleGraphQLRequest(req, res);
+      return;
+    }
+    if (req.method === "OPTIONS") {
+      this.handleCorsPreFlight(res);
+      return;
+    }
+    next();
+  }
+  async handleGraphQLRequest(req, res) {
+    try {
+      const { query, variables, operationName } = req.body ?? {};
+      if (!query) {
+        res.status(400).json({
+          errors: [{ message: "Query is required" }]
+        });
+        return;
+      }
+      const context = {
+        req,
+        res,
+        ...this.options.context ? await this.options.context(req, res) : {}
+      };
+      const result = await this.driver.execute(query, variables, context, operationName);
+      const status = result.errors?.length ? 200 : 200;
+      res.status(status).json(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      res.status(500).json({
+        errors: [{ message }]
+      });
+    }
+  }
+  servePlayground(res) {
+    const path = this.driver.getPath();
+    const html = this.getPlaygroundHtml(path);
+    res.setHeader("Content-Type", "text/html");
+    res.send(html);
+  }
+  handleCorsPreFlight(res) {
+    const corsOptions = this.options.cors;
+    if (corsOptions === false) {
+      res.status(204).end();
+      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 : "*");
+    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.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();
+  }
+}
+GraphQLMiddleware = __legacyDecorateClassTS([
+  Injectable4(),
+  __legacyDecorateParamTS(0, Inject2(LEAVEN_DRIVER)),
+  __legacyDecorateParamTS(1, Inject2(LEAVEN_MODULE_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenDriver === "undefined" ? Object : LeavenDriver,
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions
+  ])
+], GraphQLMiddleware);
+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);
+  }
+  getContext() {
+    return this.args[2];
+  }
+  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);
+  }
+}
+function getGqlContext2(context) {
+  return GqlExecutionContext.create(context).getContext();
+}
+function getGqlArgs(context) {
+  return GqlExecutionContext.create(context).getArgs();
+}
+function getGqlInfo(context) {
+  return GqlExecutionContext.create(context).getInfo();
+}
+function getGqlRoot(context) {
+  return GqlExecutionContext.create(context).getRoot();
+}
+// src/schema-builder.ts
+import { Injectable as Injectable5, Inject as Inject3 } from "@nestjs/common";
+class SchemaBuilderService {
+  options;
+  driver;
+  builtSchema = null;
+  constructor(options, driver) {
+    this.options = options;
+    this.driver = driver;
+  }
+  async onModuleInit() {
+    const schema = await this.buildSchema();
+    if (schema) {
+      this.builtSchema = schema;
+      this.driver.setSchema(schema);
+    }
+  }
+  async buildSchema() {
+    if (this.options.schema) {
+      return this.options.schema;
+    }
+    if (this.options.typeDefs) {
+      return this.buildFromTypeDefs();
+    }
+    if (this.options.autoSchemaFile) {
+      return null;
+    }
+    return null;
+  }
+  buildFromTypeDefs() {
+    const { typeDefs, resolvers } = this.options;
+    if (!typeDefs || !resolvers) {
+      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;
+    }
+  }
+  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(`
+`);
+    }
+    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;
+    }, {});
+  }
+  getSchema() {
+    return this.builtSchema;
+  }
+  setSchema(schema) {
+    this.builtSchema = schema;
+    this.driver.setSchema(schema);
+  }
+  isSchemaReady() {
+    return this.builtSchema !== null;
+  }
+}
+SchemaBuilderService = __legacyDecorateClassTS([
+  Injectable5(),
+  __legacyDecorateParamTS(0, Inject3(LEAVEN_MODULE_OPTIONS)),
+  __legacyDecorateParamTS(1, Inject3(LEAVEN_DRIVER)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions,
+    typeof LeavenDriver === "undefined" ? Object : LeavenDriver
+  ])
+], SchemaBuilderService);
+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");
+}
+var resolverMetadataStorage = [];
+function getResolverMetadata() {
+  return [...resolverMetadataStorage];
+}
+function registerResolverMetadata(metadata) {
+  resolverMetadataStorage.push(metadata);
+}
+function clearResolverMetadata() {
+  resolverMetadataStorage.length = 0;
+}
+// src/subscriptions.ts
+import { Injectable as Injectable6, Inject as Inject4 } from "@nestjs/common";
+class SubscriptionManager {
+  options;
+  driver;
+  connections = new Map;
+  config;
+  constructor(options, driver) {
+    this.options = options;
+    this.driver = driver;
+    this.config = this.normalizeConfig();
+  }
+  async onModuleInit() {}
+  async onModuleDestroy() {
+    for (const [socket] of this.connections) {
+      socket.close(1000, "Server shutdown");
+    }
+    this.connections.clear();
+  }
+  normalizeConfig() {
+    return {
+      path: this.options.path ?? "/graphql",
+      keepAlive: 12000,
+      connectionInitWaitTimeout: 3000,
+      maxSubscriptionsPerConnection: 100
+    };
+  }
+  async handleConnection(socket, request) {
+    const state = {
+      socket,
+      request,
+      subscriptions: new Map,
+      initialized: false,
+      connectionParams: undefined,
+      context: undefined,
+      keepAliveInterval: 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(() => {
+      if (!state.initialized) {
+        socket.close(4408, "Connection initialization timeout");
+      }
+    }, this.config.connectionInitWaitTimeout);
+  }
+  async handleMessage(socket, data) {
+    const state = this.connections.get(socket);
+    if (!state)
+      return;
+    try {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case "connection_init":
+          await this.handleConnectionInit(socket, state, message);
+          break;
+        case "ping":
+          this.send(socket, { type: "pong" });
+          break;
+        case "pong":
+          break;
+        case "subscribe":
+          await this.handleSubscribe(socket, state, message);
+          break;
+        case "complete":
+          await this.handleComplete(socket, state, message);
+          break;
+        default:
+          break;
+      }
+    } catch (error) {
+      console.error("Error handling WebSocket message:", error);
+    }
+  }
+  async handleConnectionInit(socket, state, message) {
+    if (state.initialized) {
+      socket.close(4429, "Too many initialization requests");
+      return;
+    }
+    state.connectionParams = message.payload ?? {};
+    const ctx = {
+      socket,
+      connectionParams: message.payload ?? {},
+      request: state.request
+    };
+    if (this.config.onConnect) {
+      const allowed = await this.config.onConnect(ctx);
+      if (!allowed) {
+        socket.close(4401, "Unauthorized");
+        return;
+      }
+    }
+    state.initialized = true;
+    state.context = ctx;
+    this.send(socket, { type: "connection_ack" });
+    if (this.config.keepAlive) {
+      state.keepAliveInterval = setInterval(() => {
+        this.send(socket, { type: "ping" });
+      }, this.config.keepAlive);
+    }
+  }
+  async handleSubscribe(socket, state, message) {
+    if (!state.initialized) {
+      socket.close(4401, "Unauthorized");
+      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);
+    }
+    try {
+      const schema = this.driver.getSchema();
+      if (!schema) {
+        this.sendError(socket, message.id, "Schema not available");
+        return;
+      }
+      let context = {
+        req: state.request,
+        res: {},
+        ...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" });
+        return;
+      }
+      state.subscriptions.set(message.id, {
+        message,
+        context
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Subscription failed";
+      this.sendError(socket, message.id, errorMessage);
+    }
+  }
+  async handleComplete(socket, state, message) {
+    const subscription = state.subscriptions.get(message.id);
+    if (subscription) {
+      state.subscriptions.delete(message.id);
+      if (this.config.onComplete && state.context) {
+        await this.config.onComplete(state.context, message);
+      }
+    }
+  }
+  async handleClose(ws) {
+    const state = this.connections.get(ws);
+    if (!state)
+      return;
+    if (state.keepAliveInterval) {
+      clearInterval(state.keepAliveInterval);
+    }
+    if (this.config.onDisconnect && state.context) {
+      await this.config.onDisconnect(state.context);
+    }
+    state.subscriptions.clear();
+    this.connections.delete(ws);
+  }
+  handleError(ws, _error) {
+    const state = this.connections.get(ws);
+    if (state) {
+      this.handleClose(ws);
+    }
+  }
+  send(socket, message) {
+    if (socket.readyState === WebSocket.OPEN) {
+      socket.send(JSON.stringify(message));
+    }
+  }
+  sendError(socket, id, message) {
+    this.send(socket, {
+      id,
+      type: "error",
+      payload: [{ message }]
+    });
+  }
+  publish(id, 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 }
+        });
+      }
+    }
+  }
+  getConnectionCount() {
+    return this.connections.size;
+  }
+  getSubscriptionCount() {
+    let count = 0;
+    for (const [_, state] of this.connections) {
+      count += state.subscriptions.size;
+    }
+    return count;
+  }
+}
+SubscriptionManager = __legacyDecorateClassTS([
+  Injectable6(),
+  __legacyDecorateParamTS(0, Inject4(LEAVEN_MODULE_OPTIONS)),
+  __legacyDecorateParamTS(1, Inject4(LEAVEN_DRIVER)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof LeavenModuleOptions === "undefined" ? Object : LeavenModuleOptions,
+    typeof LeavenDriver === "undefined" ? Object : LeavenDriver
+  ])
+], SubscriptionManager);
+function Subscription(returns, options) {
+  return (_target, _propertyKey, descriptor) => {
+    if (descriptor.value) {
+      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);
+    }
+  };
+}
+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
+};