Generic repository pattern in Typescript

Introduction

The generic repository pattern helps you manage data in a simple, reusable way. It lets you write one set of code to handle many types of data, so you don't repeat yourself.

When you want to handle different data types (like users, products, orders) with the same code structure.

When you want to keep your data access code clean and easy to maintain.

When you want to separate how you get data from how you use it in your app.

When you want to make testing easier by swapping real data with fake data.

When you want to add new data types without writing new data access code.

Syntax

Typescript

interface IRepository<T> {
  getAll(): Promise<T[]>;
  getById(id: string): Promise<T | null>;
  create(item: T & { id: string }): Promise<T>;
  update(id: string, item: T & { id: string }): Promise<T | null>;
  delete(id: string): Promise<boolean>;
}

class GenericRepository<T> implements IRepository<T> {
  private items: Map<string, T> = new Map();

  async getAll(): Promise<T[]> {
    return Array.from(this.items.values());
  }

  async getById(id: string): Promise<T | null> {
    return this.items.get(id) ?? null;
  }

  async create(item: T & { id: string }): Promise<T> {
    this.items.set(item.id, item);
    return item;
  }

  async update(id: string, item: T & { id: string }): Promise<T | null> {
    if (!this.items.has(id)) return null;
    this.items.set(id, item);
    return item;
  }

  async delete(id: string): Promise<boolean> {
    return this.items.delete(id);
  }
}

The <T> means this code works with any type you give it.

Methods return Promise to simulate async data access like databases.

Examples

This example shows how to create a repository for users.

Typescript

interface User {
  id: string;
  name: string;
  email: string;
}

const userRepo = new GenericRepository<User>();

Here we add a user and then get all users.

Typescript

await userRepo.create({ id: '1', name: 'Alice', email: '[e-mail]' });
const users = await userRepo.getAll();

This example shows a repository for products, using the same generic class.

Typescript

interface Product {
  id: string;
  title: string;
  price: number;
}

const productRepo = new GenericRepository<Product>();

Sample Program

This program shows how to use the generic repository with a User type. It adds users, reads them, updates one, deletes one, and shows the results at each step.

Typescript

interface IRepository<T> {
  getAll(): Promise<T[]>;
  getById(id: string): Promise<T | null>;
  create(item: T & { id: string }): Promise<T>;
  update(id: string, item: T & { id: string }): Promise<T | null>;
  delete(id: string): Promise<boolean>;
}

class GenericRepository<T> implements IRepository<T> {
  private items: Map<string, T> = new Map();

  async getAll(): Promise<T[]> {
    return Array.from(this.items.values());
  }

  async getById(id: string): Promise<T | null> {
    return this.items.get(id) ?? null;
  }

  async create(item: T & { id: string }): Promise<T> {
    this.items.set(item.id, item);
    return item;
  }

  async update(id: string, item: T & { id: string }): Promise<T | null> {
    if (!this.items.has(id)) return null;
    this.items.set(id, item);
    return item;
  }

  async delete(id: string): Promise<boolean> {
    return this.items.delete(id);
  }
}

interface User {
  id: string;
  name: string;
  email: string;
}

async function main() {
  const userRepo = new GenericRepository<User>();

  await userRepo.create({ id: '1', name: 'Alice', email: '[e-mail]' });
  await userRepo.create({ id: '2', name: 'Bob', email: '[e-mail]' });

  const allUsers = await userRepo.getAll();
  console.log('All users:', allUsers);

  const user1 = await userRepo.getById('1');
  console.log('User with id 1:', user1);

  await userRepo.update('2', { id: '2', name: 'Bobby', email: '[e-mail]' });
  const updatedUser = await userRepo.getById('2');
  console.log('Updated user with id 2:', updatedUser);

  const deleted = await userRepo.delete('1');
  console.log('Deleted user with id 1:', deleted);

  const usersAfterDelete = await userRepo.getAll();
  console.log('Users after delete:', usersAfterDelete);
}

main();

Important Notes

Make sure each item has a unique id property for this pattern to work well.

This pattern helps keep your code clean and easy to change later.

Summary

The generic repository pattern lets you write one data handler for many types.

It helps keep your code organized and reusable.

You can add, get, update, and delete items easily with this pattern.

Practice

1.

What is the main benefit of using the Generic Repository Pattern in TypeScript?

easy

A. It allows handling multiple data types with one reusable class.

B. It automatically generates UI components.

C. It replaces the need for TypeScript interfaces.

D. It compiles TypeScript code faster.

Solution

1. Step 1: Understand the purpose of the generic repository

   The generic repository pattern is designed to handle data operations for many types using one class or interface.

