PHPackages francescomalatesta/laravel-feature - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Utility & Helpers](/categories/utility) 4. / 5. francescomalatesta/laravel-feature ActiveLibrary[Utility & Helpers](/categories/utility) francescomalatesta/laravel-feature ================================== A simple package to manage feature flagging in a Laravel project. 3.0.0(3y ago)211206.4k↓33.3%60[2 issues](https://github.com/francescomalatesta/laravel-feature/issues)[2 PRs](https://github.com/francescomalatesta/laravel-feature/pulls)MITPHPPHP ^7.4|^8.1 Since Dec 17Pushed 3y ago11 watchersCompare [ Source](https://github.com/francescomalatesta/laravel-feature)[ Packagist](https://packagist.org/packages/francescomalatesta/laravel-feature)[ Docs](https://github.com/francescomalatesta/laravel-feature)[ RSS](/packages/francescomalatesta-laravel-feature/feed)WikiDiscussions master Synced 1mo ago READMEChangelogDependencies (7)Versions (12)Used By (0) Laravel-Feature =============== [](#laravel-feature) [![Latest Stable Version](https://camo.githubusercontent.com/3de93935588716bc44e15d29557710d939127d0633e7e36f21108dcb5d21731c/68747470733a2f2f706f7365722e707567782e6f72672f6672616e636573636f6d616c6174657374612f6c61726176656c2d666561747572652f762f737461626c65)](https://packagist.org/packages/francescomalatesta/laravel-feature)[![Build Status](https://camo.githubusercontent.com/01785065117228310aa93e767509d42695d8304df83e9b0d6a51f7636661e094/68747470733a2f2f7472617669732d63692e6f72672f6672616e636573636f6d616c6174657374612f6c61726176656c2d666561747572652e7376673f6272616e63683d6d6173746572)](https://travis-ci.org/francescomalatesta/laravel-feature)[![Code Coverage](https://camo.githubusercontent.com/a9471acd7ed179e2780105d153590cc700113e7a7797986a3fe8a3ededb286f9/68747470733a2f2f7363727574696e697a65722d63692e636f6d2f672f6672616e636573636f6d616c6174657374612f6c61726176656c2d666561747572652f6261646765732f636f7665726167652e706e673f623d6d6173746572)](https://scrutinizer-ci.com/g/francescomalatesta/laravel-feature/?branch=master)[![Scrutinizer Code Quality](https://camo.githubusercontent.com/9c09257f0d7a250767eb2cd4d4c6c7b1b910b370305ca4a8d0c5a5e0186263a4/68747470733a2f2f7363727574696e697a65722d63692e636f6d2f672f6672616e636573636f6d616c6174657374612f6c61726176656c2d666561747572652f6261646765732f7175616c6974792d73636f72652e706e673f623d6d6173746572)](https://scrutinizer-ci.com/g/francescomalatesta/laravel-feature/?branch=master)[![StyleCI](https://camo.githubusercontent.com/72318d81c4fb0005d1580a10d4eac6a07da97005bcb2a1fc01173a95f871a2bd/68747470733a2f2f7374796c6563692e696f2f7265706f732f37363731363530392f736869656c643f6272616e63683d6d6173746572)](https://styleci.io/repos/76716509) Laravel-Feature is a package fully dedicated to feature toggling in your application, in the easiest way. For Laravel, of course. It was inspired by the [AdEspresso Feature Flag Bundle](https://github.com/adespresso/FeatureBundle). Feature-What? ------------- [](#feature-what) Feature toggling is basically a way to **have full control on the activation of a feature** in your applications. Let's make a couple of examples to give you an idea: - you just finished to work on the latest feature and you want to push it, but the marketing team wants you to deploy it in a second moment; - the new killer-feature is ready, but you want to enable it only for a specific set of users; With Laravel-Feature, you can: - easily **define new features** in your application; - **enable/disable features** globally; - **enable/disable features for specific users**, or **for whatever you want**; There are many things to know about feature toggling: take a look to [this great article](http://martinfowler.com/articles/feature-toggles.html) for more info. It's a really nice and useful lecture. Install ------- [](#install) You can install Laravel-Feature with Composer. ``` $ composer require francescomalatesta/laravel-feature ``` After that, you need to **add the `FeatureServiceProvider` to the `app.php` config file**. ``` ... LaravelFeature\Provider\FeatureServiceProvider::class, ... ``` Now you have to **run migrations**, to add the tables Laravel-Feature needs. ``` $ php artisan migrate ``` ... and you're good to go! ### Facade [](#facade) If you want, you can also **add the `Feature` facade** to the `aliases` array in the `app.php` config file. ``` ... 'Feature' => \LaravelFeature\Facade\Feature::class, ... ``` If you don't like Facades, **inject the `FeatureManager`** class wherever you want! ### Config File [](#config-file) By default, you can immediately use Laravel-Feature. However, if you want to tweak some settings, feel free to **publish the config file** with ``` $ php artisan vendor:publish --provider="LaravelFeature\Provider\FeatureServiceProvider" ``` Basic Usage ----------- [](#basic-usage) There are two ways you can use features: working with them **globally** or **specifically for a specific entity**. ### Globally Enabled/Disabled Features [](#globally-enableddisabled-features) #### Declare a New Feature [](#declare-a-new-feature) Let's say you have a new feature that you want to keep hidden until a certain moment. We will call it "page\_code\_cleaner". Let's **add it to our application**: ``` Feature::add('page_code_cleaner', false); ``` Easy, huh? As you can imagine, **the first argument is the feature name**. **The second is a boolean we specify to define the current status** of the feature. - `true` stands for **the feature is enabled for everyone**; - `false` stands for **the feature is hidden, no one can use it/see it**; And that's all. #### Check if a Feature is Enabled [](#check-if-a-feature-is-enabled) Now, let's imagine a better context for our example. We're building a CMS, and our "page\_code\_cleaner" is used to... clean our HTML code. Let's assume we have a controller like this one. ``` class CMSController extends Controller { public function getPage($pageSlug) { // here we are getting our page code from some service $content = PageService::getContentBySlug($pageSlug); // here we are showing our page code return view('layout.pages', compact('content')); } } ``` Now, we want to deploy the new service, but **we don't want to make it available for users**, because the marketing team asked us to release it the next week. LaravelFeature helps us with this: ``` class CMSController extends Controller { public function getPage($pageSlug) { // here we are getting our page code from some service $content = PageService::getContentBySlug($pageSlug); // feature flagging here! if(Feature::isEnabled('page_code_cleaner')) { $content = PageCleanerService::clean($content); } // here we are showing our page code return view('layout.pages', compact('content')); } } ``` Ta-dah! Now, **the specific service code will be executed only if the "page\_code\_cleaner" feature is enabled**. #### Change a Feature Activation Status [](#change-a-feature-activation-status) Obviously, using the `Feature` class we can easily **toggle the feature activation status**. ``` // release the feature! Feature::enable('page_code_cleaner'); // hide the feature! Feature::disable('page_code_cleaner'); ``` #### Remove a Feature [](#remove-a-feature) Even if it's not so used, you can also **delete a feature** easily with ``` Feature::remove('page_code_cleaner'); ``` Warning: *be sure about what you do. If you remove a feature from the system, you will stumble upon exceptions if checks for the deleted features are still present in the codebase.* #### Work with Views [](#work-with-views) I really love blade directives, they help me writing more elegant code. I prepared **a custom blade directive, `@feature`**: ``` This is an example template div. Always visible. @feature('my_awesome_feature') This paragraph will be visible only if "my_awesome_feature" is enabled! @endfeature This is another example template div. Always visible too. ``` A really nice shortcut! ### Enable/Disable Features for Specific Users/Entities [](#enabledisable-features-for-specific-usersentities) Even if the previous things we saw are useful, LaravelFeature **is not just about pushing the on/off button on a feature**. Sometimes, business necessities require more flexibility. Think about a [**Canary Release**](http://martinfowler.com/bliki/CanaryRelease.html): we want to rollout a feature only to specific users. Or, maybe, just for one tester user. #### Enable Features Management for Specific Users [](#enable-features-management-for-specific-users) LaravelFeature makes this possible, and also easier just as **adding a trait to our `User` class**. In fact, all you need to do is to: - **add the `LaravelFeature\Featurable\Featurable` trait** to the `User` class; - let the same class **implement the `FeaturableInterface` interface**; ``` ... class User extends Authenticatable implements FeaturableInterface { use Notifiable, Featurable; ... ``` Nothing more! LaravelFeature now already knows what to do. #### Status Priority [](#status-priority) *Please keep in mind that all you're going to read from now is not valid if a feature is already enabled globally. To activate a feature for specific users, you first need to disable it.* Laravel-Feature **first checks if the feature is enabled globally, then it goes down at entity-level**. #### Enable/Disable a Feature for a Specific User [](#enabledisable-a-feature-for-a-specific-user) ``` $user = Auth::user(); // now, the feature "my.feature" is enabled ONLY for $user! Feature::enableFor('my.feature', $user); // now, the feature "my.feature" is disabled for $user! Feature::disableFor('my.feature', $user); ``` #### Check if a Feature is Enabled for a Specific User [](#check-if-a-feature-is-enabled-for-a-specific-user) ``` $user = Auth::user(); if(Feature::isEnabledFor('my.feature', $user)) { // do amazing things! } ``` #### Other Notes [](#other-notes) LaravelFeature also provides a Blade directive to check if a feature is enabled for a specific user. You can use the `@featurefor` blade tags: ``` @featurefor('my.feature', $user) // do $user related things here! @endfeaturefor ``` Advanced Things --------------- [](#advanced-things) Ok, now that we got the basics, let's raise the bar! ### Enable Features Management for Other Entities [](#enable-features-management-for-other-entities) As I told before, you can easily add features management for Users just by using the `Featurable` trait and implementing the `FeaturableInterface` in the User model. However, when structuring the relationships, I decided to implement a **many-to-many polymorphic relationship**. This means that you can **add feature management to any model**! Let's make an example: imagine that **you have a `Role` model** you use to implement a basic roles systems for your users. This because you have admins and normal users. So, **you rolled out the amazing killer feature but you want to enable it only for admins**. How to do this? Easy. Recap: - add the `Featurable` trait to the `Role` model; - be sure the `Role` model implements the `FeaturableInterface`; Let's think the role-user relationship as one-to-many one. You will probably have a `role()` method on your `User` class, right? Good. You already know the rest: ``` // $role is the admin role! $role = Auth::user()->role; ... Feature::enableFor('my.feature', $role); ... if(Feature::isEnabledFor('my.feature', $role)) { // this code will be executed only if the user is an admin! } ``` ### Scan Directories for Features [](#scan-directories-for-features) One of the nice bonuses of the package that inspired me when making this package, is the ability to **"scan" views, find `@feature` declarations and then add these scanned features if not already present** on the system. I created a simple **artisan command** to do this. ``` $ php artisan feature:scan ``` The command will use a dedicated service to **fetch the `resources/views` folder and scan every single Blade view to find `@feature` directives**. It will then output the search results. Try it, you will like it! **Note:** if you have published the config file, you will be able to **change the list of scanned directories**. ### Using a Custom Features Repository [](#using-a-custom-features-repository) Imagine that you want to **change the place or the way you store features**. For some crazy reason, you want to store it on a static file, or on Dropbox. Now, Eloquent doesn't have a Dropbox driver, so you can't use this package. **Bye.** Just joking! When making this package, I wanted to be sure to create a fully reusable logic if the developer doesn't want to use Eloquent anymore. To do this, I created a nice interface for the Job, and created some bindings in the Laravel Service Container. Nothing really complex, anyway. The interface I am talking about is `FeatureRepositoryInterface`. ```