DEV Community: David Chamling Rai

Laravel Settings Caching Done Right – With Service Layer and Auto Re-Caching

David Chamling Rai — Thu, 26 Jun 2025 16:29:11 +0000

In many Laravel apps, especially admin dashboards or multi-tenant platforms, you often fetch settings like tax_percentage, facebook_link, support_email, etc., directly from the database — again and again.

This guide shows you how to:

Cache these settings for faster performance
Access them easily via a clean service
Automatically update the cache when settings change

Let’s keep it simple and practical — no nested arrays, no JSON decoding.

Step 1: Create the Settings Table

Schema::create('settings', function (Blueprint $table) {
    $table->id();
    $table->string('key')->unique();
    $table->text('value')->nullable();
    $table->timestamps();
});

Sample Data

key	value
`tax_percentage`	`13`
`facebook_link`	`https://fb.com/myapp`
`support_email`	`support@example.com`

Step 2: Build a Simple Settings Service

We’ll use a service class to manage caching and access so we don’t repeat ourselves or hardcode cache logic.

php artisan make:service SettingService

`app/Services/SettingService.php`

namespace App\Services;

use Illuminate\Support\Facades\Cache;
use App\Models\Setting;

class SettingService
{
    protected static string $cacheKey = 'app_settings';

    public static function all(): array
    {
        return Cache::rememberForever(self::$cacheKey, function () {
            return Setting::all()->pluck('value', 'key')->toArray();
        });
    }

    public static function get(string $key, $default = null)
    {
        return self::all()[$key] ?? $default;
    }

    public static function recache(): void
    {
        $settings = Setting::all()->pluck('value', 'key')->toArray();
        Cache::forever(self::$cacheKey, $settings);
    }
}

⚠️ A Note for Large-Scale Projects

In smaller to mid-sized applications, caching all settings at once is convenient and fast.

But in large projects with a high volume of settings — for example, tenant-specific or modular settings — caching the entire settings table might be unnecessary or inefficient.

👉 In such cases, consider fetching and caching individual or grouped settings using dynamic cache keys.

🧪 Step 3: Use the Service in Your App

Anywhere in your app:

use App\Services\SettingService;

$tax = SettingService::get('tax_percentage'); // "13"
$facebook = SettingService::get('facebook_link'); // "https://fb.com/myapp"

// or
$settings = SettingService::all();
$tax = $settings->tax_percentage;
$facebook = $settings->facebook_link;

No need to touch the cache directly. It’s all handled through one clean service.

🔁 Step 4: Manual Re-caching in Controller (Not Recommended)

public function update(Request $request)
{
  // validate request
  // update setting
    Setting::updateOrCreate(
        ['key' => 'tax_percentage'],
        ['value' => $request->input('tax_percentage')]
    );

    // Manually update the cache
    \App\Services\SettingService::recache();

    return response()->json(['message' => 'Setting updated successfully.']);
}

Problem: If you update settings in multiple places (controllers, seeders, etc.), you’ll have to remember to call recache() every time. That’s easy to forget.

Step 5: Auto Re-cache with Model Observer (Recommended)

5.1: Create the Observer

php artisan make:observer SettingObserver --model=Setting

`app/Observers/SettingObserver.php`

namespace App\Observers;

use App\Models\Setting;
use App\Services\SettingService;

class SettingObserver
{
    public function saved(Setting $setting): void
    {
        SettingService::recache();
    }

    public function deleted(Setting $setting): void
    {
        SettingService::recache();
    }
}

5.2: Register the Observer

In AppServiceProvider.php:

use App\Models\Setting;
use App\Observers\SettingObserver;

public function boot(): void
{
    Setting::observe(SettingObserver::class);
}

✅ Now, every time a setting is created, updated, or deleted, the cache updates automatically.

✅ Final Thoughts

With this setup:

✅ Settings are cached for fast access
✅ Logic is centralized in a clean service
✅ You never need to worry about stale cache again

Simple, scalable, and production-ready.

🎁 Bonus: Add a Global Helper

If you prefer calling setting('tax_percentage') instead of using the service class directly:

if (!function_exists('setting')) {
    function setting(string $key = null, $default = null)
    {
        return $key
            ? \App\Services\SettingService::get($key, $default)
            : \App\Services\SettingService::all();
    }
}

Now you can use:

setting('facebook_link');

Clean and intuitive.

🙌 Did this help you?

If you found this guide helpful, please consider:

