@buenojs/bueno 0.8.5 → 0.8.7

package/dist/graphql/index.js

@@ -0,0 +1,2156 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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 __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/container/forward-ref.ts
+function forwardRef(fn) {
+  return {
+    __forwardRef: FORWARD_REF_SYMBOL,
+    forwardRef: fn
+  };
+}
+function isForwardRef(value) {
+  return typeof value === "object" && value !== null && "__forwardRef" in value && "forwardRef" in value && typeof value.forwardRef === "function";
+}
+function resolveForwardRef(ref) {
+  if (isForwardRef(ref)) {
+    return ref.forwardRef();
+  }
+  return ref;
+}
+var FORWARD_REF_SYMBOL;
+var init_forward_ref = __esm(() => {
+  FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
+});
+
+// src/container/index.ts
+var exports_container = {};
+__export(exports_container, {
+  setContainerMetadata: () => setContainerMetadata,
+  resolveForwardRef: () => resolveForwardRef,
+  isForwardRef: () => isForwardRef,
+  getInjectTokens: () => getContainerMetadata,
+  getContainerMetadata: () => getContainerMetadata,
+  forwardRef: () => forwardRef,
+  createToken: () => createToken,
+  Token: () => Token,
+  Injectable: () => Injectable,
+  Inject: () => Inject,
+  Container: () => Container
+});
+function createToken(description) {
+  return Symbol(description);
+}
+
+class ResolutionStack {
+  stack = new Set;
+  lazyResolutions = new Map;
+  push(token) {
+    if (this.stack.has(token)) {
+      throw new Error("Circular dependency detected: Token already in resolution stack");
+    }
+    this.stack.add(token);
+  }
+  pop(token) {
+    this.stack.delete(token);
+  }
+  has(token) {
+    return this.stack.has(token);
+  }
+  markLazy(token, placeholder) {
+    this.lazyResolutions.set(token, placeholder);
+  }
+  hasLazy(token) {
+    return this.lazyResolutions.has(token);
+  }
+  getLazy(token) {
+    return this.lazyResolutions.get(token);
+  }
+  clearLazy(token) {
+    this.lazyResolutions.delete(token);
+  }
+}
+
+class Container {
+  providers = new Map;
+  resolutionStack = new ResolutionStack;
+  register(provider) {
+    if (this.providers.has(provider.token)) {
+      throw new Error(`Provider already registered for token: ${String(provider.token)}`);
+    }
+    this.providers.set(provider.token, {
+      provider: {
+        ...provider,
+        scope: provider.scope ?? "singleton"
+      }
+    });
+  }
+  registerAll(providers) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+  has(token) {
+    return this.providers.has(token);
+  }
+  resolve(token) {
+    const resolved = this.providers.get(token);
+    if (!resolved) {
+      throw new Error(`No provider registered for token: ${String(token)}`);
+    }
+    const { provider } = resolved;
+    if (this.resolutionStack.has(token)) {
+      return this.createLazyProxy(token, resolved);
+    }
+    if (provider.scope === "singleton" && resolved.instance !== undefined) {
+      return resolved.instance;
+    }
+    this.resolutionStack.push(token);
+    try {
+      const instance = this.createInstance(provider);
+      if (provider.scope === "singleton") {
+        resolved.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.pop(token);
+    }
+  }
+  createLazyProxy(token, resolved) {
+    const existingLazy = this.resolutionStack.getLazy(token);
+    if (existingLazy && existingLazy.instance) {
+      return existingLazy.instance;
+    }
+    const placeholder = {
+      resolved: false
+    };
+    this.resolutionStack.markLazy(token, placeholder);
+    const proxy = new Proxy({}, {
+      get: (target, prop) => {
+        if (placeholder.resolved && placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        if (resolved.instance !== undefined) {
+          placeholder.instance = resolved.instance;
+          placeholder.resolved = true;
+        } else {
+          if (prop === "then") {
+            return;
+          }
+        }
+        if (placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        return () => {
+          return;
+        };
+      },
+      set: (target, prop, value) => {
+        if (placeholder.instance) {
+          placeholder.instance[prop] = value;
+          return true;
+        }
+        return false;
+      },
+      has: (target, prop) => {
+        if (placeholder.instance) {
+          return prop in placeholder.instance;
+        }
+        return false;
+      }
+    });
+    placeholder.instance = proxy;
+    return proxy;
+  }
+  createInstance(provider) {
+    if (provider.useValue !== undefined) {
+      return provider.useValue;
+    }
+    if (provider.useFactory) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return provider.useFactory(...deps);
+    }
+    if (provider.useClass) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return new provider.useClass(...deps);
+    }
+    throw new Error(`Invalid provider configuration for token: ${String(provider.token)}`);
+  }
+  resolveDeps(tokens) {
+    return tokens.map((tokenOrRef) => {
+      const token = resolveForwardRef(tokenOrRef);
+      return this.resolve(token);
+    });
+  }
+  clear() {
+    this.providers.clear();
+  }
+  getTokens() {
+    return Array.from(this.providers.keys());
+  }
+  createChild() {
+    const child = new Container;
+    for (const [token, resolved] of this.providers) {
+      if (resolved.provider.scope === "singleton") {
+        child.providers.set(token, resolved);
+      }
+    }
+    return child;
+  }
+}
+function setContainerMetadata(target, key, value) {
+  if (!containerMetadata.has(target)) {
+    containerMetadata.set(target, new Map);
+  }
+  containerMetadata.get(target)?.set(key, value);
+}
+function getContainerMetadata(target, key) {
+  return containerMetadata.get(target)?.get(key);
+}
+function Injectable(token) {
+  return (target) => {
+    setContainerMetadata(target, "injectable", true);
+    if (token) {
+      setContainerMetadata(target, "token", token);
+    }
+    return target;
+  };
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const targetObj = target;
+    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
+    existingTokens[parameterIndex] = token;
+    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+  };
+}
+var Token, containerMetadata;
+var init_container = __esm(() => {
+  init_forward_ref();
+  Token = createToken;
+  containerMetadata = new WeakMap;
+});
+
+// src/graphql/metadata.ts
+var exports_metadata = {};
+__export(exports_metadata, {
+  setResolverMetadata: () => setResolverMetadata,
+  setParamMetadata: () => setParamMetadata,
+  setObjectTypeMetadata: () => setObjectTypeMetadata,
+  setInputTypeMetadata: () => setInputTypeMetadata,
+  setGqlPrototypeMetadata: () => setGqlPrototypeMetadata,
+  setGqlPropertyMetadata: () => setGqlPropertyMetadata,
+  setGqlClassMetadata: () => setGqlClassMetadata,
+  getTypeMetadata: () => getTypeMetadata,
+  getSubscriptionFields: () => getSubscriptionFields,
+  getResolverMetadata: () => getResolverMetadata,
+  getQueryFields: () => getQueryFields,
+  getParamMetadata: () => getParamMetadata,
+  getMutationFields: () => getMutationFields,
+  getGqlPrototypeMetadata: () => getGqlPrototypeMetadata,
+  getGqlPropertyMetadata: () => getGqlPropertyMetadata,
+  getGqlPropertyKeys: () => getGqlPropertyKeys,
+  getGqlClassMetadata: () => getGqlClassMetadata,
+  getAllGqlPropertyMetadata: () => getAllGqlPropertyMetadata,
+  addSubscriptionField: () => addSubscriptionField,
+  addQueryField: () => addQueryField,
+  addMutationField: () => addMutationField,
+  GQL_SUBSCRIPTIONS_KEY: () => GQL_SUBSCRIPTIONS_KEY,
+  GQL_RESOLVER_KEY: () => GQL_RESOLVER_KEY,
+  GQL_QUERIES_KEY: () => GQL_QUERIES_KEY,
+  GQL_PARAMS_PREFIX: () => GQL_PARAMS_PREFIX,
+  GQL_OBJECTTYPE_KEY: () => GQL_OBJECTTYPE_KEY,
+  GQL_MUTATIONS_KEY: () => GQL_MUTATIONS_KEY,
+  GQL_INPUTTYPE_KEY: () => GQL_INPUTTYPE_KEY
+});
+function setGqlClassMetadata(target, key, value) {
+  if (!classMetadataStore.has(target)) {
+    classMetadataStore.set(target, new Map);
+  }
+  classMetadataStore.get(target)?.set(key, value);
+}
+function getGqlClassMetadata(target, key) {
+  return classMetadataStore.get(target)?.get(key);
+}
+function setGqlPrototypeMetadata(target, key, value) {
+  if (!prototypeMetadataStore.has(target)) {
+    prototypeMetadataStore.set(target, new Map);
+  }
+  prototypeMetadataStore.get(target)?.set(key, value);
+}
+function getGqlPrototypeMetadata(target, key) {
+  return prototypeMetadataStore.get(target)?.get(key);
+}
+function setGqlPropertyMetadata(target, propertyKey, value) {
+  if (!propertyMetadataStore.has(target)) {
+    propertyMetadataStore.set(target, new Map);
+  }
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  propertyMetadataStore.get(target)?.set(key, value);
+}
+function getGqlPropertyMetadata(target, propertyKey) {
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  return propertyMetadataStore.get(target)?.get(key);
+}
+function getGqlPropertyKeys(target) {
+  const map = propertyMetadataStore.get(target);
+  if (!map)
+    return [];
+  return Array.from(map.keys());
+}
+function getAllGqlPropertyMetadata(target) {
+  const map = propertyMetadataStore.get(target);
+  if (!map)
+    return [];
+  return Array.from(map.values());
+}
+function getResolverMetadata(target) {
+  return getGqlClassMetadata(target, GQL_RESOLVER_KEY);
+}
+function setResolverMetadata(target, metadata) {
+  setGqlClassMetadata(target, GQL_RESOLVER_KEY, metadata);
+}
+function getTypeMetadata(target) {
+  return getGqlClassMetadata(target, GQL_OBJECTTYPE_KEY) ?? getGqlClassMetadata(target, GQL_INPUTTYPE_KEY);
+}
+function setObjectTypeMetadata(target, metadata) {
+  setGqlClassMetadata(target, GQL_OBJECTTYPE_KEY, metadata);
+}
+function setInputTypeMetadata(target, metadata) {
+  setGqlClassMetadata(target, GQL_INPUTTYPE_KEY, metadata);
+}
+function getResolverFields(prototype, key) {
+  return getGqlPrototypeMetadata(prototype, key) ?? [];
+}
+function addResolverField(prototype, key, field) {
+  const existing = getResolverFields(prototype, key);
+  const idx = existing.findIndex((f) => f.methodName === field.methodName);
+  if (idx >= 0) {
+    existing[idx] = field;
+  } else {
+    existing.push(field);
+  }
+  setGqlPrototypeMetadata(prototype, key, existing);
+}
+function addQueryField(prototype, field) {
+  addResolverField(prototype, GQL_QUERIES_KEY, field);
+}
+function addMutationField(prototype, field) {
+  addResolverField(prototype, GQL_MUTATIONS_KEY, field);
+}
+function addSubscriptionField(prototype, field) {
+  addResolverField(prototype, GQL_SUBSCRIPTIONS_KEY, field);
+}
+function getQueryFields(prototype) {
+  return getResolverFields(prototype, GQL_QUERIES_KEY);
+}
+function getMutationFields(prototype) {
+  return getResolverFields(prototype, GQL_MUTATIONS_KEY);
+}
+function getSubscriptionFields(prototype) {
+  return getResolverFields(prototype, GQL_SUBSCRIPTIONS_KEY);
+}
+function setParamMetadata(prototype, methodName, paramIndex, meta) {
+  const key = `${GQL_PARAMS_PREFIX}${methodName}`;
+  const existing = getGqlPrototypeMetadata(prototype, key) ?? [];
+  existing[paramIndex] = meta;
+  setGqlPrototypeMetadata(prototype, key, existing);
+}
+function getParamMetadata(prototype, methodName) {
+  const key = `${GQL_PARAMS_PREFIX}${methodName}`;
+  return getGqlPrototypeMetadata(prototype, key) ?? [];
+}
+var classMetadataStore, prototypeMetadataStore, propertyMetadataStore, GQL_RESOLVER_KEY = "gql:resolver", GQL_OBJECTTYPE_KEY = "gql:objecttype", GQL_INPUTTYPE_KEY = "gql:inputtype", GQL_QUERIES_KEY = "gql:queries", GQL_MUTATIONS_KEY = "gql:mutations", GQL_SUBSCRIPTIONS_KEY = "gql:subscriptions", GQL_PARAMS_PREFIX = "gql:params:";
+var init_metadata = __esm(() => {
+  classMetadataStore = new WeakMap;
+  prototypeMetadataStore = new WeakMap;
+  propertyMetadataStore = new WeakMap;
+});
+
+// src/graphql/context-builder.ts
+var exports_context_builder = {};
+__export(exports_context_builder, {
+  parseGraphQLRequest: () => parseGraphQLRequest,
+  enrichContextForGraphQL: () => enrichContextForGraphQL,
+  buildGraphQLContext: () => buildGraphQLContext
+});
+function buildGraphQLContext(httpContext) {
+  return {
+    request: httpContext.req,
+    user: httpContext.get("user"),
+    httpContext
+  };
+}
+function enrichContextForGraphQL(httpContext, operationName, operationType, resolverClass) {
+  httpContext.set("graphql:operation", operationName);
+  httpContext.set("graphql:type", operationType);
+  httpContext.set("graphql:resolverClass", resolverClass);
+}
+async function parseGraphQLRequest(request) {
+  if (request.method === "POST") {
+    try {
+      const body = await request.clone().json();
+      if (typeof body.query !== "string") {
+        return null;
+      }
+      return {
+        query: body.query,
+        variables: typeof body.variables === "object" && body.variables !== null ? body.variables : {},
+        operationName: typeof body.operationName === "string" ? body.operationName : undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  if (request.method === "GET") {
+    const url = new URL(request.url);
+    const query = url.searchParams.get("query");
+    if (!query)
+      return null;
+    const varsStr = url.searchParams.get("variables");
+    let variables = {};
+    if (varsStr) {
+      try {
+        variables = JSON.parse(varsStr);
+      } catch {}
+    }
+    return {
+      query,
+      variables,
+      operationName: url.searchParams.get("operationName") ?? undefined
+    };
+  }
+  return null;
+}
+
+// src/openapi/metadata.ts
+var exports_metadata2 = {};
+__export(exports_metadata2, {
+  setApiPropertyMetadata: () => setApiPropertyMetadata,
+  setApiMethodMetadata: () => setApiMethodMetadata,
+  setApiMetadata: () => setApiMetadata,
+  getApiPropertyMetadata: () => getApiPropertyMetadata,
+  getApiPropertyKeys: () => getApiPropertyKeys,
+  getApiMethodMetadata: () => getApiMethodMetadata,
+  getApiMetadata: () => getApiMetadata
+});
+function setApiMetadata(target, key, value) {
+  if (!classMetadataStore2.has(target)) {
+    classMetadataStore2.set(target, new Map);
+  }
+  classMetadataStore2.get(target)?.set(key, value);
+}
+function getApiMetadata(target, key) {
+  return classMetadataStore2.get(target)?.get(key);
+}
+function setApiMethodMetadata(target, key, value) {
+  if (!methodMetadataStore.has(target)) {
+    methodMetadataStore.set(target, new Map);
+  }
+  methodMetadataStore.get(target)?.set(key, value);
+}
+function getApiMethodMetadata(target, key) {
+  return methodMetadataStore.get(target)?.get(key);
+}
+function setApiPropertyMetadata(target, propertyKey, value) {
+  if (!propertyMetadataStore2.has(target)) {
+    propertyMetadataStore2.set(target, new Map);
+  }
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  propertyMetadataStore2.get(target)?.set(key, value);
+}
+function getApiPropertyMetadata(target, propertyKey) {
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  return propertyMetadataStore2.get(target)?.get(key);
+}
+function getApiPropertyKeys(target) {
+  const metaMap = propertyMetadataStore2.get(target);
+  if (!metaMap)
+    return [];
+  return Array.from(metaMap.keys());
+}
+var classMetadataStore2, methodMetadataStore, propertyMetadataStore2;
+var init_metadata2 = __esm(() => {
+  classMetadataStore2 = new WeakMap;
+  methodMetadataStore = new WeakMap;
+  propertyMetadataStore2 = new WeakMap;
+});
+
+// src/modules/guards.ts
+var exports_guards = {};
+__export(exports_guards, {
+  getMethodRoles: () => getMethodRoles,
+  getMethodGuards: () => getMethodGuards,
+  getClassGuards: () => getClassGuards,
+  executeGuards: () => executeGuards,
+  createForbiddenResponse: () => createForbiddenResponse,
+  UseGuards: () => UseGuards,
+  RolesGuard: () => RolesGuard,
+  Roles: () => Roles,
+  AuthGuard: () => AuthGuard
+});
+function setClassGuards(target, guards) {
+  guardsClassMetadata.set(target, guards);
+}
+function getClassGuards(target) {
+  return guardsClassMetadata.get(target);
+}
+function setMethodGuards(target, propertyKey, guards) {
+  if (!guardsMethodMetadata.has(target)) {
+    guardsMethodMetadata.set(target, new Map);
+  }
+  guardsMethodMetadata.get(target)?.set(propertyKey, guards);
+}
+function getMethodGuards(target, propertyKey) {
+  return guardsMethodMetadata.get(target)?.get(propertyKey);
+}
+function UseGuards(...guards) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined && descriptor !== undefined) {
+      const targetObj = target;
+      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
+      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingGuards = getClassGuards(targetClass) ?? [];
+      setClassGuards(targetClass, [...existingGuards, ...guards]);
+    }
+  };
+  return decorator;
+}
+
+class AuthGuard {
+  canActivate(context) {
+    const authHeader = context.req.headers.get("Authorization");
+    return authHeader !== null && authHeader.length > 0;
+  }
+}
+function setMethodRoles(target, propertyKey, roles) {
+  if (!rolesMethodMetadata.has(target)) {
+    rolesMethodMetadata.set(target, new Map);
+  }
+  rolesMethodMetadata.get(target)?.set(propertyKey, roles);
+}
+function getMethodRoles(target, propertyKey) {
+  return rolesMethodMetadata.get(target)?.get(propertyKey);
+}
+function Roles(...roles) {
+  return (target, propertyKey, descriptor) => {
+    const targetObj = target;
+    setMethodRoles(targetObj, propertyKey, roles);
+    return descriptor;
+  };
+}
+
+class RolesGuard {
+  canActivate(context) {
+    const requiredRoles = context.requiredRoles;
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
+    }
+    const user = context.user;
+    if (!user || !user.roles) {
+      return false;
+    }
+    return requiredRoles.some((role) => user.roles?.includes(role));
+  }
+}
+async function executeGuards(context, options) {
+  const {
+    globalGuards = [],
+    classGuards = [],
+    methodGuards = [],
+    resolveGuard
+  } = options;
+  const allGuards = [...globalGuards, ...classGuards, ...methodGuards];
+  for (const guard of allGuards) {
+    let guardInstance = null;
+    if (typeof guard === "function") {
+      const funcGuard = guard;
+      if (funcGuard.prototype && typeof funcGuard.prototype === "object" && "canActivate" in funcGuard.prototype) {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+        if (!guardInstance) {
+          const GuardClass = guard;
+          guardInstance = new GuardClass;
+        }
+      } else {
+        guardInstance = guard;
+      }
+    } else if (typeof guard === "object" && guard !== null) {
+      const objGuard = guard;
+      if ("canActivate" in objGuard && typeof objGuard.canActivate === "function") {
+        guardInstance = guard;
+      } else {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+      }
+    }
+    if (!guardInstance) {
+      console.warn("Guard could not be resolved:", guard);
+      continue;
+    }
+    let result;
+    if (typeof guardInstance === "function") {
+      result = await guardInstance(context);
+    } else {
+      result = await guardInstance.canActivate(context);
+    }
+    if (!result) {
+      return false;
+    }
+  }
+  return true;
+}
+function createForbiddenResponse() {
+  return new Response(JSON.stringify({
+    statusCode: 403,
+    error: "Forbidden",
+    message: "Access denied"
+  }), {
+    status: 403,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var guardsClassMetadata, guardsMethodMetadata, rolesMethodMetadata;
+var init_guards = __esm(() => {
+  guardsClassMetadata = new WeakMap;
+  guardsMethodMetadata = new WeakMap;
+  rolesMethodMetadata = new WeakMap;
+});
+
+// src/graphql/graphql-module.ts
+init_container();
+
+// src/graphql/schema-builder.ts
+init_metadata();
+function typeFnToScalarName(typeFn) {
+  const type = typeFn();
+  const resolved = Array.isArray(type) ? type[0] : type;
+  if (resolved === String)
+    return "String";
+  if (resolved === Number)
+    return "Float";
+  if (resolved === Boolean)
+    return "Boolean";
+  const name = resolved.name;
+  if (name === "GraphQLID")
+    return "ID";
+  if (name === "GraphQLInt")
+    return "Int";
+  if (name === "GraphQLFloat")
+    return "Float";
+  return null;
+}
+function typeFnToSDL(typeFn, nullable) {
+  const type = typeFn();
+  const isArray = Array.isArray(type);
+  const inner = isArray ? type[0] : type;
+  let innerName;
+  const scalarName = typeFnToScalarName(() => inner);
+  if (scalarName) {
+    innerName = scalarName;
+  } else {
+    innerName = inner.name;
+  }
+  const innerSdl = isArray ? `[${innerName}!]` : innerName;
+  return nullable ? innerSdl : `${innerSdl}!`;
+}
+
+class SchemaBuilder {
+  resolverClasses;
+  resolverInstances;
+  typeClasses = new Set;
+  constructor(resolverClasses, resolverInstances) {
+    this.resolverClasses = resolverClasses;
+    this.resolverInstances = resolverInstances;
+  }
+  build() {
+    const queries = new Map;
+    const mutations = new Map;
+    const subscriptions = new Map;
+    for (const ResolverClass of this.resolverClasses) {
+      const instance = this.resolverInstances.get(ResolverClass);
+      const qFields = getQueryFields(ResolverClass.prototype);
+      for (const f of qFields) {
+        queries.set(f.fieldName, this.toResolvedField(f, instance));
+        this.collectReturnType(f.typeFn);
+      }
+      const mFields = getMutationFields(ResolverClass.prototype);
+      for (const f of mFields) {
+        mutations.set(f.fieldName, this.toResolvedField(f, instance));
+        this.collectReturnType(f.typeFn);
+      }
+      const sFields = getSubscriptionFields(ResolverClass.prototype);
+      for (const f of sFields) {
+        subscriptions.set(f.fieldName, this.toResolvedField(f, instance));
+        this.collectReturnType(f.typeFn);
+      }
+    }
+    this.collectNestedTypes();
+    const typeFields = this.buildTypeFields();
+    const sdl = this.generateSDL(queries, mutations, subscriptions, typeFields);
+    const resolverFields = {
+      queries,
+      mutations,
+      subscriptions
+    };
+    const resolvedSchema = {
+      queryFields: queries,
+      mutationFields: mutations,
+      subscriptionFields: subscriptions
+    };
+    return { sdl, resolvedSchema, resolverFields, typeFields };
+  }
+  toResolvedField(field, instance) {
+    return {
+      resolverInstance: instance,
+      methodName: field.methodName,
+      paramMetadata: field.paramMetadata,
+      typeFn: field.typeFn,
+      nullable: field.nullable
+    };
+  }
+  collectReturnType(typeFn) {
+    const type = typeFn();
+    const resolved = Array.isArray(type) ? type[0] : type;
+    if (typeof resolved === "function") {
+      const meta = getTypeMetadata(resolved);
+      if (meta) {
+        this.typeClasses.add(resolved);
+      }
+    }
+  }
+  collectNestedTypes() {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const TypeClass of Array.from(this.typeClasses)) {
+        const fields = getAllGqlPropertyMetadata(TypeClass.prototype);
+        for (const field of fields) {
+          const type = field.typeFn();
+          const inner = Array.isArray(type) ? type[0] : type;
+          if (typeof inner === "function") {
+            const meta = getTypeMetadata(inner);
+            if (meta && !this.typeClasses.has(inner)) {
+              this.typeClasses.add(inner);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+  }
+  buildTypeFields() {
+    const result = new Map;
+    for (const TypeClass of this.typeClasses) {
+      const meta = getTypeMetadata(TypeClass);
+      if (!meta)
+        continue;
+      const fields = getAllGqlPropertyMetadata(TypeClass.prototype);
+      result.set(meta.name, fields);
+    }
+    return result;
+  }
+  generateSDL(queries, mutations, subscriptions, typeFields) {
+    const lines = [];
+    for (const TypeClass of this.typeClasses) {
+      const meta = getTypeMetadata(TypeClass);
+      if (!meta)
+        continue;
+      const fields = getAllGqlPropertyMetadata(TypeClass.prototype);
+      if (fields.length === 0)
+        continue;
+      const keyword = meta.kind === "input" ? "input" : "type";
+      if (meta.description) {
+        lines.push(`"""${meta.description}"""`);
+      }
+      lines.push(`${keyword} ${meta.name} {`);
+      for (const f of fields) {
+        if (f.description) {
+          lines.push(`  """${f.description}"""`);
+        }
+        const typeSdl = typeFnToSDL(f.typeFn, f.nullable);
+        let fieldLine = `  ${f.propertyKey}: ${typeSdl}`;
+        if (f.defaultValue !== undefined) {
+          fieldLine += ` = ${JSON.stringify(f.defaultValue)}`;
+        }
+        lines.push(fieldLine);
+        if (f.deprecationReason) {
+          lines[lines.length - 1] += ` @deprecated(reason: "${f.deprecationReason}")`;
+        }
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    if (queries.size > 0) {
+      lines.push("type Query {");
+      for (const [fieldName, field] of queries) {
+        const args = this.buildArgsSDL(fieldName, queries);
+        const typeSdl = typeFnToSDL(field.typeFn, field.nullable);
+        lines.push(`  ${fieldName}${args}: ${typeSdl}`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    if (mutations.size > 0) {
+      lines.push("type Mutation {");
+      for (const [fieldName, field] of mutations) {
+        const args = this.buildArgsSDL(fieldName, mutations);
+        const typeSdl = typeFnToSDL(field.typeFn, field.nullable);
+        lines.push(`  ${fieldName}${args}: ${typeSdl}`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    if (subscriptions.size > 0) {
+      lines.push("type Subscription {");
+      for (const [fieldName, field] of subscriptions) {
+        const typeSdl = typeFnToSDL(field.typeFn, field.nullable);
+        lines.push(`  ${fieldName}: ${typeSdl}`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    return lines.join(`
+`).trim();
+  }
+  buildArgsSDL(fieldName, fields) {
+    const field = fields.get(fieldName);
+    if (!field || field.paramMetadata.length === 0)
+      return "";
+    const args = [];
+    for (const param of field.paramMetadata) {
+      if (param.kind === "context")
+        continue;
+      if (param.kind === "args" && param.argName) {
+        continue;
+      }
+      if (param.kind === "argsObject" && param.inputTypeFn) {
+        const inputType = param.inputTypeFn();
+        const typeName = Array.isArray(inputType) ? inputType[0].name : inputType.name;
+        if (param.argName) {
+          args.push(`${param.argName}: ${typeName}!`);
+        }
+      }
+    }
+    return args.length > 0 ? `(${args.join(", ")})` : "";
+  }
+}
+var registeredTypeClasses = new Set;
+function registerTypeClass(ctor) {
+  registeredTypeClasses.add(ctor);
+}
+function getRegisteredTypeClasses() {
+  return Array.from(registeredTypeClasses);
+}
+
+// src/graphql/built-in-engine.ts
+class GraphQLParser {
+  input;
+  pos = 0;
+  constructor(input) {
+    this.input = input;
+  }
+  parse() {
+    this.skipWhitespaceAndComments();
+    let operation = "query";
+    if (this.peek("mutation")) {
+      this.pos += 8;
+      operation = "mutation";
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] !== "{") {
+        this.skipName();
+        this.skipWhitespaceAndComments();
+      }
+    } else if (this.peek("query")) {
+      this.pos += 5;
+      operation = "query";
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] !== "{") {
+        this.skipName();
+        this.skipWhitespaceAndComments();
+      }
+    }
+    if (this.input[this.pos] === "(") {
+      this.skipBalanced("(", ")");
+      this.skipWhitespaceAndComments();
+    }
+    const selections = this.parseSelectionSet();
+    return { operation, selections };
+  }
+  parseSelectionSet() {
+    this.expect("{");
+    this.skipWhitespaceAndComments();
+    const selections = [];
+    while (this.pos < this.input.length && this.input[this.pos] !== "}") {
+      if (this.input[this.pos] === "." && this.input[this.pos + 1] === "." && this.input[this.pos + 2] === ".") {
+        throw new Error("Fragment spreads are not supported by the built-in GraphQL engine. " + "Install the 'graphql' package and use GraphQLJsAdapter for full spec support.");
+      }
+      if (this.peek("on ") || this.peek("on\t") || this.peek("on{")) {
+        throw new Error("Inline fragments are not supported by the built-in GraphQL engine. " + "Install the 'graphql' package and use GraphQLJsAdapter for full spec support.");
+      }
+      const sel = this.parseSelection();
+      selections.push(sel);
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] === ",") {
+        this.pos++;
+        this.skipWhitespaceAndComments();
+      }
+    }
+    this.expect("}");
+    return selections;
+  }
+  parseSelection() {
+    const firstName = this.parseName();
+    this.skipWhitespaceAndComments();
+    let name = firstName;
+    let alias;
+    if (this.input[this.pos] === ":") {
+      alias = firstName;
+      this.pos++;
+      this.skipWhitespaceAndComments();
+      name = this.parseName();
+      this.skipWhitespaceAndComments();
+    }
+    if (name.startsWith("__")) {
+      throw new Error(`Introspection field '${name}' is not supported by the built-in GraphQL engine. ` + "Install the 'graphql' package and use GraphQLJsAdapter for introspection support.");
+    }
+    const args = [];
+    if (this.input[this.pos] === "(") {
+      args.push(...this.parseArguments());
+      this.skipWhitespaceAndComments();
+    }
+    let selections = [];
+    if (this.input[this.pos] === "{") {
+      selections = this.parseSelectionSet();
+      this.skipWhitespaceAndComments();
+    }
+    return { name, alias, arguments: args, selections };
+  }
+  parseArguments() {
+    this.expect("(");
+    this.skipWhitespaceAndComments();
+    const args = [];
+    while (this.pos < this.input.length && this.input[this.pos] !== ")") {
+      const argName = this.parseName();
+      this.skipWhitespaceAndComments();
+      this.expect(":");
+      this.skipWhitespaceAndComments();
+      const value = this.parseValue();
+      args.push({ name: argName, value });
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] === ",") {
+        this.pos++;
+        this.skipWhitespaceAndComments();
+      }
+    }
+    this.expect(")");
+    return args;
+  }
+  parseValue() {
+    const ch = this.input[this.pos];
+    if (ch === '"') {
+      return this.parseString();
+    }
+    if (ch === "-" || ch >= "0" && ch <= "9") {
+      return this.parseNumber();
+    }
+    if (this.peek("true")) {
+      this.pos += 4;
+      return true;
+    }
+    if (this.peek("false")) {
+      this.pos += 5;
+      return false;
+    }
+    if (this.peek("null")) {
+      this.pos += 4;
+      return null;
+    }
+    if (ch === "$") {
+      this.pos++;
+      const varName = this.parseName();
+      return { __variable: varName };
+    }
+    if (ch === "{") {
+      return this.parseObjectLiteral();
+    }
+    if (ch === "[") {
+      return this.parseListLiteral();
+    }
+    if (ch && /[A-Z_a-z]/.test(ch)) {
+      return this.parseName();
+    }
+    throw new Error(`Unexpected character '${ch}' at position ${this.pos}`);
+  }
+  parseString() {
+    this.expect('"');
+    let result = "";
+    while (this.pos < this.input.length && this.input[this.pos] !== '"') {
+      if (this.input[this.pos] === "\\") {
+        this.pos++;
+        const esc = this.input[this.pos];
+        const escapes = {
+          '"': '"',
+          "\\": "\\",
+          "/": "/",
+          n: `
+`,
+          r: "\r",
+          t: "\t",
+          b: "\b",
+          f: "\f"
+        };
+        result += escapes[esc] ?? esc;
+      } else {
+        result += this.input[this.pos];
+      }
+      this.pos++;
+    }
+    this.expect('"');
+    return result;
+  }
+  parseNumber() {
+    let numStr = "";
+    if (this.input[this.pos] === "-") {
+      numStr += "-";
+      this.pos++;
+    }
+    while (this.pos < this.input.length && /[\d.]/.test(this.input[this.pos])) {
+      numStr += this.input[this.pos++];
+    }
+    return Number(numStr);
+  }
+  parseObjectLiteral() {
+    this.expect("{");
+    this.skipWhitespaceAndComments();
+    const obj = {};
+    while (this.pos < this.input.length && this.input[this.pos] !== "}") {
+      const key = this.parseName();
+      this.skipWhitespaceAndComments();
+      this.expect(":");
+      this.skipWhitespaceAndComments();
+      obj[key] = this.parseValue();
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] === ",") {
+        this.pos++;
+        this.skipWhitespaceAndComments();
+      }
+    }
+    this.expect("}");
+    return obj;
+  }
+  parseListLiteral() {
+    this.expect("[");
+    this.skipWhitespaceAndComments();
+    const items = [];
+    while (this.pos < this.input.length && this.input[this.pos] !== "]") {
+      items.push(this.parseValue());
+      this.skipWhitespaceAndComments();
+      if (this.input[this.pos] === ",") {
+        this.pos++;
+        this.skipWhitespaceAndComments();
+      }
+    }
+    this.expect("]");
+    return items;
+  }
+  parseName() {
+    const start = this.pos;
+    while (this.pos < this.input.length && /[\w]/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+    if (this.pos === start) {
+      throw new Error(`Expected name at position ${this.pos}, got '${this.input[this.pos]}'`);
+    }
+    return this.input.slice(start, this.pos);
+  }
+  skipName() {
+    while (this.pos < this.input.length && /[\w]/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  skipBalanced(open, close) {
+    this.expect(open);
+    let depth = 1;
+    while (this.pos < this.input.length && depth > 0) {
+      if (this.input[this.pos] === open)
+        depth++;
+      else if (this.input[this.pos] === close)
+        depth--;
+      this.pos++;
+    }
+  }
+  skipWhitespaceAndComments() {
+    while (this.pos < this.input.length) {
+      if (/\s/.test(this.input[this.pos])) {
+        this.pos++;
+        continue;
+      }
+      if (this.input[this.pos] === "#") {
+        while (this.pos < this.input.length && this.input[this.pos] !== `
+`) {
+          this.pos++;
+        }
+        continue;
+      }
+      break;
+    }
+  }
+  expect(char) {
+    if (this.input[this.pos] !== char) {
+      throw new Error(`Expected '${char}' at position ${this.pos}, got '${this.input[this.pos] ?? "EOF"}'`);
+    }
+    this.pos++;
+  }
+  peek(str) {
+    return this.input.startsWith(str, this.pos);
+  }
+}
+
+class BuiltinGraphQLEngine {
+  supportsIntrospection = false;
+  supportsSubscriptions = false;
+  buildSchema(resolvers, _types, sdl) {
+    const schema = {
+      queries: resolvers.queries,
+      mutations: resolvers.mutations,
+      sdl
+    };
+    return schema;
+  }
+  async execute(schema, query, variables, context, _operationName) {
+    const s = schema;
+    let doc;
+    try {
+      doc = new GraphQLParser(query).parse();
+    } catch (err) {
+      return {
+        data: null,
+        errors: [{ message: String(err.message) }]
+      };
+    }
+    const fields = doc.operation === "mutation" ? s.mutations : s.queries;
+    const data = {};
+    const errors = [];
+    for (const sel of doc.selections) {
+      try {
+        const resolvedValue = await this.resolveSelection(sel, fields, variables, context);
+        const resultKey = sel.alias ?? sel.name;
+        data[resultKey] = resolvedValue;
+      } catch (err) {
+        const resultKey = sel.alias ?? sel.name;
+        data[resultKey] = null;
+        errors.push({
+          message: String(err.message),
+          path: [resultKey]
+        });
+      }
+    }
+    const result = { data };
+    if (errors.length > 0) {
+      result.errors = errors;
+    }
+    return result;
+  }
+  async resolveSelection(sel, fields, variables, context) {
+    const field = fields.get(sel.name);
+    if (!field) {
+      throw new Error(`Field '${sel.name}' does not exist on type`);
+    }
+    const args = this.buildArgsFromSelection(sel, variables);
+    const instance = field.resolverInstance;
+    const methodArgs = this.buildMethodArgs(field, args, context);
+    const rawResult = await instance[field.methodName](...methodArgs);
+    if (sel.selections.length > 0 && rawResult !== null && rawResult !== undefined) {
+      if (Array.isArray(rawResult)) {
+        return Promise.all(rawResult.map((item) => this.resolveObject(item, sel.selections, variables, context)));
+      }
+      return this.resolveObject(rawResult, sel.selections, variables, context);
+    }
+    return rawResult;
+  }
+  async resolveObject(obj, selections, variables, context) {
+    const result = {};
+    const record = obj;
+    for (const sel of selections) {
+      if (sel.name.startsWith("__")) {
+        throw new Error(`Introspection field '${sel.name}' is not supported by the built-in engine.`);
+      }
+      const resultKey = sel.alias ?? sel.name;
+      const fieldValue = record[sel.name];
+      if (sel.selections.length > 0 && fieldValue !== null && fieldValue !== undefined) {
+        if (Array.isArray(fieldValue)) {
+          result[resultKey] = await Promise.all(fieldValue.map((item) => this.resolveObject(item, sel.selections, variables, context)));
+        } else {
+          result[resultKey] = await this.resolveObject(fieldValue, sel.selections, variables, context);
+        }
+      } else {
+        result[resultKey] = fieldValue ?? null;
+      }
+    }
+    return result;
+  }
+  buildArgsFromSelection(sel, variables) {
+    const args = {};
+    for (const arg of sel.arguments) {
+      args[arg.name] = this.resolveValue(arg.value, variables);
+    }
+    return args;
+  }
+  resolveValue(value, variables) {
+    if (value !== null && typeof value === "object" && "__variable" in value) {
+      const varName = value.__variable;
+      return variables[varName];
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.resolveValue(v, variables));
+    }
+    if (value !== null && typeof value === "object") {
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        result[k] = this.resolveValue(v, variables);
+      }
+      return result;
+    }
+    return value;
+  }
+  buildMethodArgs(field, args, context) {
+    const methodArgs = [];
+    for (const param of field.paramMetadata) {
+      if (param.kind === "context") {
+        methodArgs[param.index] = context;
+      } else if (param.kind === "args" && param.argName) {
+        methodArgs[param.index] = args[param.argName];
+      } else if (param.kind === "argsObject" && param.argName) {
+        methodArgs[param.index] = args[param.argName];
+      }
+    }
+    return methodArgs;
+  }
+}
+
+// src/graphql/subscription-handler.ts
+class SubscriptionHandler {
+  engine;
+  engineSchema;
+  graphqlPath;
+  container;
+  globalGuards;
+  globalInterceptors;
+  connections = new Map;
+  constructor(engine, engineSchema, graphqlPath, container, globalGuards, globalInterceptors) {
+    this.engine = engine;
+    this.engineSchema = engineSchema;
+    this.graphqlPath = graphqlPath;
+    this.container = container;
+    this.globalGuards = globalGuards;
+    this.globalInterceptors = globalInterceptors;
+  }
+  getWebSocketConfig() {
+    const upgradeHandler = this.handleUpgrade.bind(this);
+    return {
+      __upgradeHandler: upgradeHandler,
+      open: (ws) => {
+        this.connections.set(ws.data.connectionId, {
+          subscriptions: new Map,
+          initialized: false
+        });
+      },
+      message: async (ws, raw) => {
+        try {
+          const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+          const msg = JSON.parse(text);
+          await this.handleMessage(ws, msg);
+        } catch (err) {
+          this.send(ws, {
+            type: "error",
+            id: "",
+            payload: [{ message: `Protocol error: ${err.message}` }]
+          });
+        }
+      },
+      close: (ws) => {
+        const state = this.connections.get(ws.data.connectionId);
+        if (state) {
+          for (const sub of state.subscriptions.values()) {
+            sub.generator.return?.(undefined);
+          }
+          this.connections.delete(ws.data.connectionId);
+        }
+      },
+      error: (ws, error) => {
+        console.error("[GraphQL WS] WebSocket error:", error);
+      }
+    };
+  }
+  handleUpgrade(req, server) {
+    const url = new URL(req.url);
+    if (url.pathname !== this.graphqlPath) {
+      return;
+    }
+    const protocol = req.headers.get("sec-websocket-protocol") ?? "";
+    if (!protocol.includes("graphql-transport-ws")) {
+      return new Response("Unsupported WebSocket protocol", { status: 426 });
+    }
+    const connectionId = crypto.randomUUID();
+    const upgraded = server.upgrade(req, {
+      headers: {
+        "Sec-WebSocket-Protocol": "graphql-transport-ws"
+      },
+      data: { connectionId }
+    });
+    return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
+  }
+  async handleMessage(ws, msg) {
+    const state = this.connections.get(ws.data.connectionId);
+    if (!state)
+      return;
+    switch (msg.type) {
+      case "connection_init":
+        if (state.initialized) {
+          ws.close(4429, "Too many initialisation requests");
+          return;
+        }
+        state.initialized = true;
+        this.send(ws, { type: "connection_ack" });
+        break;
+      case "subscribe":
+        if (!state.initialized) {
+          ws.close(4401, "Unauthorized: connection not initialized");
+          return;
+        }
+        if (state.subscriptions.has(msg.id)) {
+          ws.close(4409, `Subscriber for ${msg.id} already exists`);
+          return;
+        }
+        await this.handleSubscribe(ws, state, msg);
+        break;
+      case "complete":
+        if (msg.id) {
+          const sub = state.subscriptions.get(msg.id);
+          if (sub) {
+            sub.generator.return?.(undefined);
+            state.subscriptions.delete(msg.id);
+          }
+        }
+        break;
+    }
+  }
+  async handleSubscribe(ws, state, msg) {
+    if (!this.engine.subscribe) {
+      this.send(ws, {
+        type: "error",
+        id: msg.id,
+        payload: [
+          {
+            message: "Subscriptions are not supported by the configured GraphQL engine. " + "Use GraphQLJsAdapter for subscription support."
+          }
+        ]
+      });
+      return;
+    }
+    const context = {
+      request: new Request(`ws://localhost${this.graphqlPath}`),
+      user: undefined,
+      httpContext: null
+    };
+    let generator;
+    try {
+      generator = await this.engine.subscribe(this.engineSchema, msg.payload.query, msg.payload.variables ?? {}, context, msg.payload.operationName);
+    } catch (err) {
+      this.send(ws, {
+        type: "error",
+        id: msg.id,
+        payload: [{ message: err.message }]
+      });
+      return;
+    }
+    state.subscriptions.set(msg.id, { generator });
+    (async () => {
+      try {
+        for await (const result of generator) {
+          if (!state.subscriptions.has(msg.id))
+            break;
+          this.send(ws, {
+            type: "next",
+            id: msg.id,
+            payload: result
+          });
+        }
+        this.send(ws, { type: "complete", id: msg.id });
+        state.subscriptions.delete(msg.id);
+      } catch (err) {
+        this.send(ws, {
+          type: "error",
+          id: msg.id,
+          payload: [{ message: err.message }]
+        });
+        state.subscriptions.delete(msg.id);
+      }
+    })();
+  }
+  send(ws, msg) {
+    try {
+      ws.send(JSON.stringify(msg));
+    } catch {}
+  }
+}
+
+// src/graphql/graphql-module.ts
+init_metadata();
+function generatePlaygroundHTML(path) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>GraphQL Playground</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <link rel="stylesheet" href="https://unpkg.com/graphiql@3/graphiql.min.css" />
+  <style>body { margin: 0; }</style>
+</head>
+<body>
+  <div id="graphiql" style="height:100vh;"></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/graphiql.min.js"></script>
+  <script>
+    const root = ReactDOM.createRoot(document.getElementById('graphiql'));
+    root.render(React.createElement(GraphiQL, {
+      fetcher: GraphiQL.createFetcher({ url: '${path}' }),
+    }));
+  </script>
+</body>
+</html>`;
+}
+
+class GraphQLModuleInstance {
+  sdl;
+  resolvedSchema;
+  path;
+  constructor(sdl, resolvedSchema, path) {
+    this.sdl = sdl;
+    this.resolvedSchema = resolvedSchema;
+    this.path = path;
+  }
+}
+
+class DeferredInitializer {
+  resolverClasses;
+  app;
+  engine;
+  initialized = false;
+  initPromise = null;
+  initError = null;
+  resolverInstances = new Map;
+  resolverFields = null;
+  resolvedSchema = null;
+  sdl = "";
+  engineSchema = null;
+  constructor(resolverClasses, app, engine) {
+    this.resolverClasses = resolverClasses;
+    this.app = app;
+    this.engine = engine;
+  }
+  async ensureInitialized() {
+    if (this.initialized) {
+      if (this.initError)
+        throw this.initError;
+      return;
+    }
+    if (this.initPromise) {
+      await this.initPromise;
+      if (this.initError)
+        throw this.initError;
+      return;
+    }
+    this.initPromise = this.initialize();
+    await this.initPromise;
+    if (this.initError)
+      throw this.initError;
+  }
+  async initialize() {
+    try {
+      for (const ResolverClass of this.resolverClasses) {
+        if (this.resolverInstances.has(ResolverClass))
+          continue;
+        const token = ResolverClass;
+        if (!this.app.container.has(token)) {
+          this.app.container.register({
+            token,
+            useClass: ResolverClass
+          });
+        }
+        const injectTokens = getContainerMetadata(ResolverClass, "inject:tokens") ?? [];
+        const deps = injectTokens.map((t) => {
+          const resolved = resolveForwardRef(t);
+          return this.app.container.resolve(resolved);
+        });
+        const instance = new ResolverClass(...deps);
+        this.resolverInstances.set(ResolverClass, instance);
+      }
+      const builder = new SchemaBuilder(this.resolverClasses, this.resolverInstances);
+      const { sdl, resolvedSchema, resolverFields, typeFields } = builder.build();
+      this.sdl = sdl;
+      this.resolvedSchema = resolvedSchema;
+      this.resolverFields = resolverFields;
+      this.engineSchema = this.engine.buildSchema(resolverFields, typeFields, sdl);
+      this.initialized = true;
+    } catch (err) {
+      this.initError = err instanceof Error ? err : new Error(String(err));
+      throw this.initError;
+    }
+  }
+}
+
+class GraphQLModule {
+  static setup(app, options) {
+    const engine = options.engine ?? new BuiltinGraphQLEngine;
+    const path = options.path ?? "/graphql";
+    const introspection = options.introspection !== false;
+    const playgroundEnabled = options.playground !== undefined ? options.playground : engine.supportsIntrospection;
+    if (options.playground === true && !engine.supportsIntrospection) {
+      console.warn("[GraphQL] Playground enabled but the built-in engine does not support " + "introspection. GraphiQL will not work correctly. " + "Use GraphQLJsAdapter for full playground support.");
+    }
+    const initializer = new DeferredInitializer(options.resolvers, app, engine);
+    app.router.post(path, async (httpContext) => {
+      const parsed = await parseGraphQLRequest(httpContext.req);
+      if (!parsed) {
+        return httpContext.json({
+          errors: [{ message: "Invalid GraphQL request: expected JSON body with 'query' field" }]
+        }, { status: 400 });
+      }
+      try {
+        await initializer.ensureInitialized();
+      } catch (err) {
+        return httpContext.json({
+          errors: [{ message: `GraphQL initialization failed: ${err.message}` }]
+        });
+      }
+      const gqlContext = buildGraphQLContext(httpContext);
+      const schema = initializer.engineSchema;
+      const fields = initializer.resolverFields;
+      const trimmed = parsed.query.trim();
+      const isMutation = trimmed.startsWith("mutation");
+      const operationType = isMutation ? "mutation" : "query";
+      const operationFields = isMutation ? fields.mutations : fields.queries;
+      let result;
+      try {
+        result = await GraphQLModule.executeWithPipeline(engine, schema, parsed, gqlContext, httpContext, operationFields, operationType, isMutation ? "mutation" : "query", options, app);
+      } catch (err) {
+        result = {
+          errors: [{ message: err.message }]
+        };
+      }
+      return httpContext.json(result);
+    });
+    if (introspection) {
+      app.router.get(`${path}/schema`, async (httpContext) => {
+        await initializer.ensureInitialized().catch(() => {});
+        return httpContext.text(initializer.sdl || "# Schema not yet initialized");
+      });
+    }
+    if (playgroundEnabled) {
+      app.router.get(path, (httpContext) => {
+        return httpContext.html(generatePlaygroundHTML(path));
+      });
+    }
+    if (options.subscriptions) {
+      if (!engine.supportsSubscriptions) {
+        console.warn("[GraphQL] subscriptions: true but the configured engine does not support " + "subscriptions. Use GraphQLJsAdapter for subscription support.");
+      } else {
+        const subHandler = new SubscriptionHandler(engine, null, path, app.container, app.getGlobalGuards(), app.getGlobalInterceptors());
+        app.setWebSocketHandler(subHandler.getWebSocketConfig());
+      }
+    }
+    if (options.syncOpenAPI) {
+      queueMicrotask(async () => {
+        try {
+          await initializer.ensureInitialized().catch(() => {});
+          const typeClasses = getRegisteredTypeClasses();
+          const { setApiPropertyMetadata: setApiPropertyMetadata2 } = await Promise.resolve().then(() => (init_metadata2(), exports_metadata2));
+          const { getGqlPropertyKeys: getGqlPropertyKeys2, getGqlPropertyMetadata: getGqlPropertyMetadata2 } = await Promise.resolve().then(() => (init_metadata(), exports_metadata));
+          for (const TypeClass of typeClasses) {
+            const keys = getGqlPropertyKeys2(TypeClass.prototype);
+            for (const key of keys) {
+              const fieldMeta = getGqlPropertyMetadata2(TypeClass.prototype, key);
+              if (!fieldMeta)
+                continue;
+              const apiOptions = GraphQLModule.fieldToApiProperty(fieldMeta);
+              setApiPropertyMetadata2(TypeClass.prototype, key, apiOptions);
+            }
+          }
+        } catch {
+          console.warn("[GraphQL] syncOpenAPI: failed to sync field metadata to OpenAPI store. Ensure @buenojs/bueno/openapi is available.");
+        }
+      });
+    }
+    return new GraphQLModuleInstance("", {}, path);
+  }
+  static async executeWithPipeline(engine, schema, parsed, gqlContext, httpContext, operationFields, operationType, _opTypeStr, options, app) {
+    const topLevelFields = extractTopLevelFields(parsed.query);
+    for (const fieldName of topLevelFields) {
+      const resolvedField = operationFields.get(fieldName);
+      if (!resolvedField)
+        continue;
+      const resolverClass = findResolverClass(options.resolvers, fieldName, operationType);
+      if (!resolverClass)
+        continue;
+      const guardsPassed = await runGuardsForField(resolverClass, fieldName, httpContext, gqlContext, operationType, app);
+      if (!guardsPassed) {
+        return {
+          errors: [
+            {
+              message: `Access denied to field '${fieldName}'`,
+              path: [fieldName],
+              extensions: { code: "FORBIDDEN" }
+            }
+          ]
+        };
+      }
+    }
+    return engine.execute(schema, parsed.query, parsed.variables, gqlContext, parsed.operationName);
+  }
+  static fieldToApiProperty(fieldMeta) {
+    const type = fieldMeta.typeFn();
+    const isArray = Array.isArray(type);
+    const inner = isArray ? type[0] : type;
+    let apiType;
+    if (inner === String)
+      apiType = "string";
+    else if (inner === Number)
+      apiType = "number";
+    else if (inner === Boolean)
+      apiType = "boolean";
+    else if (inner.name === "GraphQLID")
+      apiType = "string";
+    else if (inner.name === "GraphQLInt")
+      apiType = "integer";
+    else if (inner.name === "GraphQLFloat")
+      apiType = "number";
+    else
+      apiType = inner;
+    const options = {
+      required: !fieldMeta.nullable
+    };
+    if (isArray) {
+      options.type = "array";
+      options.items = typeof apiType === "string" ? { type: apiType } : { $ref: `#/components/schemas/${inner.name}` };
+    } else {
+      options.type = apiType;
+    }
+    if (fieldMeta.description) {
+      options.description = fieldMeta.description;
+    }
+    return options;
+  }
+}
+function extractTopLevelFields(query) {
+  const stripped = query.trim().replace(/^(query|mutation)\s*\w*\s*(\([^)]*\))?\s*/, "");
+  const match = stripped.match(/^\{([\s\S]*)\}$/);
+  if (!match)
+    return [];
+  const body = match[1];
+  const fields = [];
+  let depth = 0;
+  let nameStart = -1;
+  for (let i = 0;i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+    } else if (depth === 0 && /[A-Za-z_]/.test(ch) && nameStart < 0) {
+      nameStart = i;
+    } else if (depth === 0 && nameStart >= 0 && !/[\w]/.test(ch)) {
+      const name = body.slice(nameStart, i);
+      if (body[i] === ":") {
+        nameStart = -1;
+        continue;
+      }
+      if (name !== "on")
+        fields.push(name);
+      nameStart = -1;
+    }
+  }
+  if (nameStart >= 0) {
+    fields.push(body.slice(nameStart));
+  }
+  return [...new Set(fields)];
+}
+function findResolverClass(resolverClasses, fieldName, operationType) {
+  for (const ResolverClass of resolverClasses) {
+    const fields = operationType === "mutation" ? getMutationFields(ResolverClass.prototype) : getQueryFields(ResolverClass.prototype);
+    if (fields.some((f) => f.fieldName === fieldName)) {
+      return ResolverClass;
+    }
+  }
+  return;
+}
+async function runGuardsForField(resolverClass, fieldName, httpContext, gqlContext, operationType, app) {
+  const { executeGuards: executeGuards2, getClassGuards: getClassGuards2, getMethodGuards: getMethodGuards2 } = await Promise.resolve().then(() => (init_guards(), exports_guards));
+  const { resolveForwardRef: resolveForwardRef2 } = await Promise.resolve().then(() => (init_container(), exports_container));
+  const classGuards = getClassGuards2(resolverClass) ?? [];
+  const methodGuards = getMethodGuards2(resolverClass.prototype, fieldName) ?? [];
+  const globalGuards = app.getGlobalGuards();
+  const { enrichContextForGraphQL: enrichContextForGraphQL2 } = await Promise.resolve().then(() => exports_context_builder);
+  enrichContextForGraphQL2(httpContext, fieldName, operationType, resolverClass);
+  return executeGuards2(httpContext, {
+    globalGuards,
+    classGuards,
+    methodGuards,
+    resolveGuard: (guard) => {
+      if (typeof guard === "object" && guard !== null && !("canActivate" in guard)) {
+        try {
+          return app.container.resolve(guard);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+  });
+}
+// src/graphql/decorators.ts
+init_metadata();
+function Resolver(name) {
+  return (target) => {
+    const ctor = target;
+    setResolverMetadata(ctor, {
+      name: name ?? ctor.name
+    });
+  };
+}
+function ObjectType(name, options) {
+  return (target) => {
+    const ctor = target;
+    setObjectTypeMetadata(ctor, {
+      name: name ?? ctor.name,
+      kind: "object",
+      description: options?.description
+    });
+    registerTypeClass(ctor);
+  };
+}
+function InputType(name, options) {
+  return (target) => {
+    const ctor = target;
+    setInputTypeMetadata(ctor, {
+      name: name ?? ctor.name,
+      kind: "input",
+      description: options?.description
+    });
+    registerTypeClass(ctor);
+  };
+}
+function Query(typeFn, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const methodName = String(propertyKey);
+    addQueryField(target, {
+      methodName,
+      fieldName: options.name ?? methodName,
+      typeFn,
+      kind: "query",
+      nullable: options.nullable ?? false,
+      description: options.description,
+      deprecationReason: options.deprecationReason,
+      paramMetadata: getParamMetadata(target, methodName)
+    });
+    return descriptor;
+  };
+}
+function Mutation(typeFn, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const methodName = String(propertyKey);
+    addMutationField(target, {
+      methodName,
+      fieldName: options.name ?? methodName,
+      typeFn,
+      kind: "mutation",
+      nullable: options.nullable ?? false,
+      description: options.description,
+      deprecationReason: options.deprecationReason,
+      paramMetadata: getParamMetadata(target, methodName)
+    });
+    return descriptor;
+  };
+}
+function Subscription(typeFn, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const methodName = String(propertyKey);
+    addSubscriptionField(target, {
+      methodName,
+      fieldName: options.name ?? methodName,
+      typeFn,
+      kind: "subscription",
+      nullable: options.nullable ?? false,
+      description: options.description,
+      deprecationReason: options.deprecationReason,
+      paramMetadata: getParamMetadata(target, methodName)
+    });
+    return descriptor;
+  };
+}
+function Field(typeFn, options = {}) {
+  return (target, propertyKey) => {
+    const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+    setGqlPropertyMetadata(target, propertyKey, {
+      propertyKey: key,
+      typeFn,
+      nullable: options.nullable ?? false,
+      description: options.description,
+      deprecationReason: options.deprecationReason,
+      defaultValue: options.defaultValue
+    });
+  };
+}
+function Args(name, inputType) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey)
+      return;
+    const methodName = String(propertyKey);
+    setParamMetadata(target, methodName, parameterIndex, {
+      index: parameterIndex,
+      kind: inputType ? "argsObject" : "args",
+      argName: name,
+      inputTypeFn: inputType ? () => inputType : undefined
+    });
+    syncParamMetadata(target, methodName);
+  };
+}
+function GqlContext() {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey)
+      return;
+    const methodName = String(propertyKey);
+    setParamMetadata(target, methodName, parameterIndex, {
+      index: parameterIndex,
+      kind: "context"
+    });
+    syncParamMetadata(target, methodName);
+  };
+}
+function syncParamMetadata(prototype, methodName) {
+  const params = getParamMetadata(prototype, methodName);
+  const syncFields = (fields, addFn) => {
+    const field = fields.find((f) => f.methodName === methodName);
+    if (field) {
+      addFn(prototype, { ...field, paramMetadata: params });
+    }
+  };
+  syncFields(getQueryFields(prototype), addQueryField);
+  syncFields(getMutationFields(prototype), addMutationField);
+  syncFields(getSubscriptionFields(prototype), addSubscriptionField);
+}
+// src/graphql/types.ts
+class GraphQLID {
+  static __type = "ID";
+}
+
+class GraphQLInt {
+  static __type = "Int";
+}
+
+class GraphQLFloat {
+  static __type = "Float";
+}
+// src/graphql/execution-pipeline.ts
+init_guards();
+
+// src/modules/interceptors.ts
+var interceptorsClassMetadata = new WeakMap;
+var interceptorsMethodMetadata = new WeakMap;
+function setClassInterceptors(target, interceptors) {
+  interceptorsClassMetadata.set(target, interceptors);
+}
+function getClassInterceptors(target) {
+  return interceptorsClassMetadata.get(target);
+}
+function setMethodInterceptors(target, propertyKey, interceptors) {
+  if (!interceptorsMethodMetadata.has(target)) {
+    interceptorsMethodMetadata.set(target, new Map);
+  }
+  interceptorsMethodMetadata.get(target)?.set(propertyKey, interceptors);
+}
+function getMethodInterceptors(target, propertyKey) {
+  return interceptorsMethodMetadata.get(target)?.get(propertyKey);
+}
+function UseInterceptors(...interceptors) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined && descriptor !== undefined) {
+      const targetObj = target;
+      const existingInterceptors = getMethodInterceptors(targetObj, propertyKey) ?? [];
+      setMethodInterceptors(targetObj, propertyKey, [
+        ...existingInterceptors,
+        ...interceptors
+      ]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingInterceptors = getClassInterceptors(targetClass) ?? [];
+      setClassInterceptors(targetClass, [
+        ...existingInterceptors,
+        ...interceptors
+      ]);
+    }
+  };
+  return decorator;
+}
+
+class LoggingInterceptor {
+  async intercept(context, next) {
+    const method = context.method;
+    const path = context.path;
+    const startTime = Date.now();
+    console.log(`[${method}] ${path} - Started`);
+    try {
+      const result = await next.handle();
+      const duration = Date.now() - startTime;
+      console.log(`[${method}] ${path} - Completed in ${duration}ms`);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      console.error(`[${method}] ${path} - Failed in ${duration}ms`, error);
+      throw error;
+    }
+  }
+}
+
+class TransformInterceptor {
+  async intercept(context, next) {
+    const result = await next.handle();
+    return {
+      data: result,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+class TimeoutInterceptor {
+  timeoutMs;
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  async intercept(context, next) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Request timeout after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+    });
+    return Promise.race([next.handle(), timeoutPromise]);
+  }
+}
+
+class CacheInterceptor {
+  ttlMs;
+  static cache = new Map;
+  static cleanupInterval = null;
+  constructor(ttlMs = 60000) {
+    this.ttlMs = ttlMs;
+    CacheInterceptor.setupCleanup();
+  }
+  static setupCleanup() {
+    if (CacheInterceptor.cleanupInterval === null) {
+      CacheInterceptor.cleanupInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [key, entry] of CacheInterceptor.cache.entries()) {
+          if (entry.expiresAt < now) {
+            CacheInterceptor.cache.delete(key);
+          }
+        }
+      }, 60000);
+    }
+  }
+  getCacheKey(context) {
+    return `${context.method}:${context.path}:${context.url.search}`;
+  }
+  static clearCache() {
+    CacheInterceptor.cache.clear();
+  }
+  static clearCachePattern(pattern) {
+    for (const key of CacheInterceptor.cache.keys()) {
+      if (key.includes(pattern)) {
+        CacheInterceptor.cache.delete(key);
+      }
+    }
+  }
+  async intercept(context, next) {
+    const cacheKey = this.getCacheKey(context);
+    const now = Date.now();
+    const cached = CacheInterceptor.cache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.value;
+    }
+    const result = await next.handle();
+    CacheInterceptor.cache.set(cacheKey, {
+      value: result,
+      expiresAt: now + this.ttlMs
+    });
+    return result;
+  }
+}
+
+class HeaderInterceptor {
+  headers;
+  constructor(headers) {
+    this.headers = headers;
+  }
+  async intercept(context, next) {
+    const result = await next.handle();
+    if (result instanceof Response) {
+      const newHeaders = new Headers(result.headers);
+      for (const [key, value] of Object.entries(this.headers)) {
+        newHeaders.set(key, value);
+      }
+      return new Response(result.body, {
+        status: result.status,
+        statusText: result.statusText,
+        headers: newHeaders
+      });
+    }
+    return result;
+  }
+}
+function createCallHandler(interceptors, context, finalHandler, resolveInterceptor) {
+  let index = 0;
+  const execute = async () => {
+    if (index >= interceptors.length) {
+      return finalHandler();
+    }
+    const interceptor = interceptors[index++];
+    let interceptorInstance = interceptor;
+    if (resolveInterceptor && !isNestInterceptor(interceptor) && !isInterceptorFn(interceptor)) {
+      interceptorInstance = resolveInterceptor(interceptor);
+    }
+    if (!interceptorInstance) {
+      console.warn("Interceptor could not be resolved:", interceptor);
+      return execute();
+    }
+    const next = {
+      handle: () => execute()
+    };
+    if (isInterceptorFn(interceptorInstance)) {
+      return interceptorInstance(context, () => execute());
+    } else {
+      return interceptorInstance.intercept(context, next);
+    }
+  };
+  return {
+    handle: execute
+  };
+}
+async function executeInterceptors(context, handler, options) {
+  const {
+    globalInterceptors = [],
+    classInterceptors = [],
+    methodInterceptors = [],
+    resolveInterceptor
+  } = options;
+  const allInterceptors = [
+    ...globalInterceptors,
+    ...classInterceptors,
+    ...methodInterceptors
+  ];
+  if (allInterceptors.length === 0) {
+    return handler();
+  }
+  const resolvedInterceptors = [];
+  for (const interceptor of allInterceptors) {
+    let instance = null;
+    if (typeof interceptor === "function") {
+      const funcInterceptor = interceptor;
+      if (funcInterceptor.prototype && typeof funcInterceptor.prototype === "object" && "intercept" in funcInterceptor.prototype) {
+        instance = resolveInterceptor ? resolveInterceptor(interceptor) : null;
+        if (!instance) {
+          const InterceptorClass = interceptor;
+          instance = new InterceptorClass;
+        }
+      } else {
+        instance = interceptor;
+      }
+    } else if (typeof interceptor === "object" && interceptor !== null) {
+      const objInterceptor = interceptor;
+      if ("intercept" in objInterceptor && typeof objInterceptor.intercept === "function") {
+        instance = interceptor;
+      } else {
+        instance = resolveInterceptor ? resolveInterceptor(interceptor) : null;
+      }
+    }
+    if (instance) {
+      resolvedInterceptors.push(instance);
+    } else {
+      console.warn("Interceptor could not be resolved:", interceptor);
+    }
+  }
+  const callHandler = createCallHandler(resolvedInterceptors, context, handler, resolveInterceptor);
+  return callHandler.handle();
+}
+function isNestInterceptor(value) {
+  return typeof value === "object" && value !== null && "intercept" in value && typeof value.intercept === "function";
+}
+function isInterceptorFn(value) {
+  return typeof value === "function" && !isNestInterceptor(value);
+}
+// src/graphql/execution-pipeline.ts
+class GraphQLForbiddenError extends Error {
+  extensions = { code: "FORBIDDEN" };
+  constructor(message = "Forbidden") {
+    super(message);
+    this.name = "GraphQLForbiddenError";
+  }
+  toGraphQLError() {
+    return {
+      message: this.message,
+      extensions: this.extensions
+    };
+  }
+}
+export {
+  buildGraphQLContext,
+  SubscriptionHandler,
+  Subscription,
+  SchemaBuilder,
+  Resolver,
+  Query,
+  ObjectType,
+  Mutation,
+  InputType,
+  GraphQLModuleInstance,
+  GraphQLModule,
+  GraphQLInt,
+  GraphQLID,
+  GraphQLForbiddenError,
+  GraphQLFloat,
+  GqlContext,
+  Field,
+  BuiltinGraphQLEngine,
+  Args
+};