คำถามสัมภาษณ์ PHP Laravel Framework 2026: Eloquent, Queues และ Architecture Patterns

// Eager load พร้อม constraints เพื่อหลีกเลี่ยงการโหลดข้อมูลที่ไม่จำเป็น
$users = User::query()
    ->with(['posts' => function (Builder $query) {
        $query->where('published', true)
              ->select('id', 'user_id', 'title', 'published_at');
    }])
    ->withCount('posts')
    ->paginate(25);

// ไม่ดี: ทำให้เกิด N+1 เมื่อเข้าถึง posts ใน loop
foreach ($users as $user) {
    $user->posts; // แต่ละ iteration ทำ query ไปยัง database
}

// Cursor pagination สำหรับ dataset ขนาดใหญ่
$posts = Post::query()
    ->where('status', 'published')
    ->orderBy('published_at', 'desc')
    ->cursorPaginate(50);

// Chunk processing สำหรับ batch operations
User::query()
    ->where('last_login_at', '<', now()->subYear())
    ->chunkById(1000, function (Collection $users) {
        foreach ($users as $user) {
            $user->markAsInactive();
        }
    });

class Post extends Model
{
    // Local scope สำหรับเนื้อหาที่เผยแพร่แล้ว
    public function scopePublished(Builder $query): Builder
    {
        return $query->where('status', 'published')
                     ->whereNotNull('published_at')
                     ->where('published_at', '<=', now());
    }

    // Local scope พร้อม parameter
    public function scopeByAuthor(Builder $query, int $authorId): Builder
    {
        return $query->where('author_id', $authorId);
    }

    // Scope ที่สามารถ chain ได้
    public function scopeRecent(Builder $query, int $days = 7): Builder
    {
        return $query->where('published_at', '>=', now()->subDays($days));
    }
}

// การใช้งาน: chaining multiple scopes
$recentPosts = Post::published()
    ->byAuthor($userId)
    ->recent(14)
    ->get();

class ActiveScope implements Scope
{
    public function apply(Builder $builder, Model $model): void
    {
        $builder->where('is_active', true);
    }
}

// app/Models/Subscription.php
class Subscription extends Model
{
    protected static function booted(): void
    {
        static::addGlobalScope(new ActiveScope());
    }
}

// Bypass global scope เมื่อจำเป็น
$allSubscriptions = Subscription::withoutGlobalScope(ActiveScope::class)->get();

class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public int $tries = 3;
    public int $maxExceptions = 2;
    public int $timeout = 120;
    public int $backoff = 60;

    public function __construct(
        public readonly Order $order,
        public readonly string $idempotencyKey
    ) {}

    public function handle(PaymentGateway $gateway): void
    {
        // ตรวจสอบ idempotency เพื่อป้องกันการประมวลผลซ้ำ
        if (Cache::has("payment_processed:{$this->idempotencyKey}")) {
            return;
        }

        $result = $gateway->charge(
            $this->order->total,
            $this->order->payment_method_id
        );

        $this->order->update([
            'payment_status' => $result->status,
            'payment_id' => $result->id,
        ]);

        Cache::put(
            "payment_processed:{$this->idempotencyKey}",
            true,
            now()->addDays(7)
        );
    }

    public function failed(Throwable $exception): void
    {
        Log::error('Payment processing failed', [
            'order_id' => $this->order->id,
            'error' => $exception->getMessage(),
        ]);

        $this->order->update(['payment_status' => 'failed']);
        
        Notification::route('slack', config('services.slack.payments_channel'))
            ->notify(new PaymentFailedNotification($this->order, $exception));
    }

    public function retryUntil(): DateTime
    {
        return now()->addHours(6);
    }
}

// Dispatch batch of jobs
$batch = Bus::batch([
    new ProcessPodcastEpisode($episode1),
    new ProcessPodcastEpisode($episode2),
    new ProcessPodcastEpisode($episode3),
])
->then(function (Batch $batch) {
    Log::info('All episodes processed successfully');
})
->catch(function (Batch $batch, Throwable $e) {
    Log::error('Batch processing failed', ['error' => $e->getMessage()]);
})
->finally(function (Batch $batch) {
    // Cleanup resources
})
->allowFailures()
->dispatch();

// Monitor batch progress
$progress = Bus::findBatch($batch->id);
echo $progress->progress(); // Percentage complete
echo $progress->failedJobs; // Count of failed jobs

// Job chain สำหรับ multi-step workflow
Bus::chain([
    new ValidateOrder($order),
    new ProcessPayment($order),
    new SendConfirmationEmail($order),
    new UpdateInventory($order),
])->dispatch();

class PaymentServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Singleton: instance เดียวกันตลอด request
        $this->app->singleton(PaymentGateway::class, function ($app) {
            return new StripeGateway(
                config('services.stripe.secret'),
                $app->make(HttpClient::class)
            );
        });

        // Binding interface กับ implementation
        $this->app->bind(
            PaymentProcessorInterface::class,
            StripePaymentProcessor::class
        );

        // Contextual binding: implementation ที่แตกต่างกันตาม consumer
        $this->app->when(SubscriptionController::class)
            ->needs(PaymentProcessorInterface::class)
            ->give(RecurringPaymentProcessor::class);

        $this->app->when(CheckoutController::class)
            ->needs(PaymentProcessorInterface::class)
            ->give(OneTimePaymentProcessor::class);
    }
}

interface UserRepositoryInterface
{
    public function findById(int $id): ?User;
    public function findByEmail(string $email): ?User;
    public function createWithProfile(array $userData, array $profileData): User;
    public function getActiveWithSubscriptions(): Collection;
}

// app/Repositories/EloquentUserRepository.php
class EloquentUserRepository implements UserRepositoryInterface
{
    public function __construct(
        private readonly User $model
    ) {}

    public function findById(int $id): ?User
    {
        return $this->model->find($id);
    }

    public function findByEmail(string $email): ?User
    {
        return $this->model->where('email', $email)->first();
    }

    public function createWithProfile(array $userData, array $profileData): User
    {
        return DB::transaction(function () use ($userData, $profileData) {
            $user = $this->model->create($userData);
            $user->profile()->create($profileData);
            return $user->load('profile');
        });
    }

    public function getActiveWithSubscriptions(): Collection
    {
        return $this->model
            ->where('status', 'active')
            ->with(['subscriptions' => fn($q) => $q->active()])
            ->get();
    }
}

class UserRegistrationService
{
    public function __construct(
        private readonly UserRepositoryInterface $userRepository,
        private readonly NotificationService $notificationService,
        private readonly EventDispatcher $events
    ) {}

    public function register(RegisterUserDTO $dto): User
    {
        $user = $this->userRepository->createWithProfile(
            $dto->toUserArray(),
            $dto->toProfileArray()
        );

        $this->notificationService->sendWelcomeEmail($user);
        $this->events->dispatch(new UserRegistered($user));

        return $user;
    }
}

class OrderPlaced implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public function __construct(
        public readonly Order $order
    ) {}

    public function broadcastOn(): array
    {
        return [
            new PrivateChannel('orders.' . $this->order->user_id),
        ];
    }
}

// app/Listeners/SendOrderConfirmation.php
class SendOrderConfirmation implements ShouldQueue
{
    public function handle(OrderPlaced $event): void
    {
        Mail::to($event->order->user)
            ->send(new OrderConfirmationMail($event->order));
    }

    public function shouldQueue(OrderPlaced $event): bool
    {
        return $event->order->total > 0;
    }
}

// app/Providers/EventServiceProvider.php
protected $listen = [
    OrderPlaced::class => [
        SendOrderConfirmation::class,
        UpdateInventory::class,
        NotifyWarehouse::class,
        RecordAnalytics::class,
    ],
];

class OrderObserver
{
    public function created(Order $order): void
    {
        $order->generateOrderNumber();
        Cache::tags(['orders', "user:{$order->user_id}"])->flush();
    }

    public function updated(Order $order): void
    {
        if ($order->wasChanged('status')) {
            event(new OrderStatusChanged($order));
        }
    }

    public function deleted(Order $order): void
    {
        $order->lineItems()->delete();
        Storage::delete($order->attachments);
    }
}

class OrderControllerTest extends TestCase
{
    use RefreshDatabase;

    public function test_user_can_place_order(): void
    {
        $user = User::factory()->create();
        $product = Product::factory()->create(['price' => 5000]);

        $this->actingAs($user)
            ->postJson('/api/orders', [
                'items' => [
                    ['product_id' => $product->id, 'quantity' => 2]
                ],
                'shipping_address_id' => $user->addresses()->first()->id,
            ])
            ->assertCreated()
            ->assertJsonStructure([
                'data' => ['id', 'total', 'status', 'items']
            ]);

        $this->assertDatabaseHas('orders', [
            'user_id' => $user->id,
            'total' => 10000,
        ]);
    }

    public function test_payment_failure_does_not_create_order(): void
    {
        $this->mock(PaymentGateway::class, function ($mock) {
            $mock->shouldReceive('charge')
                ->once()
                ->andThrow(new PaymentFailedException('Card declined'));
        });

        $user = User::factory()->create();

        $this->actingAs($user)
            ->postJson('/api/orders', $this->validOrderData())
            ->assertStatus(422)
            ->assertJsonPath('message', 'Payment failed: Card declined');

        $this->assertDatabaseMissing('orders', ['user_id' => $user->id]);
    }
}

class EnsureTeamAccess
{
    public function handle(Request $request, Closure $next, string $permission): Response
    {
        $team = $request->route('team');
        $user = $request->user();

        if (!$user->belongsToTeam($team)) {
            abort(403, 'You are not a member of this team');
        }

        if (!$user->hasTeamPermission($team, $permission)) {
            abort(403, "Missing permission: {$permission}");
        }

        return $next($request);
    }
}

// routes/web.php
Route::middleware(['auth', 'team.access:manage-projects'])
    ->prefix('teams/{team}')
    ->group(function () {
        Route::resource('projects', ProjectController::class);
    });