@buenojs/bueno 0.8.5 → 0.8.7

package/dist/index.js

@@ -26,6 +26,237 @@ var __legacyMetadataTS = (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: () => Container2
+});
+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 Container2 {
+  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 Container2;
+    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/context/index.ts
 var exports_context = {};
 __export(exports_context, {
@@ -259,6 +490,150 @@ function createPipeline() {
   return new Pipeline;
 }
 
+// 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, descriptor2) => {
+    if (propertyKey !== undefined && descriptor2 !== undefined) {
+      const targetObj = target;
+      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
+      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
+      return descriptor2;
+    } 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, descriptor2) => {
+    const targetObj = target;
+    setMethodRoles(targetObj, propertyKey, roles);
+    return descriptor2;
+  };
+}
+
+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/validation/index.ts
 async function validate(schema, data) {
   try {
@@ -413,6 +788,59 @@ function validateEnvSync(schema, envVars) {
   }
 }
 
+// src/openapi/metadata.ts
+var exports_metadata = {};
+__export(exports_metadata, {
+  setApiPropertyMetadata: () => setApiPropertyMetadata,
+  setApiMethodMetadata: () => setApiMethodMetadata,
+  setApiMetadata: () => setApiMetadata,
+  getApiPropertyMetadata: () => getApiPropertyMetadata,
+  getApiPropertyKeys: () => getApiPropertyKeys,
+  getApiMethodMetadata: () => getApiMethodMetadata,
+  getApiMetadata: () => getApiMetadata
+});
+function setApiMetadata(target, key, value) {
+  if (!classMetadataStore.has(target)) {
+    classMetadataStore.set(target, new Map);
+  }
+  classMetadataStore.get(target)?.set(key, value);
+}
+function getApiMetadata(target, key) {
+  return classMetadataStore.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 (!propertyMetadataStore.has(target)) {
+    propertyMetadataStore.set(target, new Map);
+  }
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  propertyMetadataStore.get(target)?.set(key, value);
+}
+function getApiPropertyMetadata(target, propertyKey) {
+  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
+  return propertyMetadataStore.get(target)?.get(key);
+}
+function getApiPropertyKeys(target) {
+  const metaMap = propertyMetadataStore.get(target);
+  if (!metaMap)
+    return [];
+  return Array.from(metaMap.keys());
+}
+var classMetadataStore, methodMetadataStore, propertyMetadataStore;
+var init_metadata = __esm(() => {
+  classMetadataStore = new WeakMap;
+  methodMetadataStore = new WeakMap;
+  propertyMetadataStore = new WeakMap;
+});
+
 // src/config/merge.ts
 function isPlainObject(value) {
   if (value === null || typeof value !== "object") {
@@ -1599,278 +2027,69 @@ function watchConfig(filePath, callback, options) {
     try {
       configCache.delete(filePath);
       const { config } = await loadConfigFile(filePath, { useCache: false });
-      if (timeout) {
-        clearTimeout(timeout);
-      }
-      timeout = setTimeout(() => {
-        callback(config);
-      }, debounce);
-    } catch {}
-  }, 1000);
-  return () => {
-    clearInterval(interval);
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-  };
-}
-function validateConfigStructure(config) {
-  if (config === null || typeof config !== "object") {
-    return false;
-  }
-  const validKeys = new Set([
-    "server",
-    "database",
-    "cache",
-    "logger",
-    "health",
-    "metrics",
-    "telemetry",
-    "frontend"
-  ]);
-  const cfg = config;
-  for (const key of Object.keys(cfg)) {
-    if (!validKeys.has(key)) {
-      console.warn(`Unknown config key: ${key}`);
-    }
-  }
-  return true;
-}
-function getConfigPathFromArgs(args = process.argv) {
-  const configIndex = args.indexOf("--config");
-  if (configIndex !== -1 && args[configIndex + 1]) {
-    return args[configIndex + 1];
-  }
-  const shortIndex = args.indexOf("-c");
-  if (shortIndex !== -1 && args[shortIndex + 1]) {
-    return args[shortIndex + 1];
-  }
-  return;
-}
-function getConfigPathFromEnv() {
-  return Bun.env.BUENO_CONFIG;
-}
-var CONFIG_FILES, configCache;
-var init_loader = __esm(() => {
-  CONFIG_FILES = [
-    "bueno.config.ts",
-    "bueno.config.js",
-    ".buenorc.ts",
-    ".buenorc.js",
-    "bueno.config.mjs"
-  ];
-  configCache = new Map;
-});
-
-// src/container/forward-ref.ts
-var FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
-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;
-}
-
-// src/container/index.ts
-function createToken(description) {
-  return Symbol(description);
-}
-var Token = createToken;
-
-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 Container2 {
-  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 Container2;
-    for (const [token, resolved] of this.providers) {
-      if (resolved.provider.scope === "singleton") {
-        child.providers.set(token, resolved);
+      if (timeout) {
+        clearTimeout(timeout);
       }
+      timeout = setTimeout(() => {
+        callback(config);
+      }, debounce);
+    } catch {}
+  }, 1000);
+  return () => {
+    clearInterval(interval);
+    if (timeout) {
+      clearTimeout(timeout);
     }
-    return child;
-  }
+  };
 }
