Service Layer pattern — where business logic lives

<?php
declare(strict_types=1);

// app/Services/UserRegistrationService.php
namespace App\Services;

use App\Events\UserRegistered;
use App\Exceptions\EmailAlreadyTakenException;
use App\Models\User;
use App\Notifications\WelcomeNotification;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;

// A service encapsulates a use case. All steps are coordinated here.
// It is injected — never instantiated with `new` in caller code.
final class UserRegistrationService
{
    public function __construct(
        private readonly EmailVerificationService $emailVerification,
    ) {}

    public function register(
        string $name,
        string $email,
        string $password,
    ): User {
        // 1. Guard against duplicates — this is a business rule, not a DB constraint check
        if (User::where('email', $email)->exists()) {
            throw new EmailAlreadyTakenException($email);
        }

        // 2. Wrap multi-step side-effects in a transaction
        $user = DB::transaction(function () use ($name, $email, $password) {
            $user = User::create([
                'name'     => $name,
                'email'    => $email,
                'password' => Hash::make($password),
            ]);

            // Coordination: call other services, fire events
            $this->emailVerification->sendVerificationEmail($user);

            return $user;
        });

        // Events after transaction — if the DB commit fails, the event is not dispatched
        event(new UserRegistered($user));
        $user->notify(new WelcomeNotification());

        return $user;
    }
}

// app/Http/Controllers/Auth/RegisterController.php
// Controller is now 100% HTTP plumbing — no business logic
namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Http\Requests\RegisterRequest;
use App\Services\UserRegistrationService;
use Illuminate\Http\JsonResponse;

class RegisterController extends Controller
{
    public function __construct(
        private readonly UserRegistrationService $registration,
    ) {}

    public function __invoke(RegisterRequest $request): JsonResponse
    {
        try {
            $user = $this->registration->register(
                name: $request->validated('name'),
                email: $request->validated('email'),
                password: $request->validated('password'),
            );
        } catch (\App\Exceptions\EmailAlreadyTakenException $e) {
            return response()->json(['message' => $e->getMessage()], 422);
        }

        return response()->json(['user' => $user], 201);
    }
}

// tests/Unit/Services/UserRegistrationServiceTest.php
// Service is testable without an HTTP request
namespace Tests\Unit\Services;

use App\Exceptions\EmailAlreadyTakenException;
use App\Models\User;
use App\Services\EmailVerificationService;
use App\Services\UserRegistrationService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Mockery;
use Tests\TestCase;

class UserRegistrationServiceTest extends TestCase
{
    use RefreshDatabase;

    public function test_registers_user_and_dispatches_event(): void
    {
        $this->expectsEvents(\App\Events\UserRegistered::class);

        $verifier = Mockery::mock(EmailVerificationService::class);
        $verifier->shouldReceive('sendVerificationEmail')->once();

        $service = new UserRegistrationService($verifier);
        $user = $service->register('Alice', 'alice@example.com', 'secret');

        $this->assertDatabaseHas('users', ['email' => 'alice@example.com']);
        $this->assertSame('Alice', $user->name);
    }

    public function test_throws_when_email_already_taken(): void
    {
        User::factory()->create(['email' => 'taken@example.com']);

        $this->expectException(EmailAlreadyTakenException::class);

        $verifier = Mockery::mock(EmailVerificationService::class);
        $service = new UserRegistrationService($verifier);
        $service->register('Bob', 'taken@example.com', 'secret');
    }
}