Getting Started

Minimal Setup

Install the package:
```
composer require internachi/modularize
```

Add the trait to a command:

use InterNACHI\Modularize\Support\Modularize;

class MyCommand extends Command {
    use Modularize;
}

Use the --module flag:
```
php artisan my:command --module=Blog
```

Access module data:

public function handle() {
    if ($module = $this->module()) {
        $this->info("Module: {$module->name}");
        $this->info("Path: {$module->path}");
    }
}

First Use Case: Module-Aware Generator

For file generators (e.g., MakeController), extend GeneratorCommand and use ModularizeGeneratorCommand:

use InterNACHI\Modularize\Support\ModularizeGeneratorCommand;

class MakeWidget extends GeneratorCommand {
    use ModularizeGeneratorCommand;

    protected function getDefaultNamespace() {
        return $this->module()
            ? $this->module()->getNamespace('Http/Controllers')
            : parent::getDefaultNamespace();
    }
}

Run:

php artisan make:widget --module=Blog

Key Files to Review

Support/Modularize.php: Core trait for basic module access.
Support/ModularizeGeneratorCommand.php: Generator-specific logic.
internachi/modular docs: Understand ModuleConfig methods (e.g., getNamespace()).

Implementation Patterns

Workflow: Adding Module Support to Existing Commands

Identify command type:
- File generators: Use ModularizeGeneratorCommand.
- Other commands: Use Modularize.

Add the trait:

use InterNACHI\Modularize\Support\Modularize; // or ModularizeGeneratorCommand

Override methods as needed:
- For generators: getDefaultNamespace(), getPath().
- For custom logic: Use $this->module() to access ModuleConfig.
Test with --module flag:
```
php artisan my:command --module=Admin
```

Integration with `internachi/modular`

ModuleConfig methods:
- $module->name: Module name (e.g., Blog).
- $module->path: Base path (e.g., modules/Blog).
- $module->getNamespace(string $subpath): Full namespace (e.g., Modules\Blog\Http\Controllers).
- $module->exists(): Check if module exists.

Example:

if ($module = $this->module()) {
    $namespace = $module->getNamespace('Http/Controllers');
    $this->info("Generating in: {$namespace}");
}

Common Patterns

Fallback Logic:

protected function getDefaultNamespace() {
    return $this->module()
        ? $this->module()->getNamespace('Http/Controllers')
        : 'App\Http\Controllers';
}

Dynamic Paths:

protected function getPath($name) {
    return $this->module()
        ? $this->module()->path("database/migrations/{$name}")
        : database_path("migrations/{$name}");
}

Module Validation:

if (!$this->module() || !$this->module()->exists()) {
    $this->error('Module not found or invalid.');
    return 1;
}

Laravel Service Provider Integration

If your package includes a service provider, ensure internachi/modular is bootstrapped:

public function boot() {
    $this->app->make('internachi/modular')->boot();
}

Gotchas and Tips

Pitfalls

Missing --module Flag:
- Commands won’t fail if --module is omitted, but $this->module() returns null.
- Fix: Always check $this->module() before use.
```
if (!$module = $this->module()) {
    $this->error('Module required. Use --module=NAME.');
    return 1;
}
```
Namespace Collisions:
- If a module’s namespace conflicts with global namespaces (e.g., App vs. Modules\App), generated files may fail to autoload.
- Fix: Use $module->getNamespace() explicitly and validate it:
```
$namespace = $module->getNamespace('Http/Controllers');
if (str_contains($namespace, 'App')) {
    $this->error('Namespace conflict detected.');
    return 1;
}
```
Generator Path Overrides:
- ModularizeGeneratorCommand does not override getStub() or getFileName(). Ensure these methods return module-aware values if needed.
- Example:
```
protected function getFileName() {
    return $this->module()
        ? "{$this->argument('name')}Service.php"
        : parent::getFileName();
}
```
Laravel 13+ Console Component:
- The package assumes Symfony 7.x (Laravel 13+). If using older Laravel, expect console argument parsing issues.
- Fix: Upgrade to Laravel 13+ or patch the trait to use Symfony\Component\Console directly.
Module Not Found:
- $this->module()->exists() may return false if the module is registered but not bootstrapped.
- Fix: Ensure internachi/modular is bootstrapped in your app’s AppServiceProvider:
```
public function boot() {
    app('internachi/modular')->boot();
}
```

Debugging Tips

Dump Module Data:

$this->line(print_r($this->module(), true));

Check Module Registration:
```
php artisan modular:list
```

Validate Paths:

$this->info("Module path: " . $this->module()->path);
$this->info("Generated path: " . $this->getPath($name));

Extension Points

Custom ModuleConfig: Extend InterNACHI\Modular\Support\ModuleConfig to add custom methods:

namespace App\Modules;

use InterNACHI\Modular\Support\ModuleConfig;

class CustomModuleConfig extends ModuleConfig {
    public function getCustomPath() {
        return $this->path('custom/directory');
    }
}

'config' => App\Modules\CustomModuleConfig::class,

Override Generator Behavior: Extend ModularizeGeneratorCommand to customize file generation:

use InterNACHI\Modularize\Support\ModularizeGeneratorCommand;

class CustomMakeCommand extends GeneratorCommand {
    use ModularizeGeneratorCommand {
        getDefaultNamespace as traitGetDefaultNamespace;
    }

    protected function getDefaultNamespace() {
        $namespace = $this->traitGetDefaultNamespace();
        return str_replace('App', 'Modules\\' . $this->module()->name, $namespace);
    }
}

Add Module-Specific Arguments: Use Laravel’s --option syntax to add module-aware flags:

protected $signature = 'my:command
    {--module= : The module name}
    {--force : Force execution}';

Configuration Quirks

config/modular.php: Ensure the modules path is correctly configured. Default:
```
'modules' => base_path('modules'),
```
If using custom paths, update the config or extend ModuleConfig.

Autoloading: Generated files in modules must be autoloaded. Add to composer.json:

"autoload": {
    "psr-4": {
        "Modules\\Blog\\": "modules/Blog/src/"
    }
}

Caching: Module paths/namespaces are cached by Laravel. Clear the cache if changes don’t reflect:
```
php artisan cache:clear
php artisan config:clear
```

Performance Considerations

Avoid Repeated $this->module() Calls: Cache the result in the command’s __construct():

private $module;

public function __construct() {
    parent::__construct();
    $this->module = $this->module();
}

Lazy-Load ModuleConfig: For heavy commands, defer module loading until needed:

public function handle() {
    if ($this->option('module')) {
        $module = $this->module();
        // Use $module...
    }
}

Laravel 13+ Specifics

Symfony 7.x Console: The package uses

Modularize Laravel Package