In Laravel, managing application settings dynamically allows you to create flexible and easily configurable applications. Imagine storing settings such as the application’s timezone, notification preferences, or API rate limits in a database, making them adjustable without touching the code. This tutorial will guide you through setting up a system to dynamically manage application settings in Laravel.


Scenario: Dynamic Application Settings

For this tutorial, we will create a settings system to manage:

  • Application Timezone: Configure the app’s timezone dynamically.
  • Notification Preferences: Enable or disable notifications.
  • API Rate Limit: Define the maximum number of API requests allowed per minute.

These settings will be stored in a database, retrieved efficiently, and made accessible throughout the application.


Step 1: Create a Settings Table and Model

Start by creating a database table to store your application settings.

  1. Generate the Migration:

   php artisan make:migration create_settings_table --create=settings
  1. Define the Schema:

Open the generated migration file in database/migrations and define the schema:


   use Illuminate\Database\Migrations\Migration;
   use Illuminate\Database\Schema\Blueprint;
   use Illuminate\Support\Facades\Schema;

   class CreateSettingsTable extends Migration
   {
       public function up()
       {
           Schema::create('settings', function (Blueprint $table) {
               $table->id();
               $table->string('key')->unique();
               $table->string('value')->nullable();
               $table->timestamps();
           });
       }

       public function down()
       {
           Schema::dropIfExists('settings');
       }
   }
  1. Run the Migration:

   php artisan migrate
  1. Create the Model:

   php artisan make:model Setting

Define the model in app/Models/Setting.php:


   namespace App\Models;

   use Illuminate\Database\Eloquent\Model;

   class Setting extends Model
   {
       protected $fillable = ['key', 'value'];
   }

Step 2: Seed the Database with Default Settings

Add some initial settings for testing.

  1. Create a Seeder:

   php artisan make:seeder SettingsSeeder
  1. Define Default Settings:

Open the generated file in database/seeders and populate the settings table:


   namespace Database\Seeders;

   use Illuminate\Database\Seeder;
   use Illuminate\Support\Facades\DB;

   class SettingsSeeder extends Seeder
   {
       public function run()
       {
           DB::table('settings')->insert([
               ['key' => 'timezone', 'value' => 'UTC'],
               ['key' => 'notifications_enabled', 'value' => 'true'],
               ['key' => 'api_rate_limit', 'value' => '100'],
           ]);
       }
   }
  1. Run the Seeder:

   php artisan db:seed --class=SettingsSeeder

Step 3: Create a Helper Function for Retrieving Settings

To easily fetch settings, create a helper function.

  1. Add a Helper File:

Create app/Helpers/helpers.php (if it doesn’t already exist). Add this to your composer.json file:


   "autoload": {
       "files": [
           "app/Helpers/helpers.php"
       ]
   }

Run composer dump-autoload after adding the file.

  1. Define the Helper Function:

Add this code to helpers.php:


   use Illuminate\Support\Facades\Cache;

   if (!function_exists('getSetting')) {
       function getSetting($key, $default = null)
       {
           return Cache::rememberForever("setting_{$key}", function () use ($key, $default) {
               $setting = \App\Models\Setting::where('key', $key)->first();
               return $setting ? $setting->value : $default;
           });
       }
   }

This helper:

  • Caches settings to reduce database queries.
  • Returns the default value if the setting doesn’t exist.

Step 4: Use Settings in Your Application

Now you can use the getSetting helper to dynamically adjust application behavior.

  1. Set the Timezone Dynamically:

In AppServiceProvider, set the application timezone:


   namespace App\Providers;

   use Illuminate\Support\ServiceProvider;

   class AppServiceProvider extends ServiceProvider
   {
       public function boot()
       {
           config(['app.timezone' => getSetting('timezone', 'UTC')]);
       }
   }
  1. Toggle Notifications:

Use the notifications_enabled setting to control notification behavior:


   if (getSetting('notifications_enabled', 'false') === 'true') {
       // Send notifications
   }
  1. Dynamic API Rate Limit:

Adjust middleware behavior based on the api_rate_limit setting:


   namespace App\Http\Middleware;

   use Closure;

   class RateLimitMiddleware
   {
       public function handle($request, Closure $next)
       {
           $rateLimit = getSetting('api_rate_limit', 60);
           // Apply the rate limit logic here
           return $next($request);
       }
   }

Step 5: Add an Admin Interface for Settings

Allow admins to edit settings from a web interface.

  1. Create a Settings Controller:

   php artisan make:controller Admin/SettingsController
  1. Define Edit and Update Methods:

In SettingsController, add methods to edit and update settings:


   namespace App\Http\Controllers\Admin;

   use App\Models\Setting;
   use Illuminate\Http\Request;

   class SettingsController extends Controller
   {
       public function edit()
       {
           $settings = Setting::all();
           return view('admin.settings.edit', compact('settings'));
       }

       public function update(Request $request)
       {
           foreach ($request->settings as $key => $value) {
               Setting::updateOrCreate(['key' => $key], ['value' => $value]);
           }

           return redirect()->back()->with('success', 'Settings updated successfully.');
       }
   }
  1. Create the Blade View:

Create resources/views/admin/settings/edit.blade.php:


   
@csrf @method('PUT') @foreach ($settings as $setting)
@endforeach

Conclusion

You now have a system for dynamically managing application settings in Laravel. These settings are stored in the database, efficiently retrieved using a helper, and editable through an admin interface. With this approach, you can build highly configurable applications without hardcoding settings.