Simplifying Database Access in Controllers

@Tray2 I prefer to use a service to handle everything in the controller, so I can keep it as lean as possible. For validation, as you demonstrated above, I like to use the FormRequest class since that's its intended purpose. However, when working with services, is it standard practice to pass the request object—such as $request->validated()—and handle it within a service method? Also, I’m curious: can a service contain multiple methods, or should it follow the action pattern, where each service has only one method that performs a specific task?

@minaremonshaker It's your service class, you may do as you please with it.

Take this service class for example. this is the one used in the example above.

class ForeignKeyService
{
    public function getGenreId(string $genreName, string $mediaType): int
    {
        return Genre::firstOrCreate(
            ['name' => $genreName],
            ['media_type_id' => MediaType::query()
                ->where('name', $mediaType)
                ->value('id'),
            ])
            ->value('id');
    }

    public function getFormatId(string $formatName, string $mediaType): int
    {
        return Format::firstOrCreate(
            ['name' => $formatName],
            ['media_type_id' => MediaType::query()
                ->where('name', $mediaType)
                ->value('id'),
            ])
            ->value('id');
    }

    public function getSeriesId(string $seriesName): int
    {
        return Series::firstOrCreate([
            'name' => $seriesName,
        ])->value('id');
    }

    public function getPublisherId(string $publisherName): int
    {
        return Publisher::firstOrCreate([
            'name' => $publisherName,
        ])->value('id');
    }

    public function getAuthorIds(array $authors): array
    {
        $authorIds = [];

        foreach ($authors as $author) {
            [$lastName, $firstName] = explode(', ', $author);
            $authorIds[] = Author::firstOrCreate(
                ['last_name' => $lastName],
                ['first_name' => $firstName]
            )->value('id');
        }

        return $authorIds;
    }

    public function getArtistId(string $artist): int
    {
        return Artist::firstOrCreate([
            'name' => $artist,
        ])->value('id');
    }

    public function getCountryId(string $countryName): int
    {
        return Country::firstOrCreate([
            'name' => $countryName,
        ])->value('id');
    }

    public function getRecordLabelId(string $recordLabelName): int
    {
        return RecordLabel::firstOrCreate([
            'name' => $recordLabelName,
        ])->value('id');
    }

    public function getPlatformId(string $platformName): int
    {
        return Platform::firstOrCreate([
            'name' => $platformName,
        ])->value('id');
    }

    public function getActorIds(array $actors): array
    {
        $actorIds = [];

        foreach ($actors as $actor) {
            [$firstName, $lastName] = explode(' ', $actor);
            $actorIds[] = Actor::firstOrCreate(
                ['last_name' => $lastName],
                ['first_name' => $firstName]
            )->value('id');
        }

        return $actorIds;
    }
}

Here I made the decision to keep all of them in the same service class, they each do the same thing, but with different models, which in my case makes sense to keep in a single class. The main reason for this, is to be able to get the first record matching the given data, and if it doesn't exist, it creates the record and returns the id.

@minaremonshaker Replace the FormRequest with a DTO (using the Spatie LaravelData package) and a lot of goodness is encapsulated in a single place.

You can add the validation rules to the DTO, you then have a nice object to be able to pass around your application, and in your case (as is also often mine too), a nicely-typed, validated object to pass to the service/action to process as you wish.

eg:

// AController.php
public function update(Model $model, MyData $data, Store $store)
{
	try {
		$result = $store(model: $model, data: $data);
	} catch (AnException $exception) {
		// Handle exception...
	}

	return new JsonResponse($result);
}

// MyData.php
public function __construct(
	#[MapName('a_field')
	#[StringType, Min(3), Max(32)]
	public readonly string $aField,
	#[MapName('a_number')
	#[Min(0)]
	public readonly int $aNumber,
}

@Snapey I agree with this. KISS is the best pattern when possible.

@Tray2 where should I read about this pattern ,can you guide me please ,thank you in advance

@minaremonshaker KISS stands for Keep It Simple Stupid, and it's not really a pattern, it's more of tool, that you should apply to all situations.

What is the easiest solution to creating a store method in a controller? You need to do three things most of the time.

1. Validate the user input.
2. Store the validated data.
3. Redirect to somewhere.

Now, the controller's job is to talk to the model, and redirect to the view. The validation on the other hand isn't really the controller's job, and we know that unless we are working at Twitter, that we need to be able to update the data as well, and when we do that, we'll need to validate the data once more.

So the Validation we can extract to a FormRequest class, which we then inject.

public function store(BookRequest $request)
{
}

public function update(BookRequest $request)
{
}

When it comes to storing the data, we need to ask ourselves, will I insert Books in any other way then through this controller? The answer is most likely no, I won't.

Then there is no real reason to extract the insert/create from the controller, unless you are not allowed to use the ORM provided by Laravel, or you are not using a framework at all. In that case I would move the database talk into the model, which is it's responsibility.

However, most of the time you don't need to overthink it.

public function(BookRequest $request)
{
	Book::create($request->validated());
} 

That line of code is in my opinion as clean as it gets, I use the eloquent in the controller directly, rather than injecting the model and then call store method on that.