Repository pattern for data access in Express

Introduction

The repository pattern helps organize how your app talks to data sources. It keeps data access code separate and easy to manage.

When you want to keep your data access code clean and separate from your app logic.

When you plan to switch databases or data sources without changing your app code.

When you want to write easier tests by mocking data access.

When your app grows and you want to avoid repeating data access code.

When you want a clear place to add caching or logging for data calls.

Syntax

Express

class Repository {
  constructor(model) {
    this.model = model;
  }

  async getAll() {
    return await this.model.find();
  }

  async getById(id) {
    return await this.model.findById(id);
  }

  async create(data) {
    return await this.model.create(data);
  }

  async update(id, data) {
    return await this.model.findByIdAndUpdate(id, data, { new: true });
  }

  async delete(id) {
    return await this.model.findByIdAndDelete(id);
  }
}

This example uses a class to wrap data access methods.

The model is usually a database model like a Mongoose model.

Examples

Extend the base repository to add custom methods for a specific data type.

Express

class UserRepository extends Repository {
  async findByEmail(email) {
    return await this.model.findOne({ email });
  }
}

Create an instance of the repository and call its methods to get data.

Express

const userRepository = new UserRepository(UserModel);
const users = await userRepository.getAll();

Sample Program

This Express app uses the repository pattern to manage user data. The UserRepository class handles all database calls. Routes call repository methods to get or create users.

This keeps the route code clean and focused on handling requests.

Express

import express from 'express';
import mongoose from 'mongoose';

// Define a simple User schema
const userSchema = new mongoose.Schema({
  name: String,
  email: String
});
const UserModel = mongoose.model('User', userSchema);

// Repository class
class Repository {
  constructor(model) {
    this.model = model;
  }

  async getAll() {
    return await this.model.find();
  }

  async getById(id) {
    return await this.model.findById(id);
  }

  async create(data) {
    return await this.model.create(data);
  }

  async update(id, data) {
    return await this.model.findByIdAndUpdate(id, data, { new: true });
  }

  async delete(id) {
    return await this.model.findByIdAndDelete(id);
  }
}

// UserRepository extends Repository
class UserRepository extends Repository {
  async findByEmail(email) {
    return await this.model.findOne({ email });
  }
}

const app = express();
app.use(express.json());

const userRepository = new UserRepository(UserModel);

// Connect to MongoDB (replace with your connection string)
mongoose.connect('mongodb://localhost:27017/testdb', { useNewUrlParser: true, useUnifiedTopology: true });

// Routes
app.get('/users', async (req, res) => {
  const users = await userRepository.getAll();
  res.json(users);
});

app.post('/users', async (req, res) => {
  const user = await userRepository.create(req.body);
  res.status(201).json(user);
});

app.get('/users/email/:email', async (req, res) => {
  const user = await userRepository.findByEmail(req.params.email);
  if (user) res.json(user);
  else res.status(404).send('User not found');
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Important Notes

Always handle errors in real apps to avoid crashes.

The repository pattern helps if you change your database later; just update the repository code.

Use async/await to keep code easy to read and avoid callback hell.

Summary

The repository pattern separates data access from app logic.

It makes your code cleaner and easier to maintain.

You can add custom data methods by extending the base repository.

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