@stacksjs/bun-router 0.0.18 → 0.0.19

package/dist/container/index.js

@@ -1,255 +1,1193 @@
 // @bun
 import {
-  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 = {
+  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,
       token,
-      optional: options?.optional,
-      tags: options?.tags,
-      when: options?.when
+      environment: context?.environment || "development",
+      requestId: context?.requestId || this.generateRequestId(),
+      depth: context?.depth || 0,
+      resolving: context?.resolving || new Set,
+      parent: context?.parent
     };
-    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 || []
+    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
+      }
     };
-    target[CONTROLLER_METADATA_KEY] = metadata;
-    return target;
-  };
-}
-function Get(path = "", options) {
-  return createRouteDecorator("GET", path, options);
+    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)}`;
+  }
 }
-function Post(path = "", options) {
-  return createRouteDecorator("POST", path, options);
+
+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 Put(path = "", options) {
-  return createRouteDecorator("PUT", path, options);
+var globalContainer = null;
+function getContainer() {
+  if (!globalContainer) {
+    globalContainer = new Container;
+  }
+  return globalContainer;
 }
-function Delete(path = "", options) {
-  return createRouteDecorator("DELETE", path, options);
+function setContainer(container) {
+  globalContainer = container;
 }
-function Patch(path = "", options) {
-  return createRouteDecorator("PATCH", path, options);
+function createContainer(options) {
+  return new Container(options);
 }
-function Options(path = "", options) {
-  return createRouteDecorator("OPTIONS", 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 Head(path = "", options) {
-  return createRouteDecorator("HEAD", 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 createRouteDecorator(method, path, options) {
-  return function(target, propertyKey, descriptor) {
-    if (!target.constructor[ROUTE_METADATA_KEY]) {
-      target.constructor[ROUTE_METADATA_KEY] = [];
+
+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, []);
     }
-    const metadata = {
-      method,
-      path,
-      middleware: options?.middleware || [],
-      tags: options?.tags || []
+    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
     };
-    target.constructor[ROUTE_METADATA_KEY].push({
-      ...metadata,
-      propertyKey,
-      handler: descriptor.value
+    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;
+      }
     });
-    return descriptor;
-  };
+  }
+  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)}`;
+  }
 }
-function UseMiddleware(...middleware) {
-  return function(target, propertyKey, descriptor) {
-    if (propertyKey && descriptor) {
-      if (!target.constructor[MIDDLEWARE_METADATA_KEY]) {
-        target.constructor[MIDDLEWARE_METADATA_KEY] = new Map;
+
+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}`);
       }
-      target.constructor[MIDDLEWARE_METADATA_KEY].set(propertyKey, middleware);
     } else {
-      target[MIDDLEWARE_METADATA_KEY] = middleware;
+      this.bootedProviders.add(provider.name);
     }
-    return descriptor || target;
-  };
+  }
+  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;
+  }
 }
-function Param(key) {
-  return createParamDecorator("param", key);
+
+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 Query(key) {
-  return createParamDecorator("query", 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")));
+  }
 }
-function Body() {
-  return createParamDecorator("body");
+
+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 Header(key) {
-  return createParamDecorator("header", 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 Cookie(key) {
-  return createParamDecorator("cookie", key);
+
+class AuthServiceProvider extends BaseServiceProvider {
+  name = "auth";
+  dependencies = ["config", "database"];
+  register(container) {
+    container.singleton("authService", AuthService);
+    container.singleton("jwtService", JwtService);
+    container.transient("authGuard", AuthGuard);
+  }
 }
-function InjectParam(token) {
-  return createParamDecorator("param", undefined, token);
+
+class ValidationServiceProvider extends BaseServiceProvider {
+  name = "validation";
+  register(container) {
+    container.singleton("validator", Validator);
+    container.factory("validationPipe", (validator) => new ValidationPipe(validator));
+  }
 }
-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 EventServiceProvider extends BaseDeferredServiceProvider {
+  name = "events";
+  provides() {
+    return ["eventBus", "eventDispatcher", EventBus, EventDispatcher];
+  }
+  register(container) {
+    container.singleton("eventBus", EventBus);
+    container.singleton("eventDispatcher", EventDispatcher);
+  }
 }
 
-class MetadataReader {
-  static getInjectableMetadata(target) {
-    return target[INJECTABLE_METADATA_KEY];
+class ConfigService {
+  get(key, defaultValue) {
+    return defaultValue;
   }
-  static getInjectMetadata(target) {
-    return target[INJECT_METADATA_KEY] || [];
+}
+
+class Logger {
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  static getOptionalMetadata(target) {
-    return target[OPTIONAL_METADATA_KEY] || [];
+  log(message) {
+    console.log(message);
   }
-  static getTaggedMetadata(target) {
-    return target[TAGGED_METADATA_KEY] || [];
+}
+
+class ConsoleLogger extends Logger {
+  constructor() {
+    super({});
   }
-  static getControllerMetadata(target) {
-    return target[CONTROLLER_METADATA_KEY];
+}
+
+class FileLogger extends Logger {
+  filePath;
+  constructor(filePath) {
+    super({});
+    this.filePath = filePath;
   }
-  static getAllRoutes(target) {
-    return target[ROUTE_METADATA_KEY] || [];
+}
+
+class DatabaseConnection {
+  async connect() {}
+  async disconnect() {}
+}
+
+class UserRepository {
+  db;
+  constructor(db) {
+    this.db = db;
   }
-  static getMiddlewareMetadata(target, propertyKey) {
-    if (propertyKey) {
-      const methodMiddleware = target[MIDDLEWARE_METADATA_KEY]?.get(propertyKey);
-      return methodMiddleware || [];
-    }
-    return target[MIDDLEWARE_METADATA_KEY] || [];
+}
+
+class PostRepository {
+  db;
+  constructor(db) {
+    this.db = db;
   }
-  static getParamMetadata(target, propertyKey) {
-    return target[PARAM_METADATA_KEY]?.get(propertyKey) || [];
+}
+
+class CacheManager {
+  store;
+  constructor(store) {
+    this.store = store;
   }
 }
 
-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 MemoryCache {
+  cache = new Map;
+}
+
+class RedisCache {
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  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);
+}
+
+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;
+  }
+}
+
+class Validator {
+  validate(_data, _rules) {
+    return true;
+  }
+}
+
+class ValidationPipe {
+  validator;
+  constructor(validator) {
+    this.validator = validator;
+  }
+}
+
+class EventBus {
+  emit(_event, _data) {}
+}
+
+class EventDispatcher {
+  bus;
+  constructor(bus) {
+    this.bus = bus;
   }
 }
-var decoratorContainer = new DecoratorContainer;
 export {
   setContainer,
   getContainer,