User Bundle Laravel Package

Getting Started

{Minimal steps, where to look first, first use case}

Before doing anything else, read the deprecation notice at the top of the README: this package is unmaintained and the maintainers point you at knpuniversity/oauth2-client-bundle or HWIOAuthBundle instead. That single fact changes the assessment — you are evaluating this as a source of patterns and as a reference implementation, not as a dependency you want to install long-term.

First look at, in order:

1. docs/index.md — the only real usage documentation.
2. CHANGELOG.md and the GitHub releases page — tells you how active it was before being abandoned.
3. src/ — especially the Command/, Form/, and EasyAdmin CRUD classes; these are the parts that carry the most portable knowledge.

If you are in a legacy Symfony 6 app (the only context where direct adoption makes sense):

composer require enabel/user-bundle
# register Enabel\UserBundle\EnabelUserBundle in config/bundles.php
bin/console doctrine:migrations:diff && bin/console doctrine:migrations:migrate
bin/console enabel:user:create   # or whatever the generator command is named in docs/

Then wire your security.yaml to the bundle's User entity and login form, and add the EasyAdmin dashboard entry for the CRUD controller.

If you are a Laravel developer, the honest first step is to read the bundle as a spec and not install it. The closest Laravel equivalent stack is laravel/breeze or laravel/fortify for auth, laravel/socialite for Azure SSO, and Filament or Nova for the admin CRUD. The first real use case to validate is "I need an admin-managed user table with role promotion/demotion plus Azure login" — that is what this bundle solves, and you can reproduce it in Laravel in a day or two.

Implementation Patterns

{Usage patterns, workflows, integration tips}

The three patterns worth copying regardless of framework:

1. CLI user lifecycle commands. The bundle's generate, promote, and demote commands are the cleanest part of it. Port the pattern to Laravel as php artisan user:create, user:promote {email} {role}, user:demote {email} {role}. Wrap the role mutation in a transaction and log it.
2. Self-contained auth forms. The login form and Azure SSO flow are shipped as bundle resources (Twig templates + form types), meaning you register a route and get a working screen. In Laravel the analogue is publishing Blade views from a package and registering routes in a service provider — mirror that if you want a reusable internal auth kit.
3. Admin CRUD over the User entity. The EasyAdmin controller is thin: fields, filters, role field, and a few actions. Filament's UserResource maps to this almost one-to-one, including the role field being a multi-select.

Workflow integration tips:

• Keep the framework's User entity (or Eloquent model) as the single source of truth; layer roles as a separate table or JSON column rather than editing the bundle/model directly.
• Treat the Azure SSO piece as an OAuth2 client with a provider, not as "the bundle's login". That mental model is what makes it portable to Socialite.
• If maintaining the legacy Symfony app: pin the bundle to a specific tag, commit the composer.lock, and add a composer audit gate to CI, because you will not get upstream security fixes.

Porting checklist for a Laravel rewrite: provider → Socialite driver, login form → Breeze route, EasyAdmin CRUD → Filament resource, console commands → artisan commands, role hierarchy → Gate/policies.

Gotchas and Tips

{Pitfalls, debugging, config quirks, extension points}

• Deprecated means no security patches. This is the dominating risk. Any auth bundle handling credentials and OAuth callbacks that no longer receives updates should be considered unsafe for long-lived production use. If you adopt it, budget for a migration.
• Do not try to install this in Laravel. It is a Symfony bundle: it relies on the Symfony DI container, Bundle registration in config/bundles.php, and Symfony's security firewall. Composer may resolve it, but nothing will work as expected. Read it, don't require it.
• Symfony 6.0+ and PHP constraints. The bundle targets Symfony 6.x only. On Symfony 7 you will hit dependency conflicts unless you fork and widen composer.json. Check the exact constraints before assuming compatibility with your app.
• Azure SSO config quirks: the tenant ID, client ID/secret, and redirect URI must all match the app registration exactly, including trailing slashes. Most "SSO doesn't work" reports are redirect URI mismatches. Add the callback route to security.yaml under anonymous: true or you'll get a redirect loop.
• EasyAdmin version coupling. The CRUD controllers are written against a specific EasyAdmin major. Upgrading EasyAdmin independently of the bundle will break field config. Pin both.
• Doctrine/migration surprises: the bundle ships a User entity and mapping. If your app already has a users table, you'll get schema conflicts. Configure the table name and inheritance before running doctrine:migrations:diff, not after.
• Role hierarchy confusion: the "promote/demote" commands operate on role strings that must match your security.yaml role_hierarchy. A typo silently grants nothing.
• Debugging pointers (Symfony context): bin/console debug:router | grep -i login, bin/console debug:container --tag=security.user_provider, and the profiler's security panel will resolve 90% of wiring problems.
• Extension points: override the Twig templates via templates/bundles/EnabelUserBundle/, extend the User entity via Doctrine inheritance, and hook user creation with an event subscriber rather than forking the commands.
• Fallback plan: if the app must survive more than a year, do not adopt this bundle — use knpuniversity/oauth2-client-bundle for the SSO and write your own thin user admin. The bundle's value is as a working reference, and that value does not decay with the deprecation notice.