Repository pattern for data access in Express - Step-by-Step Execution

Concept Flow - Repository pattern for data access

Start

↓

Controller calls Repository

↓

Repository handles data logic

↓

Repository calls Database

↓

Database returns data

↓

Repository returns data to Controller

↓

Controller sends response

↓

End

The controller asks the repository for data. The repository talks to the database and returns data back. The controller then sends the response.

Execution Sample

Express

class UserRepository {
  async getUser(id) {
    return db.findUserById(id);
  }
}

const repo = new UserRepository();

app.get('/user/:id', async (req, res) => {
  const user = await repo.getUser(req.params.id);
  res.json(user);
});

This code shows a repository class fetching a user by ID and the Express route using it to send JSON response.

Execution Table

Step	Action	Input	Repository Method Called	Database Call	Returned Data	Response Sent
1	HTTP GET /user/5 received	id=5	No	No	No	No
2	Controller calls repo.getUser(5)	id=5	getUser(5)	Yes: db.findUserById(5)	No	No
3	Database returns user data	id=5	getUser(5)	db.findUserById(5)	{id:5, name:'Anna'}	No
4	Repository returns data to controller	id=5	getUser(5)	No	{id:5, name:'Anna'}	No
5	Controller sends JSON response	id=5	No	No	No	{id:5, name:'Anna'}
6	Request complete	id=5	No	No	No	Response sent

💡 Request ends after controller sends JSON response with user data.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
id	undefined	5	5	5	5	5
user	undefined	undefined	undefined	{id:5, name:'Anna'}	{id:5, name:'Anna'}	{id:5, name:'Anna'}

Key Moments - 3 Insights

Why does the controller not access the database directly?

The controller calls the repository (see step 2 in execution_table) to keep data logic separate and easier to manage.

What happens if the database call fails?

The repository would handle errors before returning data to the controller, preventing direct database errors from reaching the controller.

Why is the repository method async?

Because database calls take time, the repository uses async to wait for data before returning it (step 3 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what data does the repository return to the controller at step 4?

A {id:5, name:'Anna'}

B undefined

C db.findUserById(5)

D No data

💡 Hint

Check the 'Returned Data' column at step 4 in execution_table.

At which step does the controller send the JSON response?

A Step 3

B Step 2

C Step 5

D Step 6

💡 Hint

Look at the 'Response Sent' column in execution_table.

If the repository method was not async, what would happen?

A Controller would wait correctly for data

B Controller might get undefined before data arrives

C Database call would be faster

D No change in behavior

💡 Hint

Refer to key_moments about async behavior and step 3 in execution_table.

Concept Snapshot

Repository pattern separates data logic from controllers.
Controller calls repository methods.
Repository handles database calls.
Repository methods are async to wait for data.
This keeps code clean and easier to maintain.

Full Transcript

The repository pattern in Express means the controller does not talk directly to the database. Instead, it calls a repository class that handles all data access. When a request comes in, the controller calls a repository method with needed parameters. The repository then calls the database asynchronously to get data. Once the data returns, the repository sends it back to the controller. The controller then sends the data as a JSON response. This separation helps keep code organized and easier to manage. The repository methods are async because database calls take time. The controller waits for the repository to finish before sending the response.

Practice

1. What is the main purpose of using the Repository pattern in an Express app?

easy

A. To manage user authentication

B. To handle HTTP requests and responses

C. To style the frontend components

D. To separate data access logic from business logic

Solution

1. Step 1: Understand the role of repository pattern

   The repository pattern is designed to isolate data access logic from the rest of the application.

2. Step 2: Identify the correct purpose in Express context

   In Express apps, it helps keep business logic clean by moving database queries into repositories.

3. Final Answer:

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

4. Quick Check:

   Repository pattern = separate data access [OK]

Hint: Repository pattern means separate data access from app logic [OK]

Common Mistakes:

• Confusing repository with routing or middleware
• Thinking it handles UI or styling
• Mixing it with authentication logic

2. Which of the following is the correct way to define a repository class in Express using ES6 syntax?

easy

A. class UserRepository { getAll() { /* code */ } }

B. var UserRepository = new Object({ getAll: function() {} })

C. const UserRepository = () => { return { getAll() {} } }

D. function UserRepository() { this.getAll = () => {}; }

Solution

1. Step 1: Identify ES6 class syntax

   ES6 classes use the class keyword with methods inside without the function keyword.

2. Step 2: Match the correct syntax

   class UserRepository { getAll() { /* code */ } } correctly defines a class with a method getAll() using ES6 syntax.

3. Final Answer:

   class UserRepository { getAll() { /* code */ } } -> Option A

4. Quick Check:

   ES6 class syntax = class UserRepository { getAll() { /* code */ } } [OK]

Hint: ES6 classes use 'class' keyword and method shorthand [OK]

Common Mistakes:

• Using function keyword inside class methods
• Confusing arrow functions with class methods
• Using old object syntax instead of class

3. Given this repository method, what will console.log(users) output?

class UserRepository {
  constructor() {
    this.users = [{id:1, name:'Anna'}, {id:2, name:'Bob'}];
  }
  getAll() {
    return this.users;
  }
}
const repo = new UserRepository();
const users = repo.getAll();
console.log(users);

medium

A. [{id:1, name:'Anna'}, {id:2, name:'Bob'}]

B. undefined

C. Error: getAll is not a function

D. []

Solution

1. Step 1: Understand the constructor initialization

   The constructor sets this.users to an array of two user objects.

2. Step 2: Check the getAll method return value

   The getAll() method returns this.users, so calling it returns the array.

3. Final Answer:

   [{id:1, name:'Anna'}, {id:2, name:'Bob'}] -> Option A

4. Quick Check:

   getAll returns users array [OK]

Hint: getAll returns stored users array directly [OK]

Common Mistakes:

• Assuming getAll returns undefined or empty
• Confusing method call with property access
• Expecting an error due to missing binding

4. Identify the error in this repository code snippet:

class ProductRepository {
  constructor() {
    this.products = [];
  }
  add(product) {
    this.products.push(product);
  }
  getAll() {
    return products;
  }
}

medium

A. Missing return statement in getAll method

B. Using undefined variable 'products' instead of 'this.products'

C. Constructor does not initialize products array

D. add method does not push product correctly

Solution

1. Step 1: Check variable usage in getAll method

   The method returns products but this variable is not defined in the method scope.

2. Step 2: Correct usage of instance variable

   It should return this.products to access the class property.

3. Final Answer:

   Using undefined variable 'products' instead of 'this.products' -> Option B

4. Quick Check:

   Use this.products to access class property [OK]

Hint: Use 'this.' to access class properties inside methods [OK]

Common Mistakes:

• Forgetting 'this.' prefix for class properties
• Assuming variables are global inside class methods
• Ignoring constructor initialization

5. You want to extend a base repository to add a custom method findByEmail(email) for users. Which approach correctly implements this in Express?

hard

A. const UserRepository = Object.create(BaseRepository);
UserRepository.findByEmail = function(email) {
return this.data.find(u => u.email === email);
};

B. function UserRepository() {
this.findByEmail = (email) => this.data.find(u => u.email === email);
}
UserRepository.prototype = BaseRepository.prototype;

C. class UserRepository extends BaseRepository {
findByEmail(email) {
return this.data.find(u => u.email === email);
}
}

D. class UserRepository {
findByEmail(email) {
return BaseRepository.data.find(u => u.email === email);
}
}

Solution

1. Step 1: Understand class inheritance in ES6

   Extending a base class uses extends keyword and super() if constructor is needed.

2. Step 2: Check method implementation accessing instance data

   class UserRepository extends BaseRepository { findByEmail(email) { return this.data.find(u => u.email === email); } } correctly extends BaseRepository and uses this.data to find user by email.

3. Final Answer:

   class UserRepository extends BaseRepository { findByEmail(email) { return this.data.find(u => u.email === email); } } -> Option C

4. Quick Check:

   Extend base class and add method using this.data [OK]

Hint: Use 'extends' to inherit and add custom methods in subclass [OK]

Common Mistakes:

• Not using 'extends' for inheritance
• Accessing base class data incorrectly
• Overwriting prototype without proper inheritance