Multi User Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony Ecosystem Alignment: The bundle is a Symfony-compatible fork of PUGXMultiUserBundle, a legacy multi-tenancy/user management solution. If the Laravel project is Symfony-based (e.g., Lumen, Symfony bridge, or hybrid stack), this could integrate via Symfony’s component-based architecture (e.g., Doctrine ORM, UserBundle). For pure Laravel, the fit is low due to:
  • Laravel’s Eloquent ORM vs. Doctrine’s DBAL/ORM.
  • Laravel’s auth scaffolding (e.g., laravel/breeze, laravel/fortify) vs. Symfony’s UserBundle.
  • No native Laravel service providers or facades.
• Multi-Tenancy Model: The bundle appears to support multi-user/tenant isolation (e.g., shared DB with tenant IDs). Laravel alternatives like spatie/laravel-multitenancy or stancl/tenancy are more mature for Laravel.
• Legacy Risk: The bundle has 0 stars/dependents, suggesting abandoned maintenance or niche use. The original PUGXMultiUserBundle (Symfony 2.x) is also outdated.

Integration Feasibility

• Symfony Projects:
  • High feasibility if using Symfony 4.4+ with friendsofsymfony/user-bundle (v2.x).
  • Requires Doctrine ORM (not DBAL alone) and Symfony’s dependency injection.
  • May conflict with Laravel’s service container if hybrid.
• Laravel Projects:
  • Low feasibility without a Symfony bridge (e.g., symfony/panther for testing, but not core functionality).
  • Workarounds:
    • Rewrite logic in Laravel (e.g., middleware for tenant switching).
    • Use as a reference for custom multi-tenancy (e.g., tenant-aware models).
• Database Schema:
  • Assumes Doctrine schema (e.g., User, Group, UserGroup tables). Laravel would need migration adjustments.

Technical Risk

Key Questions

1. Why Symfony? If the project is Laravel-native, is there a specific Symfony dependency (e.g., legacy monolith) requiring this bundle?
2. Multi-Tenancy Scope:
   • Is this for soft multi-tenancy (tenant ID in requests) or hard multi-tenancy (separate schemas/databases)?
   • Does Laravel already have a tenant-aware auth system (e.g., tenant() helper)?
3. Maintenance Commitment:
   • Can the team fork and maintain this bundle for Laravel?
   • Are there Symfony 6.x compatibility plans?
4. Alternatives:
   • For Laravel: spatie/laravel-multitenancy (shared DB) or stancl/tenancy (separate DBs).
   • For Symfony: api-platform/core (modern alternative) or symfonycasts/verify-email for user flows.
5. Data Migration:
   • How will existing User, Group, and UserGroup data migrate from Doctrine to Eloquent?
6. Testing:
   • Are there Symfony-specific tests (e.g., phpunit-bridge) that won’t work in Laravel?

Integration Approach

Stack Fit

Migration Path

Option 1: Symfony Project (Recommended if Applicable)

1. Add Bundle:

   composer require alessandrolandim/multi-user-bundle
   

2. Configure:
   • Update config/packages/security.yaml and config/packages/pugx_multi_user.yaml.
   • Extend User entity (Symfony’s UserInterface).
3. Migrate Data:
   • Use Doctrine migrations to align with bundle’s schema.
4. Test:
   • Verify tenant switching, role-based access, and group logic.

Option 2: Laravel (High Effort)

1. Fork the Bundle:
   • Rename to laravel-multi-user-bundle.
   • Replace Symfony-specific code (e.g., ContainerAware, EventDispatcher) with Laravel equivalents.
2. Key Replacements:
   • UserBundle → Laravel’s Auth + Breeze.
   • Doctrine → Eloquent models.
   • Symfony’s Router → Laravel’s Route service.
3. Service Provider:

   // app/Providers/MultiUserServiceProvider.php
   public function register()
   {
       $this->app->singleton('tenant', function () {
           return new TenantManager(); // Custom implementation
       });
   }
   

4. Middleware:

   // app/Http/Middleware/TenantMiddleware.php
   public function handle($request, Closure $next)
   {
       Tenant::set($request->tenant_id);
       return $next($request);
   }
   

5. Database:
   • Create Eloquent models for User, Group, UserGroup.
   • Add tenant_id to pivot tables.

Option 3: Hybrid (Symfony + Laravel)

• Use Symfony for APIs (with the bundle) and Laravel for frontend.
• Share auth state via JWT/OAuth2 (e.g., lexik/jwt-authentication-bundle).

Compatibility

• Doctrine ORM: Laravel uses Eloquent. Conflict: High.
• UserBundle: Laravel’s Auth is simpler. Conflict: High.
• Symfony Events: Laravel’s events are similar but not identical. Conflict: Medium.
• Routing: Symfony’s routing is more complex. Conflict: Medium.

Sequencing

1. Assess Scope:
   • Document current multi-tenancy/user management in Laravel.
2. Prototype:
   • Implement a minimal tenant switcher in Laravel (without the bundle) to validate requirements.
3. Decision Point:
   • If Symfony is mandatory → proceed with Option 1.
   • If Laravel-only → evaluate Option 2 or use a Laravel-native alternative.
4. Pilot:
   • Test with a single tenant first.
5. Gradual Rollout:
   • Add group/role logic post-tenancy validation.

Operational Impact

Maintenance

Support

• Symfony:
  • Leverage friendsofsymfony/user-bundle community.