@stacksjs/bun-router 0.0.19 → 0.0.21

package/dist/container/index.js

@@ -1,1193 +1,255 @@
 // @bun
 import {
-  RouterException
-} from "../chunk-a8p83068.js";
-import"../chunk-2mx7fq49.js";
-
-// src/errors/router-errors.ts
-class CircularDependencyException extends RouterException {
-  dependencyChain;
-  suggestion;
-  constructor(dependencyChain, context) {
-    const message = CircularDependencyException.buildMessage(dependencyChain);
-    const suggestion = CircularDependencyException.buildSuggestion(dependencyChain);
-    super({
-      code: "CIRCULAR_DEPENDENCY",
-      message,
-      statusCode: 500,
-      context,
-      retryable: false,
-      severity: "critical",
-      category: "system"
-    });
-    this.dependencyChain = dependencyChain;
-    this.suggestion = suggestion;
-  }
-  static buildMessage(chain) {
-    const lines = [
-      "Circular dependency detected in the dependency injection container!",
-      "",
-      "Dependency chain:",
-      ""
-    ];
-    for (let i = 0;i < chain.length; i++) {
-      const isLast = i === chain.length - 1;
-      const prefix = i === 0 ? "\u250C\u2500\u25BA" : isLast ? "\u2514\u2500\u25BA" : "\u251C\u2500\u25BA";
-      lines.push(`  ${prefix} ${chain[i]}`);
-      if (!isLast) {
-        lines.push("  \u2502");
-      }
-    }
-    lines.push("  \u2502");
-    lines.push(`  \u2514\u2500\u2500 cycles back to: ${chain[0]}`);
-    return lines.join(`
-`);
-  }
-  static buildSuggestion(chain) {
-    return `How to fix:
-
-1. Break the cycle by introducing an interface:
-  \u2022 Create an interface for one of the dependencies
-  \u2022 Use lazy injection: container.bind('${chain[0]}').lazy()
-
-2. Restructure your dependencies:
-  \u2022 Extract shared logic into a separate service
-  \u2022 Use events/callbacks instead of direct dependencies
-
-3. Use setter injection instead of constructor injection:
-  \u2022 Remove the dependency from the constructor
-  \u2022 Set it after instantiation using a setter method
-
-4. Check if the dependency is actually needed:
-  \u2022 Sometimes circular dependencies indicate a design issue
-  \u2022 Consider if the classes have too many responsibilities
-
-Dependency chain involved:
-${chain.map((dep, i) => `  ${i + 1}. ${dep}`).join(`
-`)}`;
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      dependencyChain: this.dependencyChain,
-      suggestion: this.suggestion
-    };
-  }
-}
-
-// src/container/container.ts
-var INJECTABLE_METADATA_KEY = Symbol("injectable");
-var INJECT_METADATA_KEY = Symbol("inject");
-var OPTIONAL_METADATA_KEY = Symbol("optional");
-var TAGGED_METADATA_KEY = Symbol("tagged");
-
-class Container {
-  bindings = new Map;
-  tagIndex = new Map;
-  instances = new Map;
-  scopedInstances = new Map;
-  interceptors = new Map;
-  parent;
-  children = new Set;
-  options;
-  constructor(options = {}) {
-    this.options = {
-      autoRegister: options.autoRegister ?? true,
-      strictMode: options.strictMode ?? false,
-      maxDepth: options.maxDepth ?? 50,
-      enableDecorators: options.enableDecorators ?? true,
-      enableInterception: options.enableInterception ?? false,
-      defaultScope: options.defaultScope ?? "transient"
-    };
-  }
-  bind(token) {
-    return new BindingBuilder(this, token);
-  }
-  register(binding) {
-    const existing = this.bindings.get(binding.token);
-    if (existing?.metadata?.tags) {
-      for (const tag of existing.metadata.tags) {
-        this.tagIndex.get(tag)?.delete(binding.token);
-      }
-    }
-    this.bindings.set(binding.token, binding);
-    if (binding.metadata?.tags) {
-      for (const tag of binding.metadata.tags) {
-        let tokens = this.tagIndex.get(tag);
-        if (!tokens) {
-          tokens = new Set;
-          this.tagIndex.set(tag, tokens);
-        }
-        tokens.add(binding.token);
-      }
-    }
-    return this;
-  }
-  singleton(token, implementation) {
-    return this.bind(token).to(implementation).inSingletonScope().build();
-  }
-  transient(token, implementation) {
-    return this.bind(token).to(implementation).inTransientScope().build();
-  }
-  value(token, value) {
-    return this.bind(token).toValue(value).build();
-  }
-  factory(token, factory) {
-    return this.bind(token).toFactory(factory).build();
-  }
-  resolve(token, context) {
-    const resolutionContext = {
-      container: this,
+  AuthGuard,
+  AuthService,
+  AuthServiceProvider,
+  BaseDeferredServiceProvider,
+  BaseServiceProvider,
+  BindingBuilder,
+  BindingConditions,
+  CacheManager,
+  CacheServiceProvider,
+  ConfigService,
+  ConfigServiceProvider,
+  ConsoleLogger,
+  Container,
+  ContextualContainer,
+  DatabaseConnection,
+  DatabaseServiceProvider,
+  DefaultContextualBindingBuilder,
+  DefaultServiceProviderManager,
+  EnvironmentManager,
+  EnvironmentPresets,
+  EventBus,
+  EventDispatcher,
+  EventServiceProvider,
+  FileLogger,
+  INJECTABLE_METADATA_KEY,
+  INJECT_METADATA_KEY,
+  JwtService,
+  Logger,
+  LoggingServiceProvider,
+  MemoryCache,
+  OPTIONAL_METADATA_KEY,
+  PostRepository,
+  RedisCache,
+  TAGGED_METADATA_KEY,
+  UserRepository,
+  ValidationPipe,
+  ValidationServiceProvider,
+  Validator,
+  createContainer,
+  getContainer,
+  setContainer
+} from "../chunk-g3ybefhg.js";
+import"../chunk-1ahs68ys.js";
+// src/container/decorators.ts
+var CONTROLLER_METADATA_KEY = Symbol("controller");
+var ROUTE_METADATA_KEY = Symbol("route");
+var MIDDLEWARE_METADATA_KEY = Symbol("middleware");
+var PARAM_METADATA_KEY = Symbol("param");
+function Injectable(metadata = {}) {
+  return (target) => {
+    target[INJECTABLE_METADATA_KEY] = metadata;
+    return target;
+  };
+}
+function Inject(token, options) {
+  return function(target, _propertyKey, parameterIndex) {
+    const classConstructor = target.constructor === Function ? target : target.constructor;
+    if (!classConstructor[INJECT_METADATA_KEY]) {
+      classConstructor[INJECT_METADATA_KEY] = [];
+    }
+    const metadata = {
       token,
-      environment: context?.environment || "development",
-      requestId: context?.requestId || this.generateRequestId(),
-      depth: context?.depth || 0,
-      resolving: context?.resolving || new Set,
-      parent: context?.parent
+      optional: options?.optional,
+      tags: options?.tags,
+      when: options?.when
     };
-    return this.resolveInternal(token, resolutionContext);
-  }
-  resolveAll(token) {
-    const tokens = new Set;
-    if (this.bindings.has(token)) {
-      tokens.add(token);
-    }
-    if (typeof token === "string") {
-      for (const tagged of this.tagIndex.get(token) ?? []) {
-        tokens.add(tagged);
-      }
-    }
-    return Array.from(tokens, (t) => this.resolve(t));
-  }
-  resolveTagged(tag) {
-    const tokens = this.tagIndex.get(tag);
-    if (!tokens || tokens.size === 0) {
-      return [];
-    }
-    return Array.from(tokens, (token) => this.resolve(token));
-  }
-  getTaggedBindings(tag) {
-    const tokens = this.tagIndex.get(tag);
-    if (!tokens || tokens.size === 0) {
-      return [];
-    }
-    const bindings = [];
-    for (const token of tokens) {
-      const binding = this.bindings.get(token);
-      if (binding) {
-        bindings.push(binding);
-      }
-    }
-    return bindings;
-  }
-  addInterceptor(token, interceptor) {
-    const key = this.tokenToString(token);
-    if (!this.interceptors.has(key)) {
-      this.interceptors.set(key, []);
-    }
-    this.interceptors.get(key).push(interceptor);
-  }
-  registerController(controller) {
-    this.singleton(controller, controller);
-  }
-  getController(controller) {
-    return this.resolve(controller);
-  }
-  isBound(token) {
-    return this.bindings.has(token) || (this.parent?.isBound(token) ?? false);
-  }
-  unbind(token) {
-    const binding = this.bindings.get(token);
-    if (binding?.metadata?.tags) {
-      for (const tag of binding.metadata.tags) {
-        this.tagIndex.get(tag)?.delete(token);
-      }
-    }
-    this.bindings.delete(token);
-    this.instances.delete(token);
-    return this;
-  }
-  createChild(options) {
-    const child = new Container({ ...this.options, ...options });
-    child.parent = this;
-    this.children.add(child);
-    return child;
-  }
-  createScope(scopeId) {
-    const scope = this.createChild();
-    scope.scopedInstances.set(scopeId, new Map);
-    return scope;
-  }
-  getBindings() {
-    return new Map(this.bindings);
-  }
-  clear() {
-    this.bindings.clear();
-    this.tagIndex.clear();
-    this.instances.clear();
-    this.scopedInstances.clear();
-    return this;
-  }
-  intercept(token, interceptor) {
-    if (!this.interceptors.has(token)) {
-      this.interceptors.set(token, []);
-    }
-    this.interceptors.get(token).push(interceptor);
-    return this;
-  }
-  resolveInternal(token, context) {
-    if (context.resolving.has(token)) {
-      const chain = Array.from(context.resolving).map((t) => this.tokenToString(t));
-      chain.push(this.tokenToString(token));
-      throw new CircularDependencyException(chain);
-    }
-    if (context.depth > this.options.maxDepth) {
-      const chain = Array.from(context.resolving).map((t) => this.tokenToString(t));
-      throw new Error(`Maximum resolution depth exceeded (${this.options.maxDepth}).
-` + `This usually indicates a circular or very deep dependency chain.
-` + `Current resolution chain:
-${chain.map((t, i) => `  ${i + 1}. ${t}`).join(`
-`)}`);
-    }
-    context.resolving.add(token);
-    context.depth++;
-    try {
-      const binding = this.bindings.get(token);
-      if (binding) {
-        if (binding.metadata.when && !binding.metadata.when(context)) {
-          throw new Error(`Contextual binding condition not met for: ${this.tokenToString(token)}`);
-        }
-        return this.createInstance(binding, context);
-      }
-      if (this.parent) {
-        const parentContext = {
-          resolving: new Set,
-          depth: 0,
-          container: this.parent,
-          token
-        };
-        return this.parent.resolveInternal(token, parentContext);
-      }
-      if (this.options.autoRegister && typeof token === "function") {
-        return this.autoRegisterAndResolve(token, context);
-      }
-      if (this.options.strictMode) {
-        throw new Error(`No binding found for: ${this.tokenToString(token)}`);
-      }
-      if (typeof token === "function") {
-        return this.createInstanceFromConstructor(token, context);
-      }
-      throw new Error(`Cannot resolve: ${this.tokenToString(token)}`);
-    } finally {
-      context.resolving.delete(token);
-      context.depth--;
-    }
-  }
-  createInstance(binding, context) {
-    let instance;
-    if (binding.metadata.scope === "singleton" && this.instances.has(binding.token)) {
-      instance = this.instances.get(binding.token);
-    } else if (binding.metadata.scope === "scoped" && context.requestId) {
-      const scopedMap = this.scopedInstances.get(context.requestId);
-      if (scopedMap?.has(binding.token)) {
-        instance = scopedMap.get(binding.token);
-      } else {
-        instance = this.createNewInstance(binding, context);
-        if (!scopedMap) {
-          this.scopedInstances.set(context.requestId, new Map);
-        }
-        this.scopedInstances.get(context.requestId).set(binding.token, instance);
-      }
-    } else {
-      instance = this.createNewInstance(binding, context);
-      if (binding.metadata.scope === "singleton") {
-        this.instances.set(binding.token, instance);
-      }
-    }
-    const tokenKey = this.tokenToString(binding.token);
-    if (this.interceptors.has(tokenKey)) {
-      const interceptors = this.interceptors.get(tokenKey);
-      for (const interceptor of interceptors) {
-        instance = interceptor(instance);
-      }
-    }
-    return instance;
-  }
-  createNewInstance(binding, context) {
-    if (binding.value !== undefined) {
-      return binding.value;
-    }
-    if (binding.factory) {
-      const dependencies = this.resolveDependencies(binding.metadata.dependencies || [], context);
-      return binding.factory(...dependencies);
-    }
-    if (binding.instance) {
-      return binding.instance;
-    }
-    if (binding.implementation) {
-      return this.createInstanceFromConstructor(binding.implementation, context);
-    }
-    throw new Error(`Invalid binding configuration for: ${this.tokenToString(binding.token)}`);
-  }
-  createInstanceFromConstructor(constructor, context) {
-    const dependencies = this.getConstructorDependencies(constructor);
-    const resolvedDependencies = this.resolveDependencies(dependencies, context);
-    const instance = new constructor(...resolvedDependencies);
-    if (this.options.enableDecorators) {
-      this.applyDecorators(instance, constructor);
-    }
-    return instance;
-  }
-  getConstructorDependencies(constructor) {
-    let injectMetadata = Reflect.getMetadata?.(INJECT_METADATA_KEY, constructor) || constructor[INJECT_METADATA_KEY];
-    if (!injectMetadata && constructor.constructor) {
-      injectMetadata = constructor.constructor[INJECT_METADATA_KEY];
-    }
-    if (!injectMetadata && typeof constructor === "function" && constructor.prototype) {
-      const classMetadata = constructor[INJECT_METADATA_KEY];
-      if (classMetadata) {
-        injectMetadata = classMetadata;
-      }
-    }
-    if (!injectMetadata && typeof constructor === "function") {
-      const directMetadata = constructor[INJECT_METADATA_KEY];
-      if (directMetadata) {
-        injectMetadata = directMetadata;
-      }
-    }
-    if (injectMetadata) {
-      return injectMetadata.map((meta) => meta.token);
-    }
-    const paramTypes = Reflect.getMetadata?.("design:paramtypes", constructor);
-    if (paramTypes) {
-      return paramTypes;
-    }
-    return this.parseConstructorDependencies(constructor);
-  }
-  parseConstructorDependencies(constructor) {
-    const constructorString = constructor.toString();
-    const match = constructorString.match(/constructor\s*\(([^)]*)\)/);
-    if (!match || !match[1]) {
-      return [];
-    }
-    return match[1].split(",").map((param) => param.trim().split(":")[0].trim()).filter((param) => param.length > 0);
-  }
-  resolveDependencies(dependencies, context) {
-    return dependencies.map((dep) => this.resolveInternal(dep, context));
-  }
-  autoRegisterAndResolve(constructor, context) {
-    const metadata = Reflect.getMetadata?.(INJECTABLE_METADATA_KEY, constructor);
-    const binding = {
-      token: constructor,
-      implementation: constructor,
-      metadata: {
-        scope: metadata?.scope || this.options.defaultScope,
-        tags: metadata?.tags
-      }
+    classConstructor[INJECT_METADATA_KEY][parameterIndex] = metadata;
+  };
+}
+function Optional() {
+  return (target, _propertyKey, parameterIndex) => {
+    if (!target[OPTIONAL_METADATA_KEY]) {
+      target[OPTIONAL_METADATA_KEY] = [];
+    }
+    target[OPTIONAL_METADATA_KEY][parameterIndex] = true;
+  };
+}
+function Tagged(tag) {
+  return function(target, _propertyKey, parameterIndex) {
+    if (!target[TAGGED_METADATA_KEY]) {
+      target[TAGGED_METADATA_KEY] = [];
+    }
+    target[TAGGED_METADATA_KEY][parameterIndex] = tag;
+  };
+}
+function Controller(prefix, options) {
+  return function(target) {
+    const metadata = {
+      prefix: prefix || "",
+      middleware: options?.middleware || [],
+      tags: options?.tags || []
     };
-    this.register(binding);
-    return this.resolveInternal(constructor, context);
-  }
-  applyDecorators(instance, constructor) {
-    const decorators = Reflect.getMetadata?.("decorators", constructor);
-    if (decorators) {
-      for (const decorator of decorators) {
-        decorator(instance);
-      }
-    }
-  }
-  hasTag(binding, tag) {
-    return binding.metadata.tags?.includes(tag) ?? false;
-  }
-  tokenToString(token) {
-    if (typeof token === "string")
-      return token;
-    if (typeof token === "symbol")
-      return token.toString();
-    if (typeof token === "function")
-      return token.name || "anonymous";
-    return "unknown";
-  }
-  generateRequestId() {
-    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
+    target[CONTROLLER_METADATA_KEY] = metadata;
+    return target;
+  };
 }
-
-class BindingBuilder {
-  container;
-  binding;
-  constructor(container, token) {
-    this.container = container;
-    this.binding = {
-      token,
-      metadata: {
-        scope: "transient"
-      }
-    };
-  }
-  to(implementation) {
-    this.binding.implementation = implementation;
-    return this;
-  }
-  toValue(value) {
-    this.binding.value = value;
-    this.binding.metadata.scope = "singleton";
-    return this;
-  }
-  toFactory(factory) {
-    this.binding.factory = factory;
-    return this;
-  }
-  toInstance(instance) {
-    this.binding.instance = instance;
-    this.binding.metadata.scope = "singleton";
-    return this;
-  }
-  inSingletonScope() {
-    this.binding.metadata.scope = "singleton";
-    return this;
-  }
-  inTransientScope() {
-    this.binding.metadata.scope = "transient";
-    return this;
-  }
-  inScopedScope() {
-    this.binding.metadata.scope = "scoped";
-    return this;
-  }
-  inRequestScope() {
-    this.binding.metadata.scope = "request";
-    return this;
-  }
-  withTags(...tags) {
-    this.binding.metadata.tags = [...this.binding.metadata.tags || [], ...tags];
-    return this;
-  }
-  when(condition) {
-    this.binding.metadata.when = condition;
-    return this;
-  }
-  lazy() {
-    this.binding.metadata.lazy = true;
-    return this;
-  }
-  build() {
-    this.container.register(this.binding);
-    return this.container;
-  }
+function Get(path = "", options) {
+  return createRouteDecorator("GET", path, options);
 }
-var globalContainer = null;
-function getContainer() {
-  if (!globalContainer) {
-    globalContainer = new Container;
-  }
-  return globalContainer;
+function Post(path = "", options) {
+  return createRouteDecorator("POST", path, options);
 }
-function setContainer(container) {
-  globalContainer = container;
+function Put(path = "", options) {
+  return createRouteDecorator("PUT", path, options);
 }
-function createContainer(options) {
-  return new Container(options);
+function Delete(path = "", options) {
+  return createRouteDecorator("DELETE", path, options);
 }
-// src/container/contextual-binding.ts
-class EnvironmentManager {
-  environments = new Map;
-  currentEnvironment;
-  variables = new Map;
-  constructor(defaultEnvironment = "development") {
-    this.currentEnvironment = defaultEnvironment;
-    this.loadEnvironmentVariables();
-  }
-  register(config) {
-    this.environments.set(config.name, config);
-    return this;
-  }
-  setEnvironment(name) {
-    if (!this.environments.has(name)) {
-      throw new Error(`Environment ${name} is not registered`);
-    }
-    this.currentEnvironment = name;
-    this.loadEnvironmentVariables();
-    return this;
-  }
-  getCurrentEnvironment() {
-    return this.currentEnvironment;
-  }
-  getEnvironment(name) {
-    return this.environments.get(name || this.currentEnvironment);
-  }
-  is(...environments) {
-    return environments.includes(this.currentEnvironment);
-  }
-  get(key, defaultValue) {
-    return this.variables.get(key) ?? defaultValue;
-  }
-  set(key, value) {
-    this.variables.set(key, value);
-    return this;
-  }
-  hasFeature(feature) {
-    const env = this.getEnvironment();
-    return env?.features.includes(feature) ?? false;
-  }
-  loadEnvironmentVariables() {
-    const env = this.getEnvironment();
-    if (env) {
-      for (const [key, value] of Object.entries(env.variables)) {
-        this.variables.set(key, value);
-      }
-    }
-  }
+function Patch(path = "", options) {
+  return createRouteDecorator("PATCH", path, options);
 }
-
-class DefaultContextualBindingBuilder {
-  container;
-  binding;
-  constructor(container, token) {
-    this.container = container;
-    this.binding = {
-      token,
-      conditions: [],
-      priority: 0,
-      metadata: {
-        scope: "transient"
-      }
-    };
-  }
-  when(condition) {
-    this.binding.conditions.push(condition);
-    return this;
-  }
-  whenEnvironment(...environments) {
-    const condition = {
-      type: "environment",
-      predicate: (context) => environments.includes(context.environment || "development"),
-      description: `Environment is one of: ${environments.join(", ")}`
-    };
-    return this.when(condition);
-  }
-  whenTag(tag) {
-    const condition = {
-      type: "tag",
-      predicate: (context) => {
-        return context.parent?.token?.toString().includes(tag) ?? false;
-      },
-      description: `Parent has tag: ${tag}`
-    };
-    return this.when(condition);
-  }
-  whenParent(parentToken) {
-    const condition = {
-      type: "parent",
-      predicate: (context) => context.parent?.token === parentToken,
-      description: `Parent token is: ${parentToken.toString()}`
-    };
-    return this.when(condition);
-  }
-  whenRequest(predicate) {
-    const condition = {
-      type: "request",
-      predicate,
-      description: "Custom request condition"
-    };
-    return this.when(condition);
-  }
-  withPriority(priority) {
-    this.binding.priority = priority;
-    return this;
-  }
-  withFallback(fallback) {
-    this.binding.fallback = fallback;
-    return this;
-  }
-  to(implementation) {
-    this.binding.implementation = implementation;
-    return this;
-  }
-  toValue(value) {
-    this.binding.value = value;
-    this.binding.metadata.scope = "singleton";
-    return this;
-  }
-  toFactory(factory) {
-    this.binding.factory = factory;
-    return this;
-  }
-  inSingletonScope() {
-    this.binding.metadata.scope = "singleton";
-    return this;
-  }
-  inTransientScope() {
-    this.binding.metadata.scope = "transient";
-    return this;
-  }
-  build() {
-    this.container.registerContextualBinding(this.binding);
-    return this.container;
-  }
+function Options(path = "", options) {
+  return createRouteDecorator("OPTIONS", path, options);
 }
-
-class ContextualContainer extends Container {
-  contextualBindings = new Map;
-  environmentManager;
-  constructor(options) {
-    super(options);
-    this.environmentManager = new EnvironmentManager;
-  }
-  bindContextual(token) {
-    return new DefaultContextualBindingBuilder(this, token);
-  }
-  registerContextualBinding(binding) {
-    if (!this.contextualBindings.has(binding.token)) {
-      this.contextualBindings.set(binding.token, []);
+function Head(path = "", options) {
+  return createRouteDecorator("HEAD", path, options);
+}
+function createRouteDecorator(method, path, options) {
+  return function(target, propertyKey, descriptor) {
+    if (!target.constructor[ROUTE_METADATA_KEY]) {
+      target.constructor[ROUTE_METADATA_KEY] = [];
     }
-    const bindings = this.contextualBindings.get(binding.token);
-    bindings.push(binding);
-    bindings.sort((a, b) => b.priority - a.priority);
-    return this;
-  }
-  getEnvironmentManager() {
-    return this.environmentManager;
-  }
-  forDevelopment(token) {
-    return this.bindContextual(token).whenEnvironment("development");
-  }
-  forProduction(token) {
-    return this.bindContextual(token).whenEnvironment("production");
-  }
-  forTesting(token) {
-    return this.bindContextual(token).whenEnvironment("test", "testing");
-  }
-  forStaging(token) {
-    return this.bindContextual(token).whenEnvironment("staging");
-  }
-  resolve(token, context) {
-    const resolutionContext = {
-      container: this,
-      token,
-      environment: context?.environment || this.environmentManager.getCurrentEnvironment(),
-      requestId: context?.requestId || this.generateContextualRequestId(),
-      depth: context?.depth || 0,
-      resolving: context?.resolving || new Set,
-      parent: context?.parent
+    const metadata = {
+      method,
+      path,
+      middleware: options?.middleware || [],
+      tags: options?.tags || []
     };
-    const contextualBinding = this.findContextualBinding(token, resolutionContext);
-    if (contextualBinding) {
-      return this.createInstanceFromContextualBinding(contextualBinding, resolutionContext);
-    }
-    return super.resolve(token, resolutionContext);
-  }
-  findContextualBinding(token, context) {
-    const bindings = this.contextualBindings.get(token);
-    if (!bindings)
-      return;
-    for (const binding of bindings) {
-      if (this.evaluateConditions(binding.conditions, context)) {
-        return binding;
-      }
-    }
-    return;
-  }
-  evaluateConditions(conditions, context) {
-    return conditions.every((condition) => {
-      try {
-        return condition.predicate(context);
-      } catch (error) {
-        console.warn(`Error evaluating binding condition: ${condition.description}`, error);
-        return false;
-      }
+    target.constructor[ROUTE_METADATA_KEY].push({
+      ...metadata,
+      propertyKey,
+      handler: descriptor.value
     });
-  }
-  createInstanceFromContextualBinding(binding, context) {
-    try {
-      return this.createInstance(binding, context);
-    } catch (error) {
-      if (binding.fallback) {
-        console.warn(`Contextual binding failed, using fallback for ${binding.token.toString()}`);
-        return this.createInstance(binding.fallback, context);
-      }
-      throw error;
-    }
-  }
-  generateContextualRequestId() {
-    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
+    return descriptor;
+  };
 }
-
-class EnvironmentPresets {
-  static development() {
-    return {
-      name: "development",
-      variables: {
-        DEBUG: true,
-        LOG_LEVEL: "debug",
-        CACHE_TTL: 60,
-        DB_POOL_SIZE: 5
-      },
-      services: {
-        logger: "ConsoleLogger",
-        cache: "MemoryCache",
-        database: "SQLiteDatabase"
-      },
-      features: ["hot-reload", "debug-toolbar", "detailed-errors"]
-    };
-  }
-  static production() {
-    return {
-      name: "production",
-      variables: {
-        DEBUG: false,
-        LOG_LEVEL: "error",
-        CACHE_TTL: 3600,
-        DB_POOL_SIZE: 20
-      },
-      services: {
-        logger: "FileLogger",
-        cache: "RedisCache",
-        database: "PostgreSQLDatabase"
-      },
-      features: ["performance-monitoring", "error-tracking"]
-    };
-  }
-  static testing() {
-    return {
-      name: "test",
-      variables: {
-        DEBUG: false,
-        LOG_LEVEL: "warn",
-        CACHE_TTL: 1,
-        DB_POOL_SIZE: 1
-      },
-      services: {
-        logger: "NullLogger",
-        cache: "MemoryCache",
-        database: "InMemoryDatabase"
-      },
-      features: ["test-doubles", "fast-teardown"]
-    };
-  }
-  static staging() {
-    return {
-      name: "staging",
-      variables: {
-        DEBUG: true,
-        LOG_LEVEL: "info",
-        CACHE_TTL: 1800,
-        DB_POOL_SIZE: 10
-      },
-      services: {
-        logger: "FileLogger",
-        cache: "RedisCache",
-        database: "PostgreSQLDatabase"
-      },
-      features: ["performance-monitoring", "debug-toolbar"]
-    };
-  }
-}
-
-class BindingConditions {
-  static environment(...environments) {
-    return {
-      type: "environment",
-      predicate: (context) => environments.includes(context.environment || "development"),
-      description: `Environment is one of: ${environments.join(", ")}`
-    };
-  }
-  static feature(featureName) {
-    return {
-      type: "custom",
-      predicate: (context) => {
-        const container = context.container;
-        return container.getEnvironmentManager().hasFeature(featureName);
-      },
-      description: `Feature ${featureName} is enabled`
-    };
-  }
-  static envVar(key, value) {
-    return {
-      type: "custom",
-      predicate: (context) => {
-        const container = context.container;
-        return container.getEnvironmentManager().get(key) === value;
-      },
-      description: `Environment variable ${key} equals ${value}`
-    };
-  }
-  static requestPattern(pattern) {
-    return {
-      type: "request",
-      predicate: (context) => pattern.test(context.requestId || ""),
-      description: `Request ID matches pattern: ${pattern.toString()}`
-    };
-  }
-  static timeRange(startHour, endHour) {
-    return {
-      type: "custom",
-      predicate: () => {
-        const hour = new Date().getHours();
-        return hour >= startHour && hour <= endHour;
-      },
-      description: `Time is between ${startHour}:00 and ${endHour}:00`
-    };
-  }
-  static custom(predicate, description) {
-    return {
-      type: "custom",
-      predicate,
-      description: description || "Custom condition"
-    };
-  }
-}
-// src/container/service-provider.ts
-class BaseServiceProvider {
-  version;
-  dependencies;
-  environment;
-  priority = 0;
-  boot(_container) {}
-  shutdown(_container) {}
-  singleton(container, token, implementation) {
-    container.singleton(token, implementation);
-  }
-  transient(container, token, implementation) {
-    container.transient(token, implementation);
-  }
-  value(container, token, value) {
-    container.value(token, value);
-  }
-  factory(container, token, factory) {
-    container.factory(token, factory);
-  }
-  when(container, condition) {
-    return {
-      bind: (token) => {
-        return container.bind(token).when(condition);
-      }
-    };
-  }
-  forEnvironment(container, ...environments) {
-    return this.when(container, (context) => environments.includes(context.environment || "development"));
-  }
-}
-
-class BaseDeferredServiceProvider extends BaseServiceProvider {
-  isDeferred() {
-    return true;
-  }
-}
-
-class DefaultServiceProviderManager {
-  providers = new Map;
-  deferredProviders = new Map;
-  loadedProviders = new Set;
-  bootedProviders = new Set;
-  container;
-  constructor(container) {
-    this.container = container;
-  }
-  register(provider) {
-    if (this.isConditionalProvider(provider)) {
-      const shouldLoad = provider.shouldLoad(this.container);
-      if (shouldLoad instanceof Promise) {
-        shouldLoad.then((load) => {
-          if (load) {
-            this.doRegister(provider);
-          }
-        });
-      } else if (!shouldLoad) {
-        return this;
-      }
-    }
-    this.doRegister(provider);
-    return this;
-  }
-  async boot() {
-    const providers = Array.from(this.providers.values()).sort((a, b) => (b.priority || 0) - (a.priority || 0));
-    this.validateDependencies(providers);
-    for (const provider of providers) {
-      if (!this.loadedProviders.has(provider.name)) {
-        await this.loadProvider(provider);
-      }
-    }
-    for (const provider of providers) {
-      if (!this.bootedProviders.has(provider.name)) {
-        await this.bootProvider(provider);
-      }
-    }
-  }
-  async shutdown() {
-    const providers = Array.from(this.providers.values()).reverse();
-    for (const provider of providers) {
-      if (provider.shutdown) {
-        try {
-          await provider.shutdown(this.container);
-        } catch (error) {
-          console.error(`Error shutting down provider ${provider.name}:`, error);
-        }
-      }
-    }
-    this.providers.clear();
-    this.deferredProviders.clear();
-    this.loadedProviders.clear();
-    this.bootedProviders.clear();
-  }
-  getProvider(name) {
-    return this.providers.get(name);
-  }
-  getProviders() {
-    return Array.from(this.providers.values());
-  }
-  async loadDeferredProvider(token) {
-    for (const [name, provider] of this.deferredProviders) {
-      if (provider.provides().includes(token) && !this.loadedProviders.has(name)) {
-        await this.loadProvider(provider);
-        await this.bootProvider(provider);
-        this.deferredProviders.delete(name);
-      }
-    }
-  }
-  doRegister(provider) {
-    if (this.providers.has(provider.name)) {
-      throw new Error(`Provider ${provider.name} is already registered`);
-    }
-    this.providers.set(provider.name, provider);
-    if (this.isDeferredProvider(provider)) {
-      this.deferredProviders.set(provider.name, provider);
-    }
-  }
-  async loadProvider(provider) {
-    try {
-      await provider.register(this.container);
-      this.loadedProviders.add(provider.name);
-    } catch (error) {
-      throw new Error(`Failed to load provider ${provider.name}: ${error}`);
-    }
-  }
-  async bootProvider(provider) {
-    if (provider.boot) {
-      try {
-        await provider.boot(this.container);
-        this.bootedProviders.add(provider.name);
-      } catch (error) {
-        throw new Error(`Failed to boot provider ${provider.name}: ${error}`);
+function UseMiddleware(...middleware) {
+  return function(target, propertyKey, descriptor) {
+    if (propertyKey && descriptor) {
+      if (!target.constructor[MIDDLEWARE_METADATA_KEY]) {
+        target.constructor[MIDDLEWARE_METADATA_KEY] = new Map;
       }
+      target.constructor[MIDDLEWARE_METADATA_KEY].set(propertyKey, middleware);
     } else {
-      this.bootedProviders.add(provider.name);
+      target[MIDDLEWARE_METADATA_KEY] = middleware;
     }
-  }
-  validateDependencies(providers) {
-    const providerNames = new Set(providers.map((p) => p.name));
-    for (const provider of providers) {
-      if (provider.dependencies) {
-        for (const dependency of provider.dependencies) {
-          if (!providerNames.has(dependency)) {
-            throw new Error(`Provider ${provider.name} depends on ${dependency}, but it's not registered`);
-          }
-        }
-      }
-    }
-  }
-  isDeferredProvider(provider) {
-    return "provides" in provider && "isDeferred" in provider;
-  }
-  isConditionalProvider(provider) {
-    return "shouldLoad" in provider;
-  }
+    return descriptor || target;
+  };
 }
-
-class ConfigServiceProvider extends BaseServiceProvider {
-  name = "config";
-  priority = 100;
-  register(container) {
-    container.singleton("config", ConfigService);
-    this.forEnvironment(container, "development").bind("config.debug").toValue(true);
-    this.forEnvironment(container, "production").bind("config.debug").toValue(false);
-    this.forEnvironment(container, "test").bind("config.debug").toValue(false);
-  }
+function Param(key) {
+  return createParamDecorator("param", key);
 }
-
-class LoggingServiceProvider extends BaseServiceProvider {
-  name = "logging";
-  priority = 90;
-  register(container) {
-    container.factory("logger", (config) => {
-      return new Logger(config.get("logging", {}));
-    });
-    this.forEnvironment(container, "development").bind("logger").toFactory(() => new ConsoleLogger);
-    this.forEnvironment(container, "production").bind("logger").toFactory((config) => new FileLogger(config.get("logging.file", "./app.log")));
-  }
-}
-
-class DatabaseServiceProvider extends BaseServiceProvider {
-  name = "database";
-  dependencies = ["config", "logging"];
-  register(container) {
-    container.singleton("database", DatabaseConnection);
-    container.transient("userRepository", UserRepository);
-    container.transient("postRepository", PostRepository);
-  }
-  async boot(container) {
-    const db = container.resolve("database");
-    await db.connect();
-  }
-  async shutdown(container) {
-    const db = container.resolve("database");
-    await db.disconnect();
-  }
+function Query(key) {
+  return createParamDecorator("query", key);
 }
-
-class CacheServiceProvider extends BaseServiceProvider {
-  name = "cache";
-  dependencies = ["config"];
-  register(container) {
-    container.singleton("cache", CacheManager);
-    this.forEnvironment(container, "development").bind("cache.store").toFactory(() => new MemoryCache);
-    this.forEnvironment(container, "production").bind("cache.store").toFactory((config) => new RedisCache(config.get("cache.redis")));
-  }
+function Body() {
+  return createParamDecorator("body");
 }
-
-class AuthServiceProvider extends BaseServiceProvider {
-  name = "auth";
-  dependencies = ["config", "database"];
-  register(container) {
-    container.singleton("authService", AuthService);
-    container.singleton("jwtService", JwtService);
-    container.transient("authGuard", AuthGuard);
-  }
+function Header(key) {
+  return createParamDecorator("header", key);
 }
-
-class ValidationServiceProvider extends BaseServiceProvider {
-  name = "validation";
-  register(container) {
-    container.singleton("validator", Validator);
-    container.factory("validationPipe", (validator) => new ValidationPipe(validator));
-  }
+function Cookie(key) {
+  return createParamDecorator("cookie", key);
 }
-
-class EventServiceProvider extends BaseDeferredServiceProvider {
-  name = "events";
-  provides() {
-    return ["eventBus", "eventDispatcher", EventBus, EventDispatcher];
-  }
-  register(container) {
-    container.singleton("eventBus", EventBus);
-    container.singleton("eventDispatcher", EventDispatcher);
-  }
+function InjectParam(token) {
+  return createParamDecorator("param", undefined, token);
 }
-
-class ConfigService {
-  get(key, defaultValue) {
-    return defaultValue;
-  }
-}
-
-class Logger {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  log(message) {
-    console.log(message);
-  }
+function createParamDecorator(type, key, token) {
+  return function(target, propertyKey, parameterIndex) {
+    if (!target.constructor[PARAM_METADATA_KEY]) {
+      target.constructor[PARAM_METADATA_KEY] = new Map;
+    }
+    if (!target.constructor[PARAM_METADATA_KEY].has(propertyKey)) {
+      target.constructor[PARAM_METADATA_KEY].set(propertyKey, []);
+    }
+    const metadata = {
+      type,
+      key,
+      token
+    };
+    target.constructor[PARAM_METADATA_KEY].get(propertyKey)[parameterIndex] = metadata;
+  };
 }
 
-class ConsoleLogger extends Logger {
-  constructor() {
-    super({});
+class MetadataReader {
+  static getInjectableMetadata(target) {
+    return target[INJECTABLE_METADATA_KEY];
   }
-}
-
-class FileLogger extends Logger {
-  filePath;
-  constructor(filePath) {
-    super({});
-    this.filePath = filePath;
+  static getInjectMetadata(target) {
+    return target[INJECT_METADATA_KEY] || [];
   }
-}
-
-class DatabaseConnection {
-  async connect() {}
-  async disconnect() {}
-}
-
-class UserRepository {
-  db;
-  constructor(db) {
-    this.db = db;
+  static getOptionalMetadata(target) {
+    return target[OPTIONAL_METADATA_KEY] || [];
   }
-}
-
-class PostRepository {
-  db;
-  constructor(db) {
-    this.db = db;
+  static getTaggedMetadata(target) {
+    return target[TAGGED_METADATA_KEY] || [];
   }
-}
-
-class CacheManager {
-  store;
-  constructor(store) {
-    this.store = store;
+  static getControllerMetadata(target) {
+    return target[CONTROLLER_METADATA_KEY];
   }
-}
-
-class MemoryCache {
-  cache = new Map;
-}
-
-class RedisCache {
-  config;
-  constructor(config) {
-    this.config = config;
+  static getAllRoutes(target) {
+    return target[ROUTE_METADATA_KEY] || [];
   }
-}
-
-class AuthService {
-  jwt;
-  userRepo;
-  constructor(jwt, userRepo) {
-    this.jwt = jwt;
-    this.userRepo = userRepo;
-  }
-}
-
-class JwtService {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-}
-
-class AuthGuard {
-  auth;
-  constructor(auth) {
-    this.auth = auth;
+  static getMiddlewareMetadata(target, propertyKey) {
+    if (propertyKey) {
+      const methodMiddleware = target[MIDDLEWARE_METADATA_KEY]?.get(propertyKey);
+      return methodMiddleware || [];
+    }
+    return target[MIDDLEWARE_METADATA_KEY] || [];
   }
-}
-
-class Validator {
-  validate(_data, _rules) {
-    return true;
+  static getParamMetadata(target, propertyKey) {
+    return target[PARAM_METADATA_KEY]?.get(propertyKey) || [];
   }
 }
 
-class ValidationPipe {
-  validator;
-  constructor(validator) {
-    this.validator = validator;
+class DecoratorContainer extends Container {
+  registerController(controllerClass) {
+    const metadata = MetadataReader.getControllerMetadata(controllerClass);
+    if (!metadata) {
+      throw new Error(`Class ${controllerClass.name} is not decorated with @Controller`);
+    }
+    this.singleton(controllerClass, controllerClass);
+    const routes = MetadataReader.getAllRoutes(controllerClass);
+    for (const _route of routes) {}
   }
-}
-
-class EventBus {
-  emit(_event, _data) {}
-}
-
-class EventDispatcher {
-  bus;
-  constructor(bus) {
-    this.bus = bus;
+  resolve(token, context) {
+    if (typeof token === "function") {
+      const metadata = MetadataReader.getInjectableMetadata(token);
+      if (metadata) {
+        try {
+          return super.resolve(token, context);
+        } catch {
+          const scope = metadata.scope || "transient";
+          switch (scope) {
+            case "singleton":
+              this.singleton(token, token);
+              break;
+            case "transient":
+              this.transient(token, token);
+              break;
+            default:
+              this.transient(token, token);
+          }
+        }
+      }
+    }
+    return super.resolve(token, context);
   }
 }
+var decoratorContainer = new DecoratorContainer;
 export {
   setContainer,
   getContainer,