@devcraft-ts/diadem 0.1.0

package/dist/chunk-RTX6B4YY.js

@@ -0,0 +1,681 @@
+import { getLogger, loadManifest, getDIMetadata } from './chunk-W7NA3ZZF.js';
+
+// src/core/dependency-resolver.ts
+var EnhancedDependencyResolver = class {
+  registeredServices = /* @__PURE__ */ new Set();
+  serviceClassMap = /* @__PURE__ */ new Map();
+  serviceMetadataMap = /* @__PURE__ */ new Map();
+  /**
+   * Register services using build-time dependency analysis
+   * Services are registered in the correct order based on their dependencies
+   */
+  async registerServicesWithManifest(container, services, manifestEntries, environment) {
+    const warnings = [];
+    const registrationOrder = [];
+    let registeredCount = 0;
+    let skippedCount = 0;
+    const manifestMap = /* @__PURE__ */ new Map();
+    this.serviceClassMap.clear();
+    this.serviceMetadataMap.clear();
+    let servicesWithMetadata = 0;
+    const reverseMapping = /* @__PURE__ */ new Map();
+    try {
+      const { SERVICE_CLASSES } = await loadManifest();
+      Object.entries(SERVICE_CLASSES).forEach(([originalName, serviceClass]) => {
+        reverseMapping.set(serviceClass, originalName);
+      });
+    } catch {
+    }
+    for (const serviceClass of services) {
+      const metadata = getDIMetadata(serviceClass);
+      if (metadata) {
+        const originalName = reverseMapping.get(serviceClass) || serviceClass.name;
+        this.serviceClassMap.set(originalName, serviceClass);
+        this.serviceMetadataMap.set(originalName, metadata);
+        servicesWithMetadata++;
+      }
+    }
+    getLogger().info(
+      `\u{1F4CB} Built service map: ${servicesWithMetadata}/${services.length} services with DI metadata`
+    );
+    if (servicesWithMetadata === 0) {
+      getLogger().error("\u274C CRITICAL: No services have DI metadata!");
+      getLogger().error(
+        "\u{1F50D} Service analysis:",
+        services.slice(0, 3).map((s) => ({
+          name: s.name,
+          hasDI: !!getDIMetadata(s)
+        }))
+      );
+    }
+    for (const entry of manifestEntries) {
+      if (environment && entry.environment && entry.environment !== environment) {
+        continue;
+      }
+      manifestMap.set(entry.className, entry);
+    }
+    getLogger().info(
+      `\u{1F4CB} Manifest map: ${manifestMap.size}/${manifestEntries.length} entries for ${environment || "any"}`
+    );
+    const sortedEntries = Array.from(manifestMap.values()).sort(
+      (a, b) => a.registrationOrder - b.registrationOrder
+    );
+    if (sortedEntries.length === 0) {
+      getLogger().error("\u274C CRITICAL: No services to register after filtering!");
+      getLogger().error("\u{1F50D} Debug analysis:", {
+        serviceClassMapSize: this.serviceClassMap.size,
+        manifestMapSize: manifestMap.size,
+        serviceNames: Array.from(this.serviceClassMap.keys()).slice(0, 5),
+        manifestNames: manifestEntries.slice(0, 5).map((e) => e.className),
+        environment
+      });
+      return {
+        registeredServices: [],
+        registeredCount: 0,
+        skippedCount: 0,
+        dependencyStats: {
+          totalServices: 0,
+          servicesWithDependencies: 0,
+          totalDependencies: 0,
+          externalDependencies: 0,
+          maxDependencyDepth: 0
+        },
+        warnings: ["No services to register"],
+        registrationOrder: []
+      };
+    }
+    getLogger().info(`\u{1F517} Registering ${sortedEntries.length} services`);
+    for (const manifestEntry of sortedEntries) {
+      const serviceClass = this.serviceClassMap.get(manifestEntry.className);
+      if (!serviceClass) {
+        getLogger().error(`\u274C Service class not found: ${manifestEntry.className}`);
+        getLogger().error(
+          `\u{1F50D} Available: ${Array.from(this.serviceClassMap.keys()).slice(0, 5).join(", ")}...`
+        );
+        warnings.push(`Service class ${manifestEntry.className} not found`);
+        skippedCount++;
+        continue;
+      }
+      try {
+        await this.registerSingleService(
+          container,
+          serviceClass,
+          manifestEntry,
+          warnings
+        );
+        registeredCount++;
+        registrationOrder.push(manifestEntry.className);
+        this.registeredServices.add(manifestEntry.className);
+      } catch (error) {
+        const err = error;
+        skippedCount++;
+        getLogger().error(
+          `\u274C Registration failed: ${manifestEntry.className} - ${err.message}`
+        );
+        warnings.push(
+          `Failed to register ${manifestEntry.className}: ${err.message}`
+        );
+      }
+    }
+    getLogger().info(
+      `\u{1F4CA} Registration complete: ${registeredCount} registered, ${skippedCount} skipped`
+    );
+    const dependencyStats = this.calculateDependencyStats(manifestEntries);
+    const result = {
+      registeredServices: Array.from(this.registeredServices),
+      registeredCount,
+      skippedCount,
+      dependencyStats,
+      warnings,
+      registrationOrder
+    };
+    if (process.env.DEBUG_DI) {
+      getLogger().info(`\u{1F4CA} Registration Summary:`);
+      getLogger().info(`   \u2705 Registered: ${registeredCount}`);
+      getLogger().info(`   \u26A0\uFE0F  Skipped: ${skippedCount}`);
+      getLogger().info(
+        `   \u{1F517} Dependencies resolved: ${dependencyStats.totalDependencies}`
+      );
+      if (warnings.length > 0) {
+        getLogger().warn(`   \u26A0\uFE0F  Warnings: ${warnings.length}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Register a single service with proper dependency injection
+   */
+  async registerSingleService(container, ServiceClass, manifestEntry, warnings) {
+    const metadata = getDIMetadata(ServiceClass);
+    if (!metadata) {
+      getLogger().error(`\u274C No DI metadata: ${ServiceClass.name}`);
+      throw new Error(`No DI metadata found for ${ServiceClass.name}`);
+    }
+    if (typeof container.registerSingleton !== "function" || typeof container.registerFactory !== "function") {
+      getLogger().error(
+        `\u274C Container missing registration methods for ${ServiceClass.name}`
+      );
+      throw new Error(`Container missing registration methods`);
+    }
+    const createInstance = () => {
+      const resolvedArgs = [];
+      for (const dependency of manifestEntry.resolvedDependencies) {
+        try {
+          if (dependency.external) {
+            if (dependency.isOptional) {
+              resolvedArgs[dependency.paramIndex] = void 0;
+            } else {
+              const defaultValue = this.getDefaultValueForExternalDependency(dependency);
+              if (defaultValue !== void 0) {
+                resolvedArgs[dependency.paramIndex] = defaultValue;
+              } else {
+                throw new Error(
+                  `External dependency ${dependency.typeName} is required but no default available`
+                );
+              }
+            }
+          } else if (dependency.implementingService) {
+            const depMetadata = this.serviceMetadataMap.get(
+              dependency.implementingService
+            );
+            if (!depMetadata) {
+              throw new Error(
+                `No DI metadata found for dependency ${dependency.implementingService}`
+              );
+            }
+            const resolvedDep = container.resolve(depMetadata.token);
+            resolvedArgs[dependency.paramIndex] = resolvedDep;
+          } else {
+            if (dependency.isOptional) {
+              resolvedArgs[dependency.paramIndex] = void 0;
+            } else {
+              throw new Error(
+                `Unknown dependency type for ${dependency.typeName}`
+              );
+            }
+          }
+        } catch (error) {
+          if (dependency.isOptional) {
+            resolvedArgs[dependency.paramIndex] = void 0;
+            warnings.push(
+              `Optional dependency ${dependency.typeName} could not be resolved for ${ServiceClass.name}: ${error}`
+            );
+          } else {
+            throw new Error(
+              `Cannot resolve required dependency ${dependency.typeName} for service ${ServiceClass.name}: ${error}`,
+              { cause: error }
+            );
+          }
+        }
+      }
+      return new ServiceClass(...resolvedArgs);
+    };
+    getLogger().info(
+      `\u{1F527} Registering ${ServiceClass.name} (${manifestEntry.lifecycle})`
+    );
+    try {
+      switch (manifestEntry.lifecycle) {
+        case "singleton":
+          container.registerSingleton(metadata.token, createInstance);
+          break;
+        case "factory":
+          container.registerFactory(metadata.token, createInstance);
+          break;
+        case "lazy":
+          container.registerFactory(metadata.token, createInstance);
+          break;
+        case "lazySingleton": {
+          let lazySingletonInstance = null;
+          container.registerFactory(metadata.token, () => {
+            if (lazySingletonInstance === null) {
+              lazySingletonInstance = createInstance();
+            }
+            return lazySingletonInstance;
+          });
+          break;
+        }
+        default:
+          container.registerSingleton(metadata.token, createInstance);
+      }
+      getLogger().info(`\u2705 Registered ${ServiceClass.name}`);
+    } catch (error) {
+      const err = error;
+      getLogger().error(
+        `\u274C Container registration failed for ${ServiceClass.name}: ${err.message}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Get default value for external dependencies
+   */
+  getDefaultValueForExternalDependency(dependency) {
+    switch (dependency.typeName) {
+      case "string":
+        return "";
+      case "number":
+        return 0;
+      case "boolean":
+        return false;
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Calculate dependency statistics from manifest entries
+   */
+  calculateDependencyStats(manifestEntries) {
+    let servicesWithDependencies = 0;
+    let totalDependencies = 0;
+    let externalDependencies = 0;
+    let maxDependencyDepth = 0;
+    for (const entry of manifestEntries) {
+      if (entry.resolvedDependencies.length > 0) {
+        servicesWithDependencies++;
+        totalDependencies += entry.resolvedDependencies.length;
+        maxDependencyDepth = Math.max(
+          maxDependencyDepth,
+          entry.resolvedDependencies.length
+        );
+        externalDependencies += entry.resolvedDependencies.filter(
+          (dep) => dep.external
+        ).length;
+      }
+    }
+    return {
+      totalServices: manifestEntries.length,
+      servicesWithDependencies,
+      totalDependencies,
+      externalDependencies,
+      maxDependencyDepth
+    };
+  }
+  /**
+   * Validate that all required dependencies can be resolved
+   */
+  validateDependencies(manifestEntries) {
+    const missingDependencies = [];
+    const availableServices = new Set(
+      manifestEntries.map((entry) => entry.className)
+    );
+    for (const entry of manifestEntries) {
+      for (const dep of entry.resolvedDependencies) {
+        if (!dep.external && !dep.isOptional && dep.implementingService) {
+          if (!availableServices.has(dep.implementingService)) {
+            missingDependencies.push(
+              `${entry.className} requires ${dep.implementingService} (${dep.typeName})`
+            );
+          }
+        }
+      }
+    }
+    const circularDependencies = this.detectCircularDependencies(manifestEntries);
+    return {
+      valid: missingDependencies.length === 0 && circularDependencies.length === 0,
+      missingDependencies,
+      circularDependencies
+    };
+  }
+  /**
+   * Detect circular dependencies in manifest entries
+   */
+  detectCircularDependencies(manifestEntries) {
+    const cycles = [];
+    const entryMap = new Map(
+      manifestEntries.map((entry) => [entry.className, entry])
+    );
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const findCycles = (className, path) => {
+      if (visiting.has(className)) {
+        const cycleStart = path.indexOf(className);
+        const cycle = path.slice(cycleStart).join(" -> ") + ` -> ${className}`;
+        cycles.push(cycle);
+        return;
+      }
+      if (visited.has(className)) return;
+      const entry = entryMap.get(className);
+      if (!entry) return;
+      visited.add(className);
+      visiting.add(className);
+      for (const dep of entry.resolvedDependencies) {
+        if (dep.implementingService && !dep.external) {
+          findCycles(dep.implementingService, [...path, className]);
+        }
+      }
+      visiting.delete(className);
+    };
+    for (const entry of manifestEntries) {
+      if (!visited.has(entry.className)) {
+        findCycles(entry.className, []);
+      }
+    }
+    return cycles;
+  }
+};
+async function registerServicesWithManifestDependencies(container, services, manifestEntries, environment) {
+  const resolver = new EnhancedDependencyResolver();
+  const validation = resolver.validateDependencies(manifestEntries);
+  if (!validation.valid) {
+    if (process.env.NODE_ENV === "development" || process.env.DEBUG_DI) {
+      getLogger().warn("\u26A0\uFE0F Dependency validation warnings:");
+      validation.missingDependencies.forEach((dep) => {
+        getLogger().warn(`  - ${dep}`);
+      });
+      validation.circularDependencies.forEach((cycle) => {
+        getLogger().warn(`  - Circular: ${cycle}`);
+      });
+    }
+  }
+  return resolver.registerServicesWithManifest(
+    container,
+    services,
+    manifestEntries,
+    environment
+  );
+}
+
+// src/core/container.ts
+function isDisposable(value) {
+  return typeof value === "object" && value !== null && typeof value.dispose === "function";
+}
+var DiademContainer = class _DiademContainer {
+  dependencies = /* @__PURE__ */ new Map();
+  singletons = /* @__PURE__ */ new Map();
+  factories = /* @__PURE__ */ new Map();
+  asyncFactories = /* @__PURE__ */ new Map();
+  disposers = [];
+  ready = false;
+  disposed = false;
+  /**
+   * Register a dependency by value or class instance.
+   * @param token Dependency token
+   * @param implementation The value or instance to register
+   */
+  register(token, implementation) {
+    this.dependencies.set(token, implementation);
+    this.trackDisposable(implementation);
+  }
+  /**
+   * Register a factory that returns a new instance on every resolve.
+   * Use for transient dependencies.
+   * @param token Dependency token
+   * @param factory Factory function
+   */
+  registerFactory(token, factory) {
+    this.factories.set(token, factory);
+  }
+  /**
+   * Register a singleton (one instance per container).
+   *
+   * **Order matters:** the factory runs immediately, at registration time, so
+   * anything it resolves must already be registered. Register dependencies
+   * before their dependents — the build-time manifest is emitted in exactly this
+   * (topological) order. To defer construction until first resolve instead, use
+   * a `lazySingleton` lifecycle via the decorator/manifest.
+   *
+   * @param token Dependency token
+   * @param factory Factory function, called once, immediately
+   */
+  registerSingleton(token, factory) {
+    if (!this.singletons.has(token)) {
+      const instance = factory();
+      this.singletons.set(token, instance);
+      this.trackDisposable(instance);
+    }
+  }
+  /**
+   * Register a factory that awaits its result on every {@link resolveAsync}.
+   * Use for transient dependencies that require asynchronous construction.
+   * @param token Dependency token
+   * @param factory Async factory function
+   */
+  registerAsyncFactory(token, factory) {
+    this.asyncFactories.set(token, factory);
+  }
+  /**
+   * Register an async singleton: the factory runs at most once (on the first
+   * {@link resolveAsync}) and the awaited instance is cached. If the instance
+   * is {@link Disposable} it is torn down on {@link dispose}.
+   * @param token Dependency token
+   * @param factory Async factory function, called at most once
+   */
+  registerAsyncSingleton(token, factory) {
+    let cached;
+    this.asyncFactories.set(token, () => {
+      cached ??= factory().then((instance) => {
+        this.trackDisposable(instance);
+        return instance;
+      });
+      return cached;
+    });
+  }
+  /** Record a value's disposer if it implements {@link Disposable}. */
+  trackDisposable(value) {
+    if (isDisposable(value)) {
+      this.disposers.push(() => value.dispose());
+    }
+  }
+  /**
+   * Resolve a dependency by token.
+   * @param token Dependency token
+   * @returns The resolved dependency
+   * @throws If the dependency is not found
+   */
+  resolve(token) {
+    if (!token) {
+      throw new Error("Dependency token is undefined or null");
+    }
+    if (this.dependencies.has(token)) {
+      return this.dependencies.get(token);
+    }
+    if (this.singletons.has(token)) {
+      return this.singletons.get(token);
+    }
+    if (this.factories.has(token)) {
+      const factory = this.factories.get(token);
+      return factory?.();
+    }
+    if (this.asyncFactories.has(token)) {
+      throw new Error(
+        `Dependency ${token?.name || "Unknown"} is registered as an async factory; resolve it with resolveAsync() instead of resolve().`
+      );
+    }
+    const tokenName = token?.name || "Unknown";
+    const registeredTokens = this.getRegisteredTokens();
+    const registeredNames = registeredTokens.map((t) => t?.name || "Unknown").join(", ");
+    throw new Error(
+      `Dependency not found: ${tokenName}. Available services: [${registeredNames}]. Total registered: ${registeredTokens.length}`
+    );
+  }
+  /**
+   * Resolve a dependency that may have been registered asynchronously.
+   * Synchronous registrations resolve immediately; async factories/singletons
+   * are awaited.
+   * @param token Dependency token
+   * @returns A promise of the resolved dependency
+   * @throws If the dependency is not found
+   */
+  async resolveAsync(token) {
+    if (!token) {
+      throw new Error("Dependency token is undefined or null");
+    }
+    if (this.dependencies.has(token) || this.singletons.has(token) || this.factories.has(token)) {
+      return this.resolve(token);
+    }
+    const asyncFactory = this.asyncFactories.get(token);
+    if (asyncFactory) {
+      return asyncFactory();
+    }
+    return this.resolve(token);
+  }
+  /**
+   * Returns true if the container is fully set up.
+   */
+  isReady() {
+    return this.ready;
+  }
+  /**
+   * Mark the container as ready (all dependencies registered).
+   */
+  setReady() {
+    this.ready = true;
+  }
+  /**
+   * Clear all registrations (useful for testing or container reset).
+   */
+  clear() {
+    this.dependencies.clear();
+    this.singletons.clear();
+    this.factories.clear();
+    this.asyncFactories.clear();
+    this.disposers.length = 0;
+    this.ready = false;
+  }
+  /**
+   * Register an arbitrary teardown callback, run on {@link dispose} in reverse
+   * order of registration.
+   */
+  onDispose(callback) {
+    this.disposers.push(callback);
+  }
+  /**
+   * Dispose the container: run all teardown callbacks (and the `dispose()` of
+   * any registered {@link Disposable} singletons/values) in reverse order, then
+   * clear all registrations. Idempotent.
+   *
+   * Note: transient (`factory`) and lazy instances are owned by the caller, not
+   * the container, so they are not disposed here.
+   */
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    for (const disposer of [...this.disposers].reverse()) {
+      try {
+        await disposer();
+      } catch (error) {
+        getLogger().error("Diadem: disposer threw during dispose()", error);
+      }
+    }
+    this.clear();
+  }
+  /** Whether {@link dispose} has been called. */
+  isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Get diagnostic information about registered dependencies.
+   */
+  getDiagnostics() {
+    return {
+      dependencies: this.dependencies.size,
+      singletons: this.singletons.size,
+      factories: this.factories.size,
+      asyncFactories: this.asyncFactories.size,
+      isReady: this.ready
+    };
+  }
+  /**
+   * Check if a token is registered in the container
+   */
+  has(token) {
+    if (!token) {
+      return false;
+    }
+    return this.dependencies.has(token) || this.singletons.has(token) || this.factories.has(token) || this.asyncFactories.has(token);
+  }
+  /**
+   * Get all registered tokens
+   */
+  getRegisteredTokens() {
+    const tokens = /* @__PURE__ */ new Set();
+    this.dependencies.forEach((_, token) => tokens.add(token));
+    this.singletons.forEach((_, token) => tokens.add(token));
+    this.factories.forEach((_, token) => tokens.add(token));
+    this.asyncFactories.forEach((_, token) => tokens.add(token));
+    return Array.from(tokens);
+  }
+  /**
+   * Create a child container that inherits this container's registrations and
+   * can override them locally. Useful for per-request or per-test scopes.
+   *
+   * The child shares the parent's already-created singleton instances by
+   * reference; it deliberately does NOT inherit the parent's disposers, so
+   * disposing the child never tears down shared parent-owned resources. Only
+   * resources the child registers itself are disposed with it.
+   */
+  createChild() {
+    const child = new _DiademContainer();
+    this.dependencies.forEach((impl, token) => {
+      child.dependencies.set(token, impl);
+    });
+    this.singletons.forEach((impl, token) => {
+      child.singletons.set(token, impl);
+    });
+    this.factories.forEach((factory, token) => {
+      child.factories.set(token, factory);
+    });
+    this.asyncFactories.forEach((factory, token) => {
+      child.asyncFactories.set(token, factory);
+    });
+    return child;
+  }
+  /**
+   * Auto-discover and get information about available services.
+   * Does not register them - use autoRegisterDiscovered() for that.
+   */
+  async autoDiscover(config) {
+    const { discoverServices } = await import('./auto-discovery-RPCKK3PB.js');
+    return discoverServices(config);
+  }
+  /**
+   * Auto-discover and register all DI-decorated services using build-time manifest.
+   * This is true autowiring that doesn't require hardcoded paths or explicit imports.
+   *
+   * @param environment Optional environment filter
+   * @example
+   * ```typescript
+   * const container = new DiademContainer()
+   * await container.autoRegisterDiscovered('production')
+   * container.setReady()
+   * ```
+   */
+  async autoRegisterDiscovered(environment) {
+    try {
+      const { discoverServices } = await import('./auto-discovery-RPCKK3PB.js');
+      const discoveryResult = await discoverServices({ environment });
+      const services = discoveryResult.services;
+      if (!discoveryResult.manifestAvailable) {
+        getLogger().warn(
+          "Diadem: no manifest configured \u2014 nothing was auto-registered."
+        );
+        return;
+      }
+      const { getServicesForEnvironment } = await loadManifest();
+      const manifestEntries = getServicesForEnvironment(environment);
+      const result = await registerServicesWithManifestDependencies(
+        this,
+        services,
+        manifestEntries,
+        environment
+      );
+      const log = getLogger();
+      log.debug(
+        `Diadem: registered ${result.registeredCount} services for "${environment ?? "all"}"`,
+        result.dependencyStats
+      );
+      if (result.warnings.length > 0) {
+        log.warn("Diadem: registration warnings", result.warnings);
+      }
+    } catch (error) {
+      getLogger().error("Diadem: auto-registration failed", error);
+      throw error;
+    }
+  }
+};
+
+export { DiademContainer };
+//# sourceMappingURL=chunk-RTX6B4YY.js.map
+//# sourceMappingURL=chunk-RTX6B4YY.js.map