Generic repository pattern in Typescript - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a generic repository interface.

Typescript

interface IRepository<T> {
  getById(id: number): [1];
}

Drag options to blanks, or click blank then click option'

AT

Bnumber

Cvoid

Dstring

Attempts:

3 left

💡 Hint

Common Mistakes

Returning a fixed type like number or string instead of the generic type.

Using void as return type which means no value is returned.

The method getById returns an object of the generic type T.

2fill in blank

medium

Complete the code to define a generic method to add an item to the repository.

Typescript

interface IRepository<T> {
  add(item: [1]): void;
}

Drag options to blanks, or click blank then click option'

Aany

Bobject

CT

Dunknown

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-generic type like any or object which loses type safety.

Using unknown which requires type assertions.

The add method accepts an item of the generic type T.

3fill in blank

hard

Fix the error in the generic repository class declaration.

Typescript

class Repository<[1]> implements IRepository<T> {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  getById(id: number): T | undefined {
    return this.items.find(item => (item as any).id === id);
  }
}

Drag options to blanks, or click blank then click option'

AT

BU

CItem

DK

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different generic type parameter name than the interface.

Omitting the generic parameter in the class declaration.

The class must declare the generic type parameter T to match the interface.

4fill in blank

hard

Fill both blanks to create a generic repository method that returns all items matching a condition.

Typescript

class Repository<T> implements IRepository<T> {
  private items: T[] = [];

  findAll(predicate: (item: [1]) => boolean): [2] {
    return this.items.filter(predicate);
  }
}

Drag options to blanks, or click blank then click option'

AT

BT[]

Cany

Dvoid

Attempts:

3 left

💡 Hint

Common Mistakes

Using any instead of the generic type T.

Returning void instead of an array.

The predicate function takes an item of type T, and the method returns an array of T.

5fill in blank

hard

Fill all three blanks to implement a generic repository method that updates an item by id.

Typescript

class Repository<T extends { id: number }> implements IRepository<T> {
  private items: T[] = [];

  update(id: number, [1]: Partial<[2]>): boolean {
    const index = this.items.findIndex(item => item.id === id);
    if (index === -1) return false;
    this.items[index] = { ...this.items[index], ...[3] };
    return true;
  }
}

Drag options to blanks, or click blank then click option'

Achanges

BT

Dupdates

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for the changes parameter and spread variable.

Not using Partial type for changes.

The method takes changes of type Partial<T> and merges them into the existing item.

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