⭐ Sharing it with your dev circle or community
🐦 Following me for more practical Laravel and JavaScript tips
💬 Commenting below if you have questions or improvements

Thanks for reading! 👋

Building a Complete Blog API with Laravel API CRUD Generator

David Chamling Rai — Wed, 28 May 2025 07:55:44 +0000

🚀 Quickly build feature-rich, production-ready Laravel APIs with clean architecture using the Laravel API CRUD Generator.

This tutorial walks you through building a complete Blog API using the https://github.com/wadangkaa/laravel-api-crud. You’ll learn how to scaffold models, controllers, requests, services, resources, and routes in minutes — all following Laravel best practices.

We’ll cover:

Installation & Setup
Request validation
Route generation
Search and filtering
Lifecycle hooks

Whether you’re a beginner or an experienced Laravel developer, this guide will help you rapidly prototype and scale your APIs with confidence.

Prerequisites:

PHP 8.0+
Composer
Laravel 9 or higher
Basic Laravel knowledge

Step 1: Create a New Laravel Project

laravel new blog-api
cd blog-api

Step 2: Install Laravel API CRUD Generator

composer require david-chamling/laravel-api-crud

Step 3: Generate Blog Post CRUD

php artisan make:crud Post

This generates:

Post model
PostController
Store/Update PostRequests
Post resources
PostCrudService
Post migration

Step 4: Configure the Post Model
Update app/Models/Post.php:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = [
        'title',
        'content',
        'status',
        'published_at'
    ];

    protected $casts = [
        'published_at' => 'datetime',
  ];
}

Step 5: Set Up Database Migration
Update the generated post migration:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->string('status')->default('draft');
    $table->timestamp('published_at')->nullable();
    $table->timestamps();
});

Run migrations:

php artisan migrate

Step 6: Configure Requests
Update app/Http/Requests/Post/StorePostRequest.php:

public function rules(): array
{
    return [
        'title' => 'required|string|max:255',
        'content' => 'required|string',
        'status' => 'required|in:draft,published,archived',
        'published_at' => 'nullable|date'
    ];
}

Update UpdatePostRequest.php:

public function rules(): array
{
    return [
        'title' => 'sometimes|string|max:255',
        'content' => 'sometimes|string',
        'status' => 'sometimes|in:draft,published,archived',
        'published_at' => 'nullable|date'
    ];
}

Step 7: Set Up API Routes
In routes/api.php:

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\PostController;

Route::crudResource('post', PostController::class);

Run artisan route list comment to check newly created routes

php artisan route:list

Step 8: Testing CRUD Operations

Create Post

POST /api/post
Content-Type: application/json
{
"title": "My First Post",
"content": "This is the content",
"status": "draft"
}

Get All Posts

GET /api/post

Get Single Post

GET /api/post/1

Update Post

PUT /api/post/1
Content-Type: application/json
{
"status": "published"
}

Delete Post

DELETE /api/post/1

Step 9: Adding Search Functionality
Update app/Http/Controllers/PostController.php:

protected array $searchableColumns = ['title'];
protected array $searchableRelations = [
  'author' => ['name'], // Search author via name (author relation required)
];
protected int $paginationNumber = 15;

Search Functionality Examples

The CRUD controller provides powerful search capabilities out of the box. Here are comprehensive examples:

Basic Search Syntax

GET /api/post?search={keyword}
GET /api/post?filter[{field}]={value}
GET /api/post?sort_by={field}&sort_order={asc|desc}
GET /api/post?per_page={number}

Complete Example with Parameters

GET /api/post?
    search=Laravel&
    filter[status]=published&
    filter[category.id]=5&
    sort_by=created_at&
    sort_order=desc&
    per_page=15

Step 10: Implementing Lifecycle Hooks (Optional)
Update app/Services/Crud/PostCrudService.php:

public function beforeStore(array $data): array
{
    $data['slug'] = \Str::slug($data['title']); //if you add slug field
    return $data;
}
public function afterStore(Model $model): void
{
    \Log::info("New post created: {$model->title}");
}

Conclusion

We’ve built a complete blog API with:

CRUD operations
Search and filtering
Optional lifecycle hooks

The Laravel API CRUD Generator package makes API development faster while maintaining clean code.

Key features used:

Automatic route generation
Built-in search capabilities
Customizable validation
Flexible resource transformation

For more advanced usage, check the GitHub: https://github.com/wadangkaa/laravel-api-crud