-var containerMetadata = new WeakMap;
-function setContainerMetadata(target, key, value) {
-  if (!containerMetadata.has(target)) {
-    containerMetadata.set(target, new Map);
+function validateConfigStructure(config) {
+  if (config === null || typeof config !== "object") {
+    return false;
   }
-  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);
+  const validKeys = new Set([
+    "server",
+    "database",
+    "cache",
+    "logger",
+    "health",
+    "metrics",
+    "telemetry",
+    "frontend"
+  ]);
+  const cfg = config;
+  for (const key of Object.keys(cfg)) {
+    if (!validKeys.has(key)) {
+      console.warn(`Unknown config key: ${key}`);
     }
-    return target;
-  };
+  }
+  return true;
 }
-function Inject(token) {
-  return (target, propertyKey, parameterIndex) => {
-    const targetObj = target;
-    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
-    existingTokens[parameterIndex] = token;
-    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
-  };
+function getConfigPathFromArgs(args = process.argv) {
+  const configIndex = args.indexOf("--config");
+  if (configIndex !== -1 && args[configIndex + 1]) {
+    return args[configIndex + 1];
+  }
+  const shortIndex = args.indexOf("-c");
+  if (shortIndex !== -1 && args[shortIndex + 1]) {
+    return args[shortIndex + 1];
+  }
+  return;
+}
+function getConfigPathFromEnv() {
+  return Bun.env.BUENO_CONFIG;
 }
+var CONFIG_FILES, configCache;
+var init_loader = __esm(() => {
+  CONFIG_FILES = [
+    "bueno.config.ts",
+    "bueno.config.js",
+    ".buenorc.ts",
+    ".buenorc.js",
+    "bueno.config.mjs"
+  ];
+  configCache = new Map;
+});
+
 // src/router/linear.ts
 function patternToRegex(pattern) {
   const paramNames = [];
@@ -2747,6 +2966,9 @@ class NotFoundError extends BuenoError {
   }
 }
 
+// src/modules/index.ts
+init_container();
+
 // src/modules/filters.ts
 var filterMetadataStore = new WeakMap;
 var catchMetadataStore = new WeakMap;
@@ -2947,134 +3169,8 @@ function createInternalErrorResponse(exception) {
   });
 }
 
-// src/modules/guards.ts
-var guardsClassMetadata = new WeakMap;
-var guardsMethodMetadata = new WeakMap;
-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, descriptor2) => {
-    if (propertyKey !== undefined && descriptor2 !== undefined) {
-      const targetObj = target;
-      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
-      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
-      return descriptor2;
-    } 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;
-  }
-}
-var rolesMethodMetadata = new WeakMap;
-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, descriptor2) => {
-    const targetObj = target;
-    setMethodRoles(targetObj, propertyKey, roles);
-    return descriptor2;
-  };
-}
-
-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"
-    }
-  });
-}
+// src/modules/index.ts
+init_guards();
 
 // src/modules/interceptors.ts
 var interceptorsClassMetadata = new WeakMap;
