Starter Kit Laravel Package

Technical Evaluation

Architecture Fit

• Pros:

  • Rapid Laravel Scaffolding: Eliminates repetitive setup for new Laravel projects, aligning with modern Laravel conventions (Laravel 13+).
  • Stack Agnostic: Supports Inertia.js (Vue/React) and Livewire, catering to teams with different frontend preferences.
  • Batteries-Included Auth: Custom 2FA (TOTP), email verification, and session management reduce dependency on Laravel Fortify/Breeze.
  • Internationalization: Built-in locale switching and translation files (lang/es/en/kit.php) simplify multilingual apps.
  • Tailwind CSS Integration: All presets use Tailwind, ensuring UI consistency and customization flexibility.

• Cons:

  • Limited Maturity: Low GitHub stars (1) and no dependents suggest unproven adoption; risk of undocumented edge cases.
  • Hardcoded Structure: Presets enforce specific directory layouts (e.g., resources/js/presets/, app/Http/Controllers/Auth), which may conflict with existing projects.
  • No Backend Framework: Focuses solely on frontend scaffolding; lacks API/SPA separation guidance for hybrid apps.
  • PHP 8.3/Laravel 13 Only: Excludes older Laravel versions, limiting legacy project compatibility.

Integration Feasibility

• New Projects: Ideal for greenfield Laravel 13+ apps where scaffolding can be applied cleanly.
• Existing Projects:
  • High Risk: --force flag overwrites files (e.g., routes/web.php, app/Http/Middleware), requiring manual merge or backup.
  • Auth Conflicts: Custom auth system may clash with existing Laravel auth (e.g., HasApiTokens, Sanctum).
  • Middleware: Automatically registers HandleInertiaRequests (for Inertia presets) and SetLocale, which could conflict with existing middleware.
• CI/CD: Non-interactive mode (--no-interaction) supports automation, but dependency updates (composer install, npm install) must be explicitly handled.

Technical Risk

Key Questions for TPM

1. Project Scope:
   • Is this for a new project or refactoring an existing Laravel app? (Existing projects require careful --force usage.)
   • Will the app need API endpoints alongside frontend scaffolding? (Package lacks API-specific guidance.)
2. Tech Stack Alignment:
   • Does the team prefer Inertia.js or Livewire? (Affects preset choice and long-term maintainability.)
   • Are there existing UI libraries (e.g., Bootstrap, Alpine) that conflict with Tailwind/PrimeVue/Naive UI?
3. Auth Requirements:
   • Does the app need social login (e.g., OAuth)? (Package uses custom auth; extensions may be needed.)
   • Is 2FA mandatory? (TOTP is included but may require additional UX testing.)
4. Internationalization:
   • Are more than 2 languages needed? (Package supports only es/en; extensions required.)
5. Performance:
   • How will Vite + Tailwind impact build times in CI/CD? (Test npm run build duration post-install.)
6. Long-Term Maintenance:
   • Who will update the starter kit if the package evolves? (No clear roadmap or maintainer.)
   • Are there roll-back procedures for failed installations? (Manual cleanup may be needed.)

Integration Approach

Stack Fit

• Best For:
  • Full-stack Laravel apps with frontend needs (Inertia/Livewire).
  • Teams comfortable with Tailwind CSS and modern JS frameworks (Vue 3/React).
  • Projects requiring quick auth scaffolding (registration, 2FA, email verification).
• Not For:
  • API-only or headless Laravel apps (no API-specific features).
  • Projects using non-Tailwind CSS frameworks (e.g., Bootstrap, Bulma).
  • Legacy Laravel versions (<13) or PHP <8.3.

Migration Path

Compatibility

• Laravel: Confirmed for 13.x (PHP 8.3+). Test compatibility with Laravel 14 when released.
• Frontend:
  • Inertia Presets: Require Node.js 16+ (Vue 3/React).
  • Livewire Preset: No Node.js dependency (Blade-based).
• Database: Assumes standard Laravel migrations (no schema-specific risks).
• Dependencies:
  • Composer: May conflict with existing packages (e.g., pragmarx/google2fa for 2FA).
  • NPM: Tailwind 4 + PrimeVue/Naive UI/MUI may require additional peer dependencies.

Sequencing

1. Pre-Install:
   • Verify Laravel 13+ and PHP 8.3+.
   • Backup routes/, app/Http/, and resources/ if modifying existing project.
2. Install:
   • Choose preset (--ui=primevue/--ui=wireui) and auth (--auth).
   • Run php artisan kitlauncher:install (interactive or non-interactive).
3. Post-Install:
   • Update dependencies: composer install, npm install.
   • Run migrations: php artisan migrate.
   • Build assets: npm run build.
4. Validation:
   • Test auth flows: php artisan test (if tests were installed).
   • Verify frontend routes (e.g., /dashboard, /login).
5. Customization:
   • Extend presets (e.g., add new Inertia pages or Livewire components).
   • Update vite.config.js for custom asset paths.

Operational Impact

Maintenance

• Pros:
  • Centralized Config: Auth and locale settings in config/servicios-linea-once.php.
  • Modular Presets: Easy to swap UI stacks (e.g., PrimeVue → Naive UI) via --force.
  • Built-in Tests: Feature tests for auth flows reduce regression risk.
• Cons:
  • Vendor Lock-in: Custom auth tables (two_factor_columns_to_users_table) may complicate future migrations.
  • Dependency Bloat: Presets include many UI libraries (e.g., PrimeVue + Tailwind), increasing bundle size.
  • Limited Documentation: README is comprehensive but lacks troubleshooting for edge cases.

Support

• Strengths:
  • Interactive Installer: Guides users through setup with clear prompts.
  • Bilingual Support: Spanish/English installer reduces language barriers.
  • Non-Interactive Mode: Suitable for CI/CD and scripts.
• Weaknesses:
  • No Official Support: MIT license implies community-driven fixes.
  • Undocumented Edge Cases: Low adoption may leave issues unresolved.
  • Debugging: Custom auth system may require deep Laravel knowledge to troubleshoot.

Scaling

• Performance:
  • Frontend: Vite + Tailwind should scale well for medium-sized apps; test build times for large codebases.
  • Backend: Custom auth adds minimal overhead (TOTP generation is lightweight).
  • Database: 2FA recovery codes and auth tables are minimal (~100KB).
• Team Scaling:
  • Onboarding: Reduces scaffolding time but requires familiarity with chosen preset (e.g., Inertia vs. Livewire).
  • Collaboration: Shared presets (e.g., PrimeVue) ensure UI consistency across teams.
• Horizontal Scaling:
  • No inherent limitations; follows Laravel best practices for statelessness.

Failure Modes

| Failure Scenario