Create Mockdb Repository

Step 3: Create the Class

export class MockDb{Entity}Repository implements I{Entity}Repository {
  private {entities}: {Entity}Type[] = [];

  // Helper method for filtering, pagination, and sorting
  private applyQueryParams(
    {entities}: {Entity}Type[],
    params: {Entity}QueryParamsType,
  ): PaginatedResultType<{Entity}Type> {
    let filtered = {entities};

    // Apply entity-specific filters
    if (params.createdBy) {
      filtered = filtered.filter((item) => item.createdBy === params.createdBy);
    }

    // Apply search filter
    const searchTerm = params.search?.toLowerCase().trim();
    if (searchTerm) {
      filtered = filtered.filter((item) =>
        item.{searchableField}.toLowerCase().includes(searchTerm)
      );
    }

    // Pagination
    const page = params.page ?? DEFAULT_PAGE;
    const limit = params.limit ?? DEFAULT_LIMIT;
    const skip = (page - 1) * limit;
    let paginated = filtered.slice(skip, skip + limit);
    const totalPages = Math.ceil(filtered.length / limit);

    // Sorting
    const sortBy = (params.sortBy ?? "createdAt") as keyof {Entity}Type;
    const sortOrder = params.sortOrder;
    if (sortBy) {
      paginated = paginated.sort((a, b) => {
        if (sortOrder === "asc") {
          return a[sortBy]?.toString().localeCompare(b[sortBy]?.toString() ?? "") ?? 0;
        } else if (sortOrder === "desc") {
          return b[sortBy]?.toString().localeCompare(a[sortBy]?.toString() ?? "") ?? 0;
        }
        return 0;
      });
    }

    return {
      data: paginated,
      total: filtered.length,
      page,
      limit,
      totalPages,
    };
  }

  async findAll(params: {Entity}QueryParamsType): Promise<PaginatedResultType<{Entity}Type>> {
    return this.applyQueryParams(this.{entities}, params);
  }

  async findById(id: {Entity}IdType): Promise<{Entity}Type | null> {
    const item = this.{entities}.find((e) => e.id === id);
    return item || null;
  }

  async findAllByIds(
    ids: {Entity}IdType[],
    params: {Entity}QueryParamsType,
  ): Promise<PaginatedResultType<{Entity}Type>> {
    const filtered = this.{entities}.filter((item) => ids.includes(item.id));
    return this.applyQueryParams(filtered, params);
  }

  async create(
    data: Create{Entity}Type,
    createdByUserId: UserIdType,
  ): Promise<{Entity}Type> {
    const now = new Date();
    const new{Entity}: {Entity}Type = {
      id: uuidv4(),
      ...data,
      createdBy: createdByUserId,
      createdAt: now,
      updatedAt: now,
    };
    this.{entities}.push(new{Entity});
    return new{Entity};
  }

  async update(id: {Entity}IdType, data: Update{Entity}Type): Promise<{Entity}Type | null> {
    const index = this.{entities}.findIndex((e) => e.id === id);
    if (index === -1) {
      return null;
    }
    const existing = this.{entities}[index];
    const updated = {
      ...existing,
      ...data,
      updatedAt: new Date(),
    };
    this.{entities}[index] = updated;
    return updated;
  }

  async remove(id: {Entity}IdType): Promise<boolean> {
    const initialLength = this.{entities}.length;
    this.{entities} = this.{entities}.filter((e) => e.id !== id);
    return this.{entities}.length < initialLength;
  }

  // Helper method for testing: clear all data
  clear(): void {
    this.{entities} = [];
  }
}

Patterns & Rules

Class Naming

• Class name: MockDb{Entity}Repository (e.g., MockDbNoteRepository)
• Implements: I{Entity}Repository interface

Private Data Store

private {entities}: {Entity}Type[] = [];

Use a descriptive plural name for the array (e.g., notes, courses, users).

ID Generation

Use uuid for generating unique IDs:

import { v4 as uuidv4 } from "uuid";

// In create method: