Helper Composer Laravel Package

Getting Started

Minimal Steps

1. Install the Plugin: Add the package to your project via Composer:

   composer require --dev denisok94/helper-composer
   

   • Use --dev initially to avoid polluting production dependencies unless explicitly needed.

2. Trigger Initial Setup: Run Composer to let the plugin process dependencies:

   composer update
   

   • The plugin will automatically install its bundled packages (e.g., denisok94/symfony-export, denisok94/yii2-widgets) as defined in its releases.

3. First Use Case:

   • Quick Dependency Onboarding: Install a suite of related packages (e.g., Symfony/Yii2 helpers) in one command, ideal for legacy projects or multi-framework setups.
   • Example: Use denisok94/symfony-export for data export functionality without manually requiring it:

     use Denisok94\SymfonyExport\Exporter;
     $exporter = new Exporter();
     $exporter->exportToCsv($data, 'output.csv');
     

4. Where to Look First:

   • Release Notes: Check the releases to confirm which packages are bundled (e.g., 0.0.9 adds symfony-export).
   • Composer JSON: Verify the plugin’s extra or scripts sections in your composer.json for hooks or configurations.
   • Plugin Source: If debugging, inspect the plugin’s logic in its GitHub repository (e.g., how it modifies composer.json or runs post-install scripts).

Implementation Patterns

Usage Patterns

1. Bundled Dependency Workflow:

   • Installation: Use the plugin as a shortcut to install multiple related packages:

     composer require denisok94/helper-composer
     composer update
     

   • Result: All packages listed in the plugin’s releases (e.g., symfony-helper, yii-metatag) are added to composer.json automatically.
   • Use Case: Ideal for legacy Laravel projects needing Symfony/Yii2 utilities without manual dependency management.

2. Laravel Integration:

   • Service Providers: If bundled packages include Laravel-compatible providers (e.g., SymfonyHelperServiceProvider), register them in config/app.php:

     'providers' => [
         // ...
         Denisok94\SymfonyHelper\SymfonyHelperServiceProvider::class,
     ],
     

   • Facades/Helpers: Use the bundled helpers in your code:

     use Denisok94\SymfonyExport\Facades\Export;
     $data = Export::toCsv($collection);
     

3. Custom Composer Scripts:

   • Post-Install Hooks: The plugin may run scripts after installation (e.g., publishing config files). Check for:

     "scripts": {
         "post-install-cmd": [
             "denisok94-helper-composer:post-install"
         ]
     }
     

   • Manual Triggers: If the plugin lacks Laravel-specific hooks, add custom scripts to composer.json:

     "scripts": {
         "post-root-package-install": [
             "@php artisan config:clear"
         ]
     }
     

4. Conditional Loading:

   • Environment-Specific Dependencies: Use Composer’s conflict or replace to manage version constraints:

     "conflict": {
         "denisok94/symfony-export": ">=2.0.0"
     }
     

   • Dev vs. Prod: Install dev-only packages (e.g., yii-metatag) conditionally:

     composer require --dev denisok94/helper-composer
     

5. Multi-Framework Projects:

   • Monorepos: Use the plugin to manage cross-framework dependencies (e.g., Symfony helpers in a Laravel app) without conflicts:

     composer require denisok94/helper-composer --working-dir=./laravel-app
     

Integration Tips

• Laravel Compatibility:
  • Test with Laravel 10.x/11.x and PHP 8.1+ to avoid version conflicts.
  • Use composer why-not <package> to debug dependency resolution issues.
• Dependency Isolation:
  • Pin bundled packages to specific versions in composer.json to avoid drift:

    "require": {
        "denisok94/symfony-export": "1.0.0"
    }
    

• CI/CD Pipelines:
  • Add a step to validate the plugin’s dependencies:

    - run: composer validate && composer install --prefer-dist --no-interaction
    

• Local Development:
  • Use composer install --prefer-source to debug the plugin’s behavior during development.

Gotchas and Tips

Pitfalls

1. Dependency Conflicts:

   • Risk: The plugin may pull in non-Laravel packages (e.g., Symfony Console) that conflict with Laravel’s constraints.
   • Solution: Use composer why <package> to identify conflicts and manually pin versions:

     composer why symfony/console
     

   • Workaround: Exclude conflicting packages in composer.json:

     "replace": {
         "symfony/console": "6.3.0"
     }
     

2. Plugin-Specific Issues:

   • No Laravel Awareness: The plugin lacks native Laravel integration (e.g., no Artisan commands or ServiceProvider hooks). Expect manual setup for Laravel-specific features.
   • Debugging: If composer update fails, check the plugin’s logs or source code for errors. Use --verbose:

     composer update --verbose
     

3. Version Locking:

   • Risk: The plugin may update bundled packages without notifying you, breaking your app.
   • Solution: Lock versions in composer.json:

     "require": {
         "denisok94/helper-composer": "0.0.9",
         "denisok94/symfony-export": "1.0.0"
     }
     

4. Performance Overhead:

   • Risk: The plugin may slow down composer install if it performs heavy operations (e.g., cloning repositories).
   • Solution: Benchmark with:

     time composer install --optimize-autoloader
     

5. Lack of Documentation:

   • Risk: No official Laravel-specific docs or examples.
   • Solution: Reverse-engineer the plugin’s behavior by:
     • Checking release notes for bundled packages.
     • Inspecting the plugin’s source code (e.g., Plugin.php in the repository).

Debugging Tips

1. Composer Debugging:

   • Use --dry-run to preview changes:

     composer update --dry-run
     

   • Check the composer.lock file for unexpected changes.

2. Plugin-Specific Logs:

   • Enable Composer’s debug mode:

     composer --verbose update
     

   • Look for plugin-specific output (e.g., denisok94-helper-composer: ...).

3. Laravel-Specific Issues:

   • Clear Laravel’s cache after installing the plugin:

     php artisan config:clear
     php artisan cache:clear
     

   • Test with a fresh Laravel installation to isolate issues.

Configuration Quirks

1. Composer JSON Modifications:

   • The plugin may automatically add dependencies to composer.json. To prevent this, use:

     "config": {
         "allow-plugins": {
             "denisok94/helper-composer": false
         }
     }
     

   • Warning: Disabling the plugin may break its intended functionality.

2. Post-Install Scripts:

   • If the plugin runs scripts (e.g., post-install-cmd), ensure they are compatible with Laravel’s environment:

     "scripts": {
         "post-install-cmd": [
             "@php artisan optimize:clear"
         ]
     }
     

3. Autoloading:

   • The plugin may add custom autoload rules. Verify with:

     composer dump-autoload --optimize
     

   • If issues arise, manually define autoload paths in composer.json:

     "autoload": {
         "psr-4": {
             "Denisok94\\SymfonyExport\\": "vendor/denisok94/symfony-export/src/"
         }
     }
     

Extension Points

1. Custom Plugin Logic:
   • Fork the plugin to add Laravel-specific features (e.g., Artisan commands, ServiceProviders). Example:

     // In a custom plugin class
     public function onPostInstall(PostInstallEvent $event) {
         if ($event->getOperation()->isDevMode()) {
             Artisan::call