@@ -3949,7 +4045,10 @@ function isPipeTransform(value) {
 function isPipeFn(value) {
   return typeof value === "function" && !isPipeTransform(value);
 }
+
 // src/modules/index.ts
+init_guards();
+init_container();
 function Inject2(token) {
   return (target, propertyKey, parameterIndex) => {
     const targetObj = target;
@@ -4053,6 +4152,7 @@ class Application {
   routeInterceptorMetadata = new Map;
   moduleLoader;
   loadedLazyModules = new Set;
+  websocketHandler = null;
   constructor(moduleClass) {
     this.container = new Container2;
     this.router = new Router;
@@ -4065,6 +4165,15 @@ class Application {
     this.globalGuards.push(...guards);
     return this;
   }
+  getGlobalGuards() {
+    return this.globalGuards;
+  }
+  getGlobalInterceptors() {
+    return this.globalInterceptors;
+  }
+  setWebSocketHandler(handler) {
+    this.websocketHandler = handler;
+  }
   useGlobalPipes(...pipes) {
     this.globalPipes.push(...pipes);
     return this;
@@ -4238,7 +4347,16 @@ class Application {
     this.server = Bun.serve({
       port,
       hostname,
-      fetch: async (request) => {
+      ...this.websocketHandler ? { websocket: this.websocketHandler } : {},
+      fetch: async (request, server) => {
+        if (this.websocketHandler && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+          const wsUpgradeHandler = this.websocketHandler.__upgradeHandler;
+          if (wsUpgradeHandler) {
+            const response = wsUpgradeHandler(request, server);
+            if (response)
+              return response;
+          }
+        }
         if (this.isShuttingDown) {
           return new Response("Service Unavailable", { status: 503 });
         }
@@ -7938,47 +8056,9 @@ class DocumentBuilder {
     return this.document;
   }
 }
-// src/openapi/metadata.ts
-var classMetadataStore = new WeakMap;
-function setApiMetadata(target, key, value) {
-  if (!classMetadataStore.has(target)) {
-    classMetadataStore.set(target, new Map);
-  }
-  classMetadataStore.get(target)?.set(key, value);
-}
-function getApiMetadata(target, key) {
-  return classMetadataStore.get(target)?.get(key);
-}
-var methodMetadataStore = new WeakMap;
-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);
-}
-var propertyMetadataStore = new WeakMap;
-function setApiPropertyMetadata(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 getApiPropertyMetadata(target, propertyKey) {
-  const key = typeof propertyKey === "symbol" ? propertyKey.toString() : propertyKey;
-  return propertyMetadataStore.get(target)?.get(key);
-}
-function getApiPropertyKeys(target) {
-  const metaMap = propertyMetadataStore.get(target);
-  if (!metaMap)
-    return [];
-  return Array.from(metaMap.keys());
-}
-
 // src/openapi/schema-generator.ts
+init_metadata();
+
 class SchemaGenerator {
   schemas = new Map;
   typeNames = new Map;
@@ -8147,6 +8227,7 @@ class SchemaGenerator {
   }
 }
 // src/openapi/route-scanner.ts
+init_metadata();
 class RouteScanner {
   schemaGenerator;
   constructor(schemaGenerator) {
@@ -8357,6 +8438,7 @@ class SwaggerModule {
   }
 }
 // src/openapi/decorators.ts
+init_metadata();
 function ApiTags(...tags) {
   return (target) => {
     const existingTags = getApiMetadata(target, "api:tags") ?? [];
@@ -10446,6 +10528,10 @@ class ObservabilityModule {
     return service;
   }
 }
+
+// src/index.ts
+init_container();
+
 // src/middleware/built-in.ts
 function logger(options = {}) {
   const { format = "text", level = "info" } = options;