Repository pattern for data access in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Repository Pattern: Data Fetching Behavior

Given the repository pattern implementation below, what will be the output when calling userRepository.getById(2) if the data source contains users with ids 1 and 2?

Express

class UserRepository {
  constructor() {
    this.users = [
      { id: 1, name: 'Alice' },
      { id: 2, name: 'Bob' }
    ];
  }

  getById(id) {
    return this.users.find(user => user.id === id);
  }
}

const userRepository = new UserRepository();
console.log(userRepository.getById(2));

A { id: 2, name: 'Bob' }

B undefined

C { id: 1, name: 'Alice' }

D Throws TypeError

💡 Hint

Look at how the getById method searches the array.

The getById method uses Array.find to locate the user with the matching id. Since user with id 2 exists, it returns that user object.

📝 Syntax

intermediate

Correct Repository Method Syntax

Which option correctly defines a repository method addUser that adds a user object to the internal array users?

Express

class UserRepository {
  constructor() {
    this.users = [];
  }

  // Define addUser method here
}

A addUser(user) => { this.users.push(user); }

B addUser = (user) => { this.users.push(user); }

C addUser(user) { this.users.push(user) }

D addUser(user) { this.users.push(user); }

💡 Hint

Check the correct method syntax inside a class in JavaScript.

In a class, methods are defined without the = or arrow syntax. Option D uses the correct method syntax with parentheses and curly braces.

Option D uses arrow function syntax which is invalid as a class method declaration. Option D has invalid arrow function syntax. Option D is missing a semicolon but that is allowed in JavaScript, so it would also work but is less standard.

🔧 Debug

advanced

Identify the Error in Repository Method

What error will occur when running the following repository method removeUser if called with an id that does not exist in the users array?

Express

class UserRepository {
  constructor() {
    this.users = [{ id: 1, name: 'Alice' }];
  }

  removeUser(id) {
    const index = this.users.findIndex(user => user.id === id);
    this.users.splice(index, 1);
  }
}

const repo = new UserRepository();
repo.removeUser(2);

A Removes user with id 1

B Throws RangeError due to invalid splice index

C Throws TypeError because index is undefined

D Removes no user, no error thrown

💡 Hint

What does findIndex return if no match is found?

findIndex returns -1 if no matching element is found. Calling splice(-1, 1) removes the last element in the array. But since the array has only one user with id 1, calling removeUser(2) will remove the last user incorrectly.

However, in JavaScript, splice(-1, 1) removes the last element, so it does remove user with id 1, which is wrong behavior.

Therefore, the correct answer is that it removes user with id 1, which is option A.

❓ state_output

advanced

State of Repository After Multiple Operations

After running the following code, what is the content of repo.users?

Express

class UserRepository {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
  }

  clearUsers() {
    this.users = [];
  }
}

const repo = new UserRepository();
repo.addUser({ id: 1, name: 'Alice' });
repo.addUser({ id: 2, name: 'Bob' });
repo.clearUsers();
repo.addUser({ id: 3, name: 'Charlie' });

A [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, name: 'Charlie' }]

B [{ id: 3, name: 'Charlie' }]

C []

D [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]

💡 Hint

Look at what clearUsers does to the users array.

The clearUsers method resets the users array to an empty array. After clearing, only the last added user remains in the array.

🧠 Conceptual

expert

Purpose of Repository Pattern in Express Apps

Which option best describes the main benefit of using the repository pattern for data access in an Express application?

A It replaces the need for middleware in Express routes.

B It automatically caches all database queries to improve performance.

C It separates data access logic from business logic, making code easier to maintain and test.

D It enforces a strict schema on all data models without external libraries.

💡 Hint

Think about how separating concerns helps in coding.

The repository pattern abstracts data access logic from the rest of the app. This separation makes the code cleaner, easier to maintain, and easier to test by isolating database operations.

Options B, C, and D describe unrelated or incorrect benefits.

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