Query scopes in Laravel - Mini Project: Build & Apply

Using Query Scopes in Laravel

📖 Scenario: You are building a Laravel application to manage a list of books in a library. You want to easily filter books that are published and those that are popular.

🎯 Goal: Create a Laravel Eloquent model with query scopes to filter published books and popular books. Then use these scopes to get filtered lists.

📋 What You'll Learn

Create a Book model with a published boolean field and a popularity integer field.

Add a query scope called scopePublished to filter books where published is true.

Add a query scope called scopePopular to filter books where popularity is greater than 100.

Use the query scopes to get all published books and all popular books.

💡 Why This Matters

🌍 Real World

Query scopes are used in Laravel applications to keep database queries clean and reusable, especially when filtering data based on common conditions like status or popularity.

💼 Career

Understanding query scopes is important for Laravel developers to write maintainable and efficient database queries in real-world projects.

1

Create the Book model with fields

Create a Laravel Eloquent model class called Book with public properties published and popularity. Initialize published to true and popularity to 120 inside the constructor.

Laravel

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Book extends Model
{
    // Create public properties published and popularity
    // Your code here
}

Hint

Define public properties published and popularity in the Book class. Set their values in the constructor.

2

Add the published query scope

Add a public method called scopePublished to the Book model. It should accept a $query parameter and return the query filtered where published is true using where('published', true).

Laravel

published = true;
        $this->popularity = 120;
    }

    // Add scopePublished method here
    // Your code here
}

Hint

Define scopePublished method that filters the query where published is true.

3

Add the popular query scope

Add a public method called scopePopular to the Book model. It should accept a $query parameter and return the query filtered where popularity is greater than 100 using where('popularity', '>', 100).

Laravel

published = true;
        $this->popularity = 120;
    }

    public function scopePublished($query)
    {
        return $query->where('published', true);
    }

    // Add scopePopular method here
    // Your code here
}

Hint

Define scopePopular method that filters the query where popularity is greater than 100.

4

Use the query scopes to get filtered books

Write two lines of code to get all published books using Book::published()->get() and all popular books using Book::popular()->get(). Assign the results to variables $publishedBooks and $popularBooks respectively.

Laravel

published = true;
        $this->popularity = 120;
    }

    public function scopePublished($query)
    {
        return $query->where('published', true);
    }

    public function scopePopular($query)
    {
        return $query->where('popularity', '>', 100);
    }
}

// Get all published books and popular books
// Your code here

Hint

Use the query scopes by calling Book::published()->get() and Book::popular()->get(). Assign results to $publishedBooks and $popularBooks.

Practice

1. What is the main purpose of using query scopes in a Laravel model?

easy

A. To create database migrations

B. To define database table relationships

C. To handle user authentication

D. To reuse common query filters easily across different queries

Solution

1. Step 1: Understand query scopes role

   Query scopes allow you to write common query parts once and reuse them easily.

2. Step 2: Compare with other options

   Defining relationships, migrations, or authentication are unrelated to query scopes.

3. Final Answer:

   To reuse common query filters easily across different queries -> Option D

4. Quick Check:

   Query scopes = reusable query filters [OK]

Hint: Query scopes = reusable query parts in models [OK]

Common Mistakes:

• Confusing scopes with relationships
• Thinking scopes create migrations
• Mixing scopes with authentication logic

2. Which of the following is the correct way to define a query scope named active in a Laravel model?

easy

A. public function scopeActive($query) { return $query->where('status', 'active'); }

B. public function scopeActive() { return $this->where('status', 'active'); }

C. public function scope_active($query) { return $query->where('status', 'active'); }

D. public function active() { return $this->where('status', 'active'); }

Solution

1. Step 1: Recall scope method naming

   Query scopes must be prefixed with 'scope' and accept $query as first parameter.

2. Step 2: Check method signature and body

   public function scopeActive($query) { return $query->where('status', 'active'); } correctly uses 'scopeActive($query)' and returns $query with condition.

3. Final Answer:

   public function scopeActive($query) { return $query->where('status', 'active'); } -> Option A

4. Quick Check:

   Scope method = scope + $query param [OK]

Hint: Scope methods start with 'scope' and take $query param [OK]

Common Mistakes:

• Omitting $query parameter
• Using underscore in method name
• Not prefixing method with 'scope'

3. Given this scope in a Laravel model:

public function scopePopular($query) {
    return $query->where('votes', '>', 100);
}

What will User::popular()->get() return?

medium

A. All users regardless of votes

B. All users with votes less than or equal to 100

C. All users with votes greater than 100

D. Syntax error because scope is missing

Solution

1. Step 1: Understand the scope condition

   The scope filters users where 'votes' is greater than 100.

2. Step 2: Analyze the query call

   Calling User::popular()->get() applies the scope and returns matching users.

3. Final Answer:

   All users with votes greater than 100 -> Option C

4. Quick Check:

   Scope filters votes > 100 = users returned [OK]

Hint: Scope filters queries; check condition carefully [OK]

Common Mistakes:

• Confusing greater than with less than
• Assuming scope returns all records
• Thinking scope causes syntax error

4. Identify the error in this scope definition:

public function scopeRecent() {
    return $this->orderBy('created_at', 'desc');
}

medium

A. Missing $query parameter in the scope method

B. Incorrect method name, should not start with 'scope'

C. Using orderBy inside scope is not allowed

D. Missing return type declaration

Solution

1. Step 1: Check scope method signature

   Scope methods must accept $query as the first parameter to modify the query.

2. Step 2: Identify missing parameter

   The method lacks the $query parameter, so it cannot modify the query builder.

3. Final Answer:

   Missing $query parameter in the scope method -> Option A

4. Quick Check:

   Scope method needs $query param [OK]

Hint: Scope methods always need $query parameter [OK]

Common Mistakes:

• Forgetting $query parameter
• Thinking orderBy is disallowed in scopes
• Confusing method naming rules

5. You want to create a reusable scope activeAndRecent that returns users who are active and created within the last 30 days. Which of the following scope definitions is correct?

hard

A. public function scopeActiveAndRecent($query) {
return $query->where('status', 'active')
->orWhere('created_at', '>=', now()->subDays(30));
}

B. public function scopeActiveAndRecent($query) {
return $query->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

C. public function scopeActiveAndRecent() {
return $this->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

D. public function activeAndRecent($query) {
return $query->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

Solution

1. Step 1: Verify method signature and parameters

   The scope method must be named with 'scope' prefix and accept $query parameter.

2. Step 2: Check query conditions logic

   Use 'where' twice to combine conditions with AND logic for active status and recent date.

3. Step 3: Compare options

   public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } correctly uses 'scopeActiveAndRecent($query)' and combines conditions with 'where'.

4. Final Answer:

   public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } -> Option B

5. Quick Check:

   Scope with $query and AND conditions = public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } [OK]

Hint: Use 'where' twice for AND, scope method needs $query [OK]

Common Mistakes:

• Using orWhere instead of where for AND logic
• Omitting $query parameter
• Not prefixing method with 'scope'