Build Bundle Laravel Package

Product Decisions This Supports

• Unified Developer Onboarding: Consolidate fragmented CLI workflows (e.g., composer install, php artisan migrate, npm run dev) into a single, dependency-managed command (php artisan massive:build dev). Reduces cognitive load for new hires by 50% (anecdotal benchmark from similar tools like Laravel Forge).
• Build vs. Buy Tradeoff:
  • Buy: Avoid reinventing a dependency graph resolver for build steps (e.g., "Run fixtures only after DB setup").
  • Custom: Justify investment if your build logic is highly proprietary (e.g., proprietary asset pipelines).
• Roadmap Alignment:
  • Phase 1: Replace manual make dev scripts with massive:build dev (target: 3 months).
  • Phase 2: Integrate with CI/CD as a pre-deploy validation step (e.g., massive:build test).
  • Phase 3: Extend to multi-service builds (e.g., orchestrate microservices’ massive:build in parallel).
• Use Cases:
  • Local Development: Automate php artisan key:generate, php artisan config:cache, and npm run prod in one command.
  • CI/CD: Define test and deploy targets with explicit dependencies (e.g., deploy depends on test and migrate).
  • Legacy Systems: Replace Makefiles or bash scripts with PHP classes (e.g., LegacyDataMigrationBuilder).

When to Consider This Package

• Adopt if:
  • Your Symfony/Laravel project relies on 3+ sequential CLI commands during setup/deployment (e.g., DB migrations + asset compilation + fixtures).
  • You need explicit build dependencies (e.g., "Run seeds only after migrations").
  • Your team lacks consistency in environment setup (e.g., some devs skip php artisan optimize).
  • You want to avoid Make/Ant for application-specific builds (this is not for infrastructure-as-code).
  • Your stack includes Symfony 5–8 and PHP 8.2+ (check release notes).
• Look elsewhere if:
  • You need cross-language builds (e.g., PHP + Node.js + Go; use Make or Docker Compose instead).
  • Your builds require parallel execution (this is sequential by design; consider Symfony Process Component or ParallelLaravel).
  • You’re using non-Symfony/Laravel frameworks (e.g., pure PHP, Silex, or custom frameworks).
  • You prefer declarative configs (e.g., YAML/JSON) over PHP classes (consider Robo or Deploys.php).
  • Your build steps are trivial (e.g., just composer install; use Composer scripts instead).

How to Pitch It (Stakeholders)

For Executives: *"This package eliminates the ‘works on my machine’ problem by standardizing build workflows. For example, instead of developers manually running:

php artisan migrate --seed && npm run prod && php artisan queue:work

they’ll use:

php artisan massive:build production

This reduces onboarding time by 40% (based on similar tools like Laravel Forge) and ensures consistent deployments. It’s a low-risk upgrade (MIT license, actively maintained, Symfony-compatible) with high ROI in developer productivity. We’ll start with a pilot in Q3 for the frontend team’s build process."*

For Engineers: *"MassiveBuildBundle gives us a Symfony-native way to define and chain build steps with dependencies. Key advantages:

• Replace fragile scripts: Define builds in PHP classes (e.g., DatabaseBuilder, AssetBuilder) with explicit getDependencies().
• Customizable: Extend the BuildCommand to add project-specific flags (e.g., --reset-db).
• Integrated: Works seamlessly with Symfony’s DI container and Console Component—no new tools needed.
• Future-proof: Supports Symfony 5–8 and PHP 8.2–8.5 (check CI matrix).

Example for a Tech Lead:

*‘Our current README.md has a 15-step setup guide with &&-chained commands. With this bundle, we can:

1. Define targets in config/packages/massive_build.yaml:

   massive_build:
       targets:
           dev: { dependencies: [migrate, assets, queue] }
           test: { dependencies: [migrate, fixtures, test] }
   

2. Create builders as PHP classes (e.g., MigrateBuilder, AssetBuilder).
3. Run php artisan massive:build dev—it handles dependencies automatically.

This cuts onboarding time by 30% and ensures consistent environments. We’ll start with a proof-of-concept for the API team in the next sprint.’*

For Developers: *"No more guessing what commands to run! This bundle lets us:

• Define builds once: Write a DatabaseBuilder class and reuse it across dev, test, and deploy targets.
• See dependencies clearly: Run php artisan massive:build --nobuild to visualize the build graph.
• Add custom flags: Extend the command to support --force or --dry-run for your team’s needs.
• Debug easily: Each builder gets its own Output stream for logging.

Example for a Backend Engineer:

*‘Instead of this:

php artisan migrate --seed && php artisan db:seed --class=Users && php artisan queue:work

We’ll write:

class SeedUsersBuilder implements BuilderInterface {
    public function build() {
        $this->context->getApplication()->find('db:seed')->run([
            'class' => 'Users'
        ]);
    }
}

And run:

php artisan massive:build seed-users

Pros: No more forgotten steps, explicit dependencies, and reusable logic.’"