@expressots/core 3.0.0 → 4.0.0-preview.3

package/lib/cjs/provider/logger/utils/log-levels.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_LOG_LEVEL_NONE = exports.LogLevel = void 0;
+exports.parseLogLevel = parseLogLevel;
+exports.logLevelToString = logLevelToString;
+exports.shouldLog = shouldLog;
+/**
+ * Log levels enum with numeric values for comparison.
+ * Lower values = more verbose, higher values = less verbose.
+ * @public API
+ */
+var LogLevel;
+(function (LogLevel) {
+    /** Show all logs (ultra-detailed diagnostic information, function entry/exit) */
+    LogLevel[LogLevel["ALL"] = 0] = "ALL";
+    /** Detailed diagnostic information for debugging */
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    /** General informational messages */
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    /** Warning messages for potentially harmful situations */
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    /** Error messages for error events */
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+    /** Fatal errors that cause the application to abort */
+    LogLevel[LogLevel["FATAL"] = 5] = "FATAL";
+    /** No logging */
+    LogLevel[LogLevel["SILENT"] = 6] = "SILENT";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/**
+ * Legacy log level for backward compatibility.
+ * Maps to INFO level.
+ */
+exports.LEGACY_LOG_LEVEL_NONE = "NONE";
+/**
+ * Convert string log level to enum.
+ * @param level - String log level
+ * @returns LogLevel enum value
+ * @public API
+ */
+function parseLogLevel(level) {
+    if (typeof level === "number") {
+        return level;
+    }
+    const upperLevel = level.toUpperCase();
+    // Handle legacy "NONE" level
+    if (upperLevel === "NONE") {
+        return LogLevel.INFO;
+    }
+    switch (upperLevel) {
+        case "ALL":
+        case "TRACE":
+            return LogLevel.ALL;
+        case "DEBUG":
+            return LogLevel.DEBUG;
+        case "INFO":
+            return LogLevel.INFO;
+        case "WARN":
+            return LogLevel.WARN;
+        case "ERROR":
+            return LogLevel.ERROR;
+        case "FATAL":
+            return LogLevel.FATAL;
+        case "SILENT":
+            return LogLevel.SILENT;
+        default:
+            return LogLevel.INFO;
+    }
+}
+/**
+ * Get string representation of log level.
+ * @param level - LogLevel enum value
+ * @returns String representation
+ * @public API
+ */
+function logLevelToString(level) {
+    switch (level) {
+        case LogLevel.ALL:
+            return "ALL";
+        case LogLevel.DEBUG:
+            return "DEBUG";
+        case LogLevel.INFO:
+            return "INFO";
+        case LogLevel.WARN:
+            return "WARN";
+        case LogLevel.ERROR:
+            return "ERROR";
+        case LogLevel.FATAL:
+            return "FATAL";
+        case LogLevel.SILENT:
+            return "SILENT";
+        default:
+            return "INFO";
+    }
+}
+/**
+ * Check if a log level should be logged based on configured level.
+ * @param messageLevel - The level of the message to log
+ * @param configuredLevel - The configured minimum log level
+ * @returns True if message should be logged
+ * @public API
+ */
+function shouldLog(messageLevel, configuredLevel) {
+    if (configuredLevel === LogLevel.SILENT) {
+        return false;
+    }
+    return messageLevel >= configuredLevel;
+}

package/lib/cjs/provider/provider-manager.js

@@ -1,22 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderManager = void 0;
-const inversify_1 = require("../di/inversify");
-const logger_provider_1 = require("./logger/logger.provider");
+const inversify_js_1 = require("../di/inversify.js");
+const logger_provider_js_1 = require("./logger/logger.provider.js");
+const provider_registry_js_1 = require("./provider-registry.js");
 /**
- * ProviderManager Class - A class for managing dependency injection providers.
+ * Provider manager for dependency injection providers.
+ *
+ * @layer public
+ * @audience application-developers
+ * @concept provider-management
+ * @difficulty beginner
+ *
+ * @summary Quick Start
+ * Manage dependency injection providers with introspection, health checks, and metrics.
+ *
+ * @example
+ * ```typescript
+ * const manager = new ProviderManager(container);
+ *
+ * // Register a provider
+ * manager.register(MyProvider, Scope.Singleton);
+ *
+ * // Discover all providers
+ * manager.discover();
+ *
+ * // Get provider
+ * const provider = manager.get(MyProvider);
+ * ```
+ *
+ * **Features:**
+ * - Provider registration with scopes
+ * - Auto-discovery of providers
+ * - Health checks and metrics collection
+ * - Provider introspection
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * **Internal Architecture**
+ *
+ * ProviderManager:
+ * - Wraps InversifyJS container
+ * - Delegates to ProviderRegistry for discovery
+ * - Provides high-level API for provider management
+ *
+ * **Design Decisions**
+ * - Thin wrapper around container and registry
+ * - Backward compatible with existing code
+ * - Enhanced with introspection capabilities
+ *
+ * @see {@link ProviderRegistry} for provider discovery
+ * @see {@link IProvider} for provider interface
+ *
  * @public API
  */
 class ProviderManager {
     constructor(container) {
-        this.logger = new logger_provider_1.Logger();
+        this.logger = new logger_provider_js_1.Logger();
         this.container = container;
+        this.registry = new provider_registry_js_1.ProviderRegistry(container);
+    }
+    /**
+     * Discover all providers in the container.
+     * Call this after the container is fully initialized.
+     * @public API
+     */
+    discover() {
+        this.registry.discover();
+    }
+    /**
+     * Get the provider registry instance.
+     * @returns The provider registry
+     * @public API
+     */
+    getRegistry() {
+        return this.registry;
     }
     /**
      * Register a provider with the container.
      * @public API
      */
-    register(serviceIdentifier, constructorOrScope, scope = inversify_1.BindingScopeEnum.Request) {
+    register(serviceIdentifier, constructorOrScope, scope = inversify_js_1.Scope.Request) {
         if (this.container.isBound(serviceIdentifier)) {
             this.logger.warn(`${serviceIdentifier.name} already registered`, "provider-manager");
             return;
@@ -25,13 +90,12 @@ class ProviderManager {
         if (typeof constructorOrScope === "function") {
             // Overload where constructor is provided
             const constructor = constructorOrScope;
-            const scopeDefinition = scope || inversify_1.BindingScopeEnum.Transient;
+            const scopeDefinition = scope || inversify_js_1.Scope.Transient;
             binding = this.container.bind(serviceIdentifier).to(constructor);
             this.applyScope(binding, scopeDefinition);
         }
         else {
-            const scopeDefinition = constructorOrScope ||
-                inversify_1.BindingScopeEnum.Transient;
+            const scopeDefinition = constructorOrScope || inversify_js_1.Scope.Transient;
             binding = this.container.bind(serviceIdentifier).toSelf();
             this.applyScope(binding, scopeDefinition);
         }
@@ -52,21 +116,32 @@ class ProviderManager {
     /**
      * Apply the scope to the binding.
      * @param binding - The binding to apply the scope to.
-     * @param scope - The scope to apply.
+     * @param scope - The scope to apply (built-in or custom scope name).
      * @private
      */
     applyScope(binding, scope) {
+        // Handle built-in scopes
         switch (scope) {
-            case inversify_1.BindingScopeEnum.Singleton:
+            case inversify_js_1.Scope.Singleton:
                 binding.inSingletonScope();
-                break;
-            case inversify_1.BindingScopeEnum.Request:
+                return;
+            case inversify_js_1.Scope.Request:
                 binding.inRequestScope();
-                break;
-            case inversify_1.BindingScopeEnum.Transient:
-            default:
+                return;
+            case inversify_js_1.Scope.Transient:
                 binding.inTransientScope();
-                break;
+                return;
+        }
+        // Handle custom scopes (any string that's not a built-in scope)
+        if (typeof scope === "string" &&
+            scope !== inversify_js_1.Scope.Singleton &&
+            scope !== inversify_js_1.Scope.Request &&
+            scope !== inversify_js_1.Scope.Transient) {
+            binding.inScope(scope);
+        }
+        else {
+            // Default to transient if scope is invalid
+            binding.inTransientScope();
         }
     }
     /**
@@ -88,5 +163,123 @@ class ProviderManager {
             return serviceIdentifier;
         }
     }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // INTROSPECTION METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Get all registered providers with metadata.
+     * @returns Array of provider information
+     * @public API
+     */
+    getAll() {
+        return this.registry.getAll();
+    }
+    /**
+     * Get providers by scope.
+     * @param scope - The scope to filter by
+     * @returns Array of providers with the specified scope
+     * @public API
+     */
+    getByScope(scope) {
+        return this.registry.getByScope(scope);
+    }
+    /**
+     * Get providers with a specific capability.
+     * @param capability - The capability to filter by
+     * @returns Array of providers with the capability
+     * @public API
+     */
+    getWithCapability(capability) {
+        return this.registry.getWithCapability(capability);
+    }
+    /**
+     * Get total provider count.
+     * @returns Number of registered providers
+     * @public API
+     */
+    getCount() {
+        return this.registry.getCount();
+    }
+    /**
+     * Check if a provider is registered.
+     * @param serviceIdentifier - The service identifier to check
+     * @returns true if registered
+     * @public API
+     */
+    has(serviceIdentifier) {
+        return this.container.isBound(serviceIdentifier);
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HEALTH & METRICS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Run health checks on all IHealthCheck providers.
+     * @returns Health dashboard with all results
+     * @public API
+     */
+    async checkHealth() {
+        return this.registry.checkHealth();
+    }
+    /**
+     * Collect metrics from all IMetrics providers.
+     * @returns Metrics dashboard with all metrics
+     * @public API
+     */
+    collectMetrics() {
+        return this.registry.collectMetrics();
+    }
+    /**
+     * Get providers that have lifecycle hooks (bootstrap/shutdown).
+     * @returns Array of providers with lifecycle hooks
+     * @public API
+     */
+    getLifecycleProviders() {
+        return this.registry.getLifecycleProviders();
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // SOURCE-BASED METHODS
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Get providers by source type.
+     * @param source - The provider source to filter by
+     * @returns Array of providers with the specified source
+     * @public API
+     */
+    getBySource(source) {
+        return this.registry.getBySource(source);
+    }
+    /**
+     * Get all built-in providers (core framework providers).
+     * @returns Array of built-in providers
+     * @public API
+     */
+    getBuiltinProviders() {
+        return this.registry.getBuiltinProviders();
+    }
+    /**
+     * Get all user-defined providers (application providers).
+     * @returns Array of user providers
+     * @public API
+     */
+    getUserProviders() {
+        return this.registry.getUserProviders();
+    }
+    /**
+     * Get all external providers (third-party plugins).
+     * @returns Array of external providers
+     * @public API
+     */
+    getExternalProviders() {
+        return this.registry.getExternalProviders();
+    }
+    /**
+     * Get a formatted view for banner display.
+     * @param maxDisplay - Maximum number of providers to show
+     * @returns Formatted provider view with source breakdown
+     * @public API
+     */
+    getFormattedView(maxDisplay = 5) {
+        return this.registry.getFormattedView(maxDisplay);
+    }
 }
 exports.ProviderManager = ProviderManager;