2. Step 2: Compare options with the pattern's purpose

   Only It allows handling multiple data types with one reusable class. correctly describes this benefit. Options A, B, and C are unrelated to the pattern's main use.

3. Final Answer:

   It allows handling multiple data types with one reusable class. -> Option A

4. Quick Check:

   Generic repository = reusable data handler [OK]

Hint: Generic means reusable for many types [OK]

Common Mistakes:

• Thinking it generates UI components
• Confusing it with TypeScript compilation
• Believing it removes interfaces

2.

Which of the following is the correct way to declare a generic repository interface in TypeScript?

interface IRepository<T> {
  add(item: T): void;
  get(id: number): T | undefined;
}

easy

A. interface IRepository<T> { add(item: T): void; get(id: number): T | undefined; }

B. interface IRepository { add(item: any): void; get(id: number): any; }

C. interface IRepository<T> { add(item: any): void; get(id: number): T; }

D. interface IRepository<T> { add(item: T): T; get(id: string): T | undefined; }

Solution

1. Step 1: Check generic syntax correctness

   interface IRepository<T> { add(item: T): void; get(id: number): T | undefined; } correctly declares a generic interface with type parameter <T> and uses it consistently in method signatures.

2. Step 2: Validate method signatures

   interface IRepository<T> { add(item: T): void; get(id: number): T | undefined; }'s methods use item: T and return T | undefined for get, which is correct. Other options misuse types or parameter types.

3. Final Answer:

   interface IRepository<T> { add(item: T): void; get(id: number): T | undefined; } -> Option A

4. Quick Check:

   Generic interface syntax = interface IRepository<T> { add(item: T): void; get(id: number): T | undefined; } [OK]

Hint: Generic interfaces use <T> and consistent types [OK]

Common Mistakes:

• Using 'any' instead of generic type T
• Mismatching parameter and return types
• Using wrong id parameter type

3.

Given the following generic repository class, what will be the output of the console.log statement?

class Repository<T> {
  private items: T[] = [];
  add(item: T): void {
    this.items.push(item);
  }
  getAll(): T[] {
    return this.items;
  }
}

const repo = new Repository<string>();
repo.add('apple');
repo.add('banana');
console.log(repo.getAll());

medium

A. Error: Type mismatch

B. ['apple']

C. []

D. ['apple', 'banana']

Solution

1. Step 1: Understand the generic repository usage

   The repository is created for strings, so it stores string items in an array.

2. Step 2: Trace the add and getAll methods

   Two strings 'apple' and 'banana' are added, so getAll returns ['apple', 'banana'].

3. Final Answer:

   ['apple', 'banana'] -> Option D

4. Quick Check:

   Added items = ['apple', 'banana'] [OK]

Hint: Add items then getAll returns all added [OK]

Common Mistakes:

• Expecting only one item in output
• Thinking getAll returns empty array
• Confusing type errors

4.

Identify the error in this generic repository implementation:

class Repository<T> {
  private items: T[] = [];
  add(item: T): void {
    this.items.push(item);
  }
  get(id: number): T {
    return this.items[id];
  }
}

const repo = new Repository<number>();
console.log(repo.get(0));

medium

A. The items array should be public, not private.

B. The add method should return the added item.

C. The get method should return T | undefined to handle missing items.

D. The generic type T cannot be used with arrays.

Solution

1. Step 1: Analyze the get method return type

   The get method returns this.items[id], which may be undefined if the index is invalid.

2. Step 2: Check return type compatibility

   Since undefined is possible, the return type should be T | undefined to avoid runtime errors.

3. Final Answer:

   The get method should return T | undefined to handle missing items. -> Option C

4. Quick Check:

   Return type must allow undefined for missing index [OK]

Hint: Allow undefined return for invalid index [OK]

Common Mistakes:

• Ignoring possible undefined return
• Changing add method unnecessarily
• Making items public without reason

5.

You want to create a generic repository that supports updating an item by id. Which method signature correctly fits this requirement?

hard

A. update(item: T): void

B. update(id: number, item: T): boolean

C. update(id: string, item: any): T

D. update(id: number): T | undefined

Solution

1. Step 1: Understand update method needs

   To update an item, you need to specify which item by id and provide the new item data.

2. Step 2: Evaluate method signatures

   update(id: number, item: T): boolean takes an id and a new item of type T, returning boolean to indicate success, which fits the requirement best.

3. Final Answer:

   update(id: number, item: T): boolean -> Option B

4. Quick Check:

   Update needs id and new item, returns success [OK]

Hint: Update needs id and new item, returns success boolean [OK]

Common Mistakes:

• Missing id parameter
• Using wrong parameter types
• Returning wrong type from update