Repository pattern in PHP - Step-by-Step Execution

Concept Flow - Repository pattern

Client calls Repository

↓

Repository handles data logic

↓

Repository calls Data Source (DB, API)

↓

Data Source returns data

↓

Repository returns data to Client

The client asks the repository for data. The repository talks to the data source, gets data, and returns it to the client.

Execution Sample

PHP

<?php
interface UserRepository {
  public function findUserById(int $id): array;
}

class UserRepo implements UserRepository {
  public function findUserById(int $id): array {
    // Simulate DB call
    return ['id' => $id, 'name' => 'Alice'];
  }
}

$userRepo = new UserRepo();
$user = $userRepo->findUserById(1);
print_r($user);
?>

This code shows a repository interface and class that returns user data by ID, simulating a database call.

Execution Table

Step	Action	Method Called	Input	Output
1	Create UserRepo instance	-	-	UserRepo object created
2	Call findUserById	findUserById	1	Array ['id' => 1, 'name' => 'Alice']
3	Print result	-	-	Array printed: id=1, name=Alice
4	End	-	-	No more actions

💡 All steps completed, user data retrieved and printed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
$userRepo	null	UserRepo object	UserRepo object	UserRepo object	UserRepo object
$user	null	null	['id' => 1, 'name' => 'Alice']	['id' => 1, 'name' => 'Alice']	['id' => 1, 'name' => 'Alice']

Key Moments - 2 Insights

Why do we use an interface for the repository?

The interface defines what methods the repository must have, so the client code can use any class that follows this interface without changing. See step 2 in execution_table where findUserById is called on the repository.

Does the client know how data is fetched?

No, the client only calls the repository method. The repository hides the data source details. This is shown in step 2 where the repository returns data without exposing database logic.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output of findUserById when called with 1?

A Null

B Error message

C Array with id=1 and name='Alice'

D Empty array

💡 Hint

Check step 2 in execution_table where findUserById returns the array.

At which step is the UserRepo object created?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at step 1 in execution_table where the UserRepo instance is created.

If the repository method returned data from an API instead of a database, what changes in the execution_table?

A The method called would change

B The output would still be the same format

C The client code would change

D The UserRepo object would not be created

💡 Hint

Repository hides data source, so output format stays same as shown in variable_tracker.

Concept Snapshot

Repository pattern:
- Defines an interface for data access
- Repository class implements data fetching logic
- Client calls repository, not data source directly
- Hides data source details (DB, API)
- Makes code easier to change and test

Full Transcript

The Repository pattern helps separate data access logic from the rest of the code. The client calls methods on a repository interface. The repository class implements these methods and fetches data from a database or other source. This hides the details of data fetching from the client. In the example, a UserRepo class implements a method to find a user by ID and returns user data as an array. The client creates the repository object, calls the method, and gets the data. This makes the code cleaner and easier to maintain.

Practice

1. What is the main purpose of the Repository pattern in PHP?

easy

A. To separate data access logic from business logic

B. To directly connect the database with the user interface

C. To write all code inside a single class

D. To avoid using interfaces in the code

Solution

1. Step 1: Understand the role of Repository pattern

   The Repository pattern is designed to separate how data is accessed from how the business logic works.

2. Step 2: Identify the correct purpose

   Separating data access from business logic makes code cleaner and easier to maintain.

3. Final Answer:

   To separate data access logic from business logic -> Option A

4. Quick Check:

   Repository pattern = separation of concerns [OK]

Hint: Remember: Repository separates data logic from business logic [OK]

Common Mistakes:

• Thinking Repository connects UI directly to database
• Believing all code should be in one class
• Ignoring the use of interfaces

2. Which of the following is the correct way to declare a Repository interface in PHP?

easy

A. UserRepository interface { public function findUser(int $id); }

B. class UserRepository { public function findUser(int $id); }

C. interface UserRepository { function findUser; }

D. interface UserRepository { public function findUser(int $id); }

Solution

1. Step 1: Recall PHP interface syntax

   Interfaces use the keyword interface followed by method declarations with parentheses and types.

2. Step 2: Check each option

   interface UserRepository { public function findUser(int $id); } correctly declares an interface with a method having a typed parameter. class UserRepository { public function findUser(int $id); } uses class instead of interface. interface UserRepository { function findUser; } misses parentheses. UserRepository interface { public function findUser(int $id); } has wrong syntax order.

3. Final Answer:

   interface UserRepository { public function findUser(int $id); } -> Option D

4. Quick Check:

   Interface syntax = interface UserRepository { public function findUser(int $id); } [OK]

Hint: Interfaces use 'interface' keyword and method signatures with parentheses [OK]

Common Mistakes:

• Using 'class' instead of 'interface'
• Omitting parentheses in method declaration
• Wrong keyword order in interface declaration

3. Given the following PHP code, what will be the output?

interface UserRepository {
    public function findUser(int $id);
}

class UserRepo implements UserRepository {
    public function findUser(int $id) {
        return "User_" . $id;
    }
}

$repo = new UserRepo();
echo $repo->findUser(5);

medium

A. 5

B. User_5

C. UserRepo

D. Error: Interface method not implemented

Solution

1. Step 1: Understand interface and class implementation

   The class UserRepo implements UserRepository and defines the method findUser that returns "User_" concatenated with the id.

2. Step 2: Trace the method call

   Calling $repo->findUser(5) returns "User_5" which is then printed.

3. Final Answer:

   User_5 -> Option B

4. Quick Check:

   Method returns 'User_' + id = User_5 [OK]

Hint: Look for string concatenation in method return [OK]

Common Mistakes:

• Expecting just the number 5 as output
• Confusing class name with output
• Thinking interface causes error if implemented correctly

4. Identify the error in this PHP Repository implementation:

interface ProductRepository {
    public function getProduct(int $id);
}

class ProductRepo implements ProductRepository {
    public function getProduct() {
        return "Product";
    }
}

medium

A. Class name should be ProductRepository, not ProductRepo

B. Interface keyword is misspelled

C. Method getProduct() missing parameter in class implementation

D. Return type is missing in interface method

Solution

1. Step 1: Compare interface and class method signatures

   The interface method getProduct requires an int $id parameter, but the class method has no parameters.

2. Step 2: Understand PHP interface implementation rules

   When implementing an interface, method signatures must match exactly, including parameters.

3. Final Answer:

   Method getProduct() missing parameter in class implementation -> Option C

4. Quick Check:

   Method signatures must match [OK]

Hint: Check method parameters match interface exactly [OK]

Common Mistakes:

• Ignoring parameter mismatch
• Thinking class name must match interface name
• Assuming return type is mandatory in interface

5. You want to create a flexible Repository pattern for managing users and products. Which design approach best supports adding new data types without changing existing code?

hard

A. Create separate interfaces like UserRepository and ProductRepository, then implement them in separate classes

B. Write one big class handling all data types with many methods

C. Use global functions to access data directly

D. Store all data in arrays inside a single class without interfaces

Solution

1. Step 1: Understand flexibility in Repository pattern

   Using separate interfaces and classes for each data type allows adding new repositories without changing existing ones.

2. Step 2: Evaluate options for maintainability

   Create separate interfaces like UserRepository and ProductRepository, then implement them in separate classes supports open/closed principle: open for extension, closed for modification. Other options mix concerns or lack structure.

3. Final Answer:

   Create separate interfaces like UserRepository and ProductRepository, then implement them in separate classes -> Option A

4. Quick Check:

   Separate interfaces = flexible extension [OK]

Hint: Use separate interfaces and classes for each data type [OK]

Common Mistakes:

• Putting all logic in one big class
• Using global functions instead of classes
• Avoiding interfaces reduces flexibility