What do you think about the following service to search for settings by group?

[serious-angel]

Dear Developers,

Thank you for the marvel!

---

I've been figuring out how to achieve a relatively universal controller to get settings by name (e.g. settings group), and what do you think about the following approach for, at least, obtaining the settings?:

Implementation

Settings Service

namespace App\Services\Settings;

use InvalidArgumentException;
use LogicException;
use Spatie\LaravelSettings\Exceptions\SettingDoesNotExist;
use Spatie\LaravelSettings\Settings;
use Spatie\LaravelSettings\SettingsContainer;

class SettingsService
{
    protected $settings;

    public function __construct()
    {
        $this->settings = app(SettingsContainer::class);
    }

    /**
     * @throws \Spatie\LaravelSettings\Exceptions\SettingDoesNotExist
     */
    public function getSettingsClass(string $group, ?string $property = null): string
    {
        $settingClasses = $this->settings->getSettingClasses();

        // @note As of 2025-07, Laravel Settings may have multiple classes with the same group, though it's discouraged.
        // @see https://github.com/spatie/laravel-settings/blob/04bf89e1dd29269bab735dfd33f16da1462023b1/README.md#usage

        $groupSettingClasses = $settingClasses->where(fn ($s) => $s::group() === $group);

        // $groupSettingClasses = $settingClasses->where('group', $group);

        if ($groupSettingClasses->isEmpty()) {
            throw new SettingDoesNotExist(sprintf('Setting class with group \'%s\' not found.', $group));
        }

        if ($groupSettingClasses->count() === 1) {
            return $groupSettingClasses->first();
        }

        if (empty($property)) {
            throw new InvalidArgumentException(sprintf(
                'Multiple settings found for group \'%s\', but no property is specified for the search.',
                $group
            ));
        }

        $settings = $groupSettingClasses->where(fn ($s) => property_exists($s, $property));

        if ($settings->isEmpty()) {
            throw new SettingDoesNotExist(sprintf(
                'Setting class with group \'%s\' and property \'%s\' not found.',
                $group,
                $property
            ));
        }

        if ($settings->count() > 1) {
            throw new LogicException(sprintf(
                'Too many setting classes found with group \'%s\' and property \'%s\'.',
                $group,
                $property
            ));
        }

        return $settings->first();
    }

    /**
     * @throws \Spatie\LaravelSettings\Exceptions\SettingDoesNotExist
     */
    public function getSettings(string $group, ?string $property = null): Settings
    {
        $settingsClass = $this->getSettingsClass($group, $property);

        return app($settingsClass);
    }
}

Route

Route::middleware(['web', 'admin'])
    ->resource('settings', SettingsController::class)
    ->only(['show'])
    ->names([
        'show' => 'admin.settings.show',
        // 'update' => 'admin.settings.update',
        // 'destroy' => 'admin.settings.destroy',
    ]);

Settings Controller

namespace App\Http\Controllers\Settings;

use App\Http\Controllers\Controller;
use App\Http\Requests\Settings\SettingsShowRequest;
use App\Http\Requests\Settings\SettingsUpdateRequest;
use App\Services\Settings\SettingsService;
use Illuminate\Http\JsonResponse;
use Spatie\LaravelSettings\Exceptions\SettingDoesNotExist;
use Symfony\Component\HttpFoundation\Response;

class SettingsController extends Controller
{
    public function show(SettingsShowRequest $request, string $setting): JsonResponse
    {
        // If required, from the custom request.
        // $setting = $request->get('setting');

        try {
            // Let's not support properties but groups only, at least, currently.
            $settings = app(SettingsService::class)->getSettings($setting);
        } catch (SettingDoesNotExist) {
            return response()->json([], Response::HTTP_NOT_FOUND);
        }

        return response()->json($settings);
    }

    // public function update()
    // public function destroy()
}

Settings "Show" Request

namespace App\Http\Requests\Settings;

use Illuminate\Contracts\Validation\Validator;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Http\Exceptions\HttpResponseException;
use Symfony\Component\HttpFoundation\Response;

class SettingsShowRequest extends FormRequest
{
    protected $stopOnFirstFailure = true;

    public function rules(): array
    {
        return [
            'setting' => [
                'bail',
                'required',
                'string',
                'min:1',
            ],
        ];
    }

    public function authorize(): bool
    {
        return auth()->user()?->isAdmin() === true;
    }

    protected function prepareForValidation()
    {
        $this->merge(['setting' => $this->route('setting')]);
    }

    protected function failedValidation(Validator $validator): void
    {
        throw new HttpResponseException(response()->json($validator->errors(), Response::HTTP_BAD_REQUEST));
    }
}

Test

Based on the current Readme setting example of setting in group "general".

$ curl -- 'https://example.local/admin/settings/general';
{
    "site_name": "Spatie",
    "site_active": true
}

The main idea is to not create a separate controller and request classes for each settings group.
Would you find the approach adequate enough?

---

Best and kind regards