Challenge 1: Design a Repository Interface — Possible Solution
====================================================================

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

type CreateProductInput = Omit<Product, "id">;

interface ProductRepository {
  findById(id: string): Promise<Product | null>;
  findAll(): Promise<Product[]>;
  create(input: CreateProductInput): Promise<Product>;
}

// --- In-memory implementation (great for tests) ---

class InMemoryProductRepository implements ProductRepository {
  private products: Product[] = [];
  private nextId = 1;

  async findById(id: string): Promise<Product | null> {
    return this.products.find((p) => p.id === id) ?? null;
  }

  async findAll(): Promise<Product[]> {
    return [...this.products];
  }

  async create(input: CreateProductInput): Promise<Product> {
    const product: Product = { id: String(this.nextId++), ...input };
    this.products.push(product);
    return product;
  }
}

// --- ORM-backed implementation (sketch, assumes a Prisma-style client) ---

interface PrismaLikeClient {
  product: {
    findUnique(args: { where: { id: string } }): Promise<Product | null>;
    findMany(): Promise<Product[]>;
    create(args: { data: CreateProductInput }): Promise<Product>;
  };
}

class PrismaProductRepository implements ProductRepository {
  constructor(private prisma: PrismaLikeClient) {}

  findById(id: string): Promise<Product | null> {
    return this.prisma.product.findUnique({ where: { id } });
  }

  findAll(): Promise<Product[]> {
    return this.prisma.product.findMany();
  }

  create(input: CreateProductInput): Promise<Product> {
    return this.prisma.product.create({ data: input });
  }
}

// --- Usage: business logic depends only on the interface ---

class CatalogService {
  constructor(private products: ProductRepository) {}

  async listProducts(): Promise<Product[]> {
    return this.products.findAll();
  }
}

// In tests:
const testService = new CatalogService(new InMemoryProductRepository());
// In production:
// const prodService = new CatalogService(new PrismaProductRepository(prismaClient));

WHY THIS WORKS
--------------
- CatalogService depends on ProductRepository (the interface), never on
  InMemoryProductRepository or PrismaProductRepository directly — the exact
  same principle as Database/Mailer in Chapter 1's DI chapter.
- Tests can use InMemoryProductRepository and run instantly with no real
  database, network, or Docker container required.
- Swapping the actual persistence technology (Prisma today, something else
  in two years) means writing one new class that implements
  ProductRepository — CatalogService and everything above it never changes.