Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/internachi/modular/llms.txt

Use this file to discover all available pages before exploring further.

The PluginRegistry class manages plugin registration and resolution. Plugins extend Laravel Modular’s functionality and are resolved as singletons from the service container.

​
Class Reference

InterNACHI\Modular\PluginRegistry

​
Constructor

public function __construct(
    protected Container $container,
)
​
container
Container
required
The Laravel service container instance

​
Static Methods

​
register()

Statically register one or more plugins with the registry. 
public static function register(string ...$class): void
​
class
class-string<Plugin>...
required
One or more fully qualified plugin class names to register
Example: 
use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;
use App\Plugins\ModuleAnalyzer;

// Register a single plugin
PluginRegistry::register(CustomGenerator::class);

// Register multiple plugins
PluginRegistry::register(
    CustomGenerator::class,
    ModuleAnalyzer::class
);
This is a convenience method that resolves the registry from the container and calls the add() method.

​
Instance Methods

​
add()

Add one or more plugins to the registry. 
public function add(string ...$class): static
​
class
class-string<Plugin>...
required
One or more fully qualified plugin class names to add
​
return
static
Returns the registry instance for method chaining
Example: 
use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;
use App\Plugins\ModuleAnalyzer;

$registry = app(PluginRegistry::class);

$registry
    ->add(CustomGenerator::class)
    ->add(ModuleAnalyzer::class);

// Or add multiple at once
$registry->add(
    CustomGenerator::class,
    ModuleAnalyzer::class
);
Plugins are stored using their class name as a key. Adding the same plugin multiple times has no effect.

​
get()

Resolve and retrieve a plugin instance from the container. 
public function get(string $plugin, array $parameters = []): Plugin
​
plugin
class-string<Plugin>
required
The fully qualified class name of the plugin to retrieve
​
parameters
array
Optional constructor parameters to pass when resolving the plugin
​
return
Plugin
The resolved plugin instance
​
throws
InvalidArgumentException
Thrown when attempting to get a plugin that hasn’t been registered
Example: 
use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;

$registry = app(PluginRegistry::class);

// Get a plugin
$generator = $registry->get(CustomGenerator::class);

// Get a plugin with constructor parameters
$generator = $registry->get(CustomGenerator::class, [
    'option' => 'value',
]);
Plugins are resolved as singletons. If you pass new parameters to an already-resolved plugin, the instance is recreated with the new parameters and stored in the container.

​
all()

Get all registered plugin class names. 
public function all(): array
​
return
class-string<Plugin>[]
An array of registered plugin class names
Example: 
use InterNACHI\Modular\PluginRegistry;

$registry = app(PluginRegistry::class);

$plugins = $registry->all();

foreach ($plugins as $pluginClass) {
    echo "Registered plugin: {$pluginClass}\n";
}

​
Usage Examples

​
Registering Plugins in a Service Provider

use Illuminate\Support\ServiceProvider;
use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;
use App\Plugins\ModuleAnalyzer;

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        PluginRegistry::register(
            CustomGenerator::class,
            ModuleAnalyzer::class
        );
    }
}

​
Creating a Custom Plugin

use InterNACHI\Modular\Plugins\Plugin;
use Illuminate\Console\Command;

class CustomGenerator extends Plugin
{
    public function boot(): void
    {
        // Plugin initialization logic
    }
    
    public function commands(): array
    {
        return [
            // Return custom commands
        ];
    }
}

​
Resolving and Using Plugins

use InterNACHI\Modular\PluginRegistry;
use App\Plugins\ModuleAnalyzer;

$registry = app(PluginRegistry::class);

// Resolve the plugin
$analyzer = $registry->get(ModuleAnalyzer::class);

// Use the plugin
$results = $analyzer->analyzeModule('blog');

​
Checking Registered Plugins

use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;

$registry = app(PluginRegistry::class);

// Check if a plugin is registered
$plugins = $registry->all();

if (in_array(CustomGenerator::class, $plugins)) {
    $generator = $registry->get(CustomGenerator::class);
    // Use the plugin
}

​
Error Handling

use InterNACHI\Modular\PluginRegistry;
use App\Plugins\CustomGenerator;
use InvalidArgumentException;

$registry = app(PluginRegistry::class);

try {
    $plugin = $registry->get(CustomGenerator::class);
} catch (InvalidArgumentException $e) {
    // Plugin not registered
    logger()->error("Plugin not found: {$e->getMessage()}");
    
    // Register it first
    $registry->add(CustomGenerator::class);
    $plugin = $registry->get(CustomGenerator::class);
}

​
Using Constructor Parameters

use InterNACHI\Modular\PluginRegistry;
use App\Plugins\ConfigurablePlugin;

$registry = app(PluginRegistry::class);

// First resolution with parameters
$plugin = $registry->get(ConfigurablePlugin::class, [
    'mode' => 'development',
]);

// Subsequent resolution with different parameters
// This will recreate the plugin instance
$plugin = $registry->get(ConfigurablePlugin::class, [
    'mode' => 'production',
]);

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us