Enhance plugin management and refactor application startup sequence

- Introduced `PluginContext` type in `exports.go` for improved plugin context handling.
- Refactored the `Start` method in `forge.go` to initialize plugins before setting the application status, ensuring proper service and controller registration.
- Updated `plugin.go` to align plugin type definitions with the `common` package.
- Streamlined the plugin startup process in `manager.go` by reorganizing the order of service registration, plugin initialization, and middleware setup for better clarity and functionality.

Signed-off-by: Rubicon Lee <rex.raphael@outlook.com>

Author: juicycleff

exports.go

@@ -39,6 +39,7 @@ type Service = common.Service
 type ServiceDefinition = common.ServiceDefinition
 type Plugin = common.Plugin
 type PluginMetrics = common.PluginMetrics
+type PluginContext = common.PluginContext
 type Hook = common.Hook
 type ConfigSchema = common.ConfigSchema
 type ConfigProperty = common.ConfigProperty

forge.go

@@ -1264,7 +1264,6 @@ func (app *ForgeApplication) Start(ctx context.Context) error {
 		return common.ErrLifecycleError("start", fmt.Errorf("application already started or in invalid state: %s", app.status))
 	}
 
-	app.status = common.ApplicationStatusStarting
 	app.startTime = time.Now()
 
 	if app.logger != nil {
@@ -1283,7 +1282,19 @@ func (app *ForgeApplication) Start(ctx context.Context) error {
 		return err
 	}
 
-	// Start container
+	// Start plugins BEFORE container starts to allow service and controller registration
+	// Keep status as NotStarted during plugin initialization
+	if app.pluginsManager != nil {
+		if err := app.pluginsManager.StartPlugins(ctx); err != nil {
+			app.status = common.ApplicationStatusError
+			return fmt.Errorf("failed to start plugins: %w", err)
+		}
+	}
+
+	// Now set status to Starting after plugins have registered their components
+	app.status = common.ApplicationStatusStarting
+
+	// Start container - this locks service registration
 	if app.container != nil {
 		if err := app.container.Start(ctx); err != nil {
 			app.status = common.ApplicationStatusError
@@ -1307,14 +1318,6 @@ func (app *ForgeApplication) Start(ctx context.Context) error {
 		}
 	}
 
-	// Start plugins
-	if app.pluginsManager != nil {
-		if err := app.pluginsManager.StartPlugins(ctx); err != nil {
-			app.status = common.ApplicationStatusError
-			return fmt.Errorf("failed to start plugins: %w", err)
-		}
-	}
-
 	app.status = common.ApplicationStatusRunning
 
 	if app.logger != nil {

pkg/pluginengine/plugin.go

@@ -9,34 +9,34 @@ import (
 )
 
 // Plugin defines the interface for framework plugins
-type PluginEngine = common2.PluginEngineEngine
+type PluginEngine = common2.PluginEngine
 
 // PluginType defines the type of plugin
-type PluginType = common2.PluginEngineType
+type PluginType = common2.PluginType
 
 const (
-	PluginTypeMiddleware  = common2.PluginEngineTypeMiddleware
-	PluginTypeDatabase    = common2.PluginEngineTypeDatabase
-	PluginTypeAuth        = common2.PluginEngineTypeAuth
-	PluginTypeCache       = common2.PluginEngineTypeCache
-	PluginTypeStorage     = common2.PluginEngineTypeStorage
-	PluginTypeMessaging   = common2.PluginEngineTypeMessaging
-	PluginTypeMonitoring  = common2.PluginEngineTypeMonitoring
-	PluginTypeAI          = common2.PluginEngineTypeAI
-	PluginTypeSecurity    = common2.PluginEngineTypeSecurity
-	PluginTypeIntegration = common2.PluginEngineTypeIntegration
-	PluginTypeUtility     = common2.PluginEngineTypeUtility
-	PluginTypeExtension   = common2.PluginEngineTypeExtension
+	PluginTypeMiddleware  = common2.PluginTypeMiddleware
+	PluginTypeDatabase    = common2.PluginTypeDatabase
+	PluginTypeAuth        = common2.PluginTypeAuth
+	PluginTypeCache       = common2.PluginTypeCache
+	PluginTypeStorage     = common2.PluginTypeStorage
+	PluginTypeMessaging   = common2.PluginTypeMessaging
+	PluginTypeMonitoring  = common2.PluginTypeMonitoring
+	PluginTypeAI          = common2.PluginTypeAI
+	PluginTypeSecurity    = common2.PluginTypeSecurity
+	PluginTypeIntegration = common2.PluginTypeIntegration
+	PluginTypeUtility     = common2.PluginTypeUtility
+	PluginTypeExtension   = common2.PluginTypeExtension
 )
 
 // PluginCapability describes what a plugin can do
-type PluginCapability = common2.PluginEngineCapability
+type PluginCapability = common2.PluginCapability
 
 // PluginDependency describes a plugin dependency
-type PluginDependency = common2.PluginEngineDependency
+type PluginDependency = common2.PluginDependency
 
 // PluginMetrics contains plugin performance metrics
-type PluginMetrics = common2.PluginEngineMetrics
+type PluginMetrics = common2.PluginMetrics
 
 // CLICommand represents a CLI command provided by a plugin
 type CLICommand = common2.CLICommand
@@ -247,28 +247,28 @@ func (p *BasePlugin) UpdateMetrics(callCount, errorCount int64, latency time.Dur
 }
 
 // PluginInfo contains metadata about a plugin
-type PluginInfo = common2.PluginEngineInfo
+type PluginInfo = common2.PluginInfo
 
 // PluginPackage represents a plugin package
-type PluginPackage = common2.PluginEnginePackage
+type PluginPackage = common2.PluginPackage
 
 // PluginStats contains plugin statistics
-type PluginStats = common2.PluginEngineStats
+type PluginStats = common2.PluginStats
 
 // PluginState represents the state of a plugin
-type PluginState = common2.PluginEngineState
+type PluginState = common2.PluginState
 
 const (
-	PluginStateUnloaded    = common2.PluginEngineStateUnloaded
-	PluginStateLoaded      = common2.PluginEngineStateLoaded
-	PluginStateInitialized = common2.PluginEngineStateInitialized
-	PluginStateStarted     = common2.PluginEngineStateStarted
-	PluginStateStopped     = common2.PluginEngineStateStopped
-	PluginStateError       = common2.PluginEngineStateError
+	PluginStateUnloaded    = common2.PluginStateUnloaded
+	PluginStateLoaded      = common2.PluginStateLoaded
+	PluginStateInitialized = common2.PluginStateInitialized
+	PluginStateStarted     = common2.PluginStateStarted
+	PluginStateStopped     = common2.PluginStateStopped
+	PluginStateError       = common2.PluginStateError
 )
 
 // PluginOperation represents an operation that can be performed on a plugin
-type PluginOperation = common2.PluginEngineOperation
+type PluginOperation = common2.PluginOperation
 
 // OperationType defines the type of operation
 type OperationType = common2.OperationType
@@ -284,7 +284,8 @@ const (
 )
 
 // PluginRegistry defines the interface for plugin registry
-type PluginRegistry = common2.PluginEngineRegistry
+type PluginRegistry = common2.PluginRegistry
+type Plugin = common.PluginEngine
 
 // RegistryStats contains plugin registry statistics
 type RegistryStats = common2.RegistryStats

pkg/plugins/manager.go

@@ -174,30 +174,8 @@ func (m *Manager) startPlugin(ctx context.Context, plugin common.Plugin) error {
 	// Create PluginContext with container, router, and config manager
 	pluginCtx := common.NewPluginContext(ctx, m.app.Container(), m.router, m.app.Config())
 
-	// Start the plugin with PluginContext
-	if err := plugin.Start(pluginCtx); err != nil {
-		return fmt.Errorf("Start failed: %w", err)
-	}
-
-	// Register routes
-	if m.router != nil {
-		if err := plugin.Routes(m.router); err != nil {
-			return fmt.Errorf("route registration failed: %w", err)
-		}
-	}
-
-	// Register middleware
-	middleware := plugin.Middleware()
-	if m.router != nil && len(middleware) > 0 {
-		for _, mw := range middleware {
-			if mwFunc, ok := mw.(func(http.Handler) http.Handler); ok {
-				// Register middleware
-				m.router.UseMiddleware(mwFunc)
-			}
-		}
-	}
-
-	// Register services
+	// Step 1: Register services FIRST (before anything else)
+	// Controllers, routes, and middleware may depend on these services
 	services := plugin.Services()
 	if m.app != nil && m.app.Container() != nil {
 		for _, svc := range services {
@@ -213,18 +191,95 @@ func (m *Manager) startPlugin(ctx context.Context, plugin common.Plugin) error {
 		}
 	}
 
-	// Register controllers
+	// Step 2: Start the plugin with PluginContext
+	// Plugin can now register additional services if needed
+	if err := plugin.Start(pluginCtx); err != nil {
+		return fmt.Errorf("start failed: %w", err)
+	}
+
+	// Step 3: Register controllers
+	// Register controllers directly with router without initializing them yet
+	// Controllers will be initialized later after container starts
 	controllers := plugin.Controllers()
-	if m.app != nil {
+	if m.router != nil && len(controllers) > 0 {
+		// Set plugin context in router if supported
+		if setter, ok := m.router.(interface{ SetCurrentPlugin(string) }); ok {
+			setter.SetCurrentPlugin(name)
+			defer func() {
+				if clearer, ok := m.router.(interface{ ClearCurrentPlugin() }); ok {
+					clearer.ClearCurrentPlugin()
+				}
+			}()
+		}
+
+		// Register each controller with router
 		for _, ctrl := range controllers {
-			if err := m.app.AddController(ctrl); err != nil {
+			if m.logger != nil {
+				m.logger.Debug("registering controller from plugin",
+					logger.String("plugin", name),
+					logger.String("controller", ctrl.Name()),
+				)
+			}
+
+			// Initialize controller with container first
+			// Note: This happens before container.Start(), so services cannot be resolved yet
+			// Controllers should defer service resolution to their handler methods or
+			// implement a lazy initialization pattern
+			if err := ctrl.Initialize(m.app.Container()); err != nil {
 				if m.logger != nil {
-					m.logger.Warn("failed to register controller from plugin",
+					m.logger.Error("failed to initialize controller from plugin",
 						logger.String("plugin", name),
 						logger.String("controller", ctrl.Name()),
 						logger.Error(err),
 					)
 				}
+				return fmt.Errorf("failed to initialize controller %s: %w", ctrl.Name(), err)
+			}
+
+			// Register controller with router
+			if err := m.router.RegisterController(ctrl); err != nil {
+				if m.logger != nil {
+					m.logger.Error("failed to register controller from plugin",
+						logger.String("plugin", name),
+						logger.String("controller", ctrl.Name()),
+						logger.Error(err),
+					)
+				}
+				return fmt.Errorf("failed to register controller %s: %w", ctrl.Name(), err)
+			}
+
+			if m.logger != nil {
+				m.logger.Debug("controller registered successfully",
+					logger.String("plugin", name),
+					logger.String("controller", ctrl.Name()),
+				)
+			}
+		}
+
+		if m.logger != nil {
+			m.logger.Info("plugin controllers registered",
+				logger.String("plugin", name),
+				logger.Int("count", len(controllers)),
+			)
+		}
+	}
+
+	// Step 4: Register routes
+	// Routes can reference controllers and services
+	if m.router != nil {
+		if err := plugin.Routes(m.router); err != nil {
+			return fmt.Errorf("route registration failed: %w", err)
+		}
+	}
+
+	// Step 5: Register middleware
+	// Middleware is applied last
+	middleware := plugin.Middleware()
+	if m.router != nil && len(middleware) > 0 {
+		for _, mw := range middleware {
+			if mwFunc, ok := mw.(func(http.Handler) http.Handler); ok {
+				// Register middleware
+				m.router.UseMiddleware(mwFunc)
 			}
 		}
 	}