Composite Pattern

The Problem

An e-commerce platform has a product catalog organized into categories. Categories can contain individual products or nested subcategories. Without the Composite pattern, client code must distinguish between products and categories, using different logic to calculate totals, count items, or display the structure. This leads to complex conditional logic.

The Solution

The Composite pattern defines a common CatalogComponent interface that both individual products (leaves) and categories (composites) implement. Both respond to the same operations — getPrice(), getCount(), display() — but composites delegate to their children recursively.

Structure

Component Interface (CatalogComponent) — Declares getName(), getPrice(), getCount(), and display() methods.
Leaf (ProductItem) — Represents an individual product. getPrice() returns its own price, getCount() returns 1.
Composite (Category) — Holds a collection of children. getPrice() and getCount() sum all children’s values recursively.
Client (CatalogService, CompositeController) — Builds the tree and operates on the root node uniformly.

Implementation

The CatalogService builds a tree representing a store catalog:

Electronics — Phones (iPhone, Samsung, Pixel) + Laptops (MacBook, Dell, ThinkPad)
Clothing — Men (T-Shirt, Jeans) + Women (Dress, Jacket)

Calling getPrice() on the root returns the sum of all 10 products. Calling display() returns a formatted, indented text representation.

export interface CatalogComponent {
  getName(): string;
  getPrice(): number;
  getCount(): number;
  display(indent?: number): string;
}

import { CatalogComponent } from './catalog-component.interface';

export class ProductItem implements CatalogComponent {
  constructor(
    private readonly name: string,
    private readonly price: number,
  ) {}

  getName(): string {
    return this.name;
  }

  getPrice(): number {
    return this.price;
  }

  getCount(): number {
    return 1;
  }

  display(indent: number = 0): string {
    const padding = ' '.repeat(indent);
    return `${padding}- ${this.name} ($${this.price.toFixed(2)})`;
  }
}

import { CatalogComponent } from './catalog-component.interface';

export class Category implements CatalogComponent {
  private readonly children: CatalogComponent[] = [];

  constructor(private readonly name: string) {}

  add(child: CatalogComponent): void {
    this.children.push(child);
  }

  remove(child: CatalogComponent): void {
    const index = this.children.indexOf(child);
    if (index !== -1) {
      this.children.splice(index, 1);
    }
  }

  getName(): string {
    return this.name;
  }

  getPrice(): number {
    return this.children.reduce((sum, child) => sum + child.getPrice(), 0);
  }

  getCount(): number {
    return this.children.reduce((count, child) => count + child.getCount(), 0);
  }

  display(indent: number = 0): string {
    const padding = ' '.repeat(indent);
    const lines = [`${padding}+ ${this.name}`];

    for (const child of this.children) {
      lines.push(child.display(indent + 2));
    }

    return lines.join('\n');
  }
}

import { Injectable } from '@nestjs/common';
import { Category } from './category';
import { ProductItem } from './product-item';
import { CatalogComponent } from './catalog-component.interface';

@Injectable()
export class CatalogService {
  buildCatalog(): CatalogComponent {
    const root = new Category('Store Catalog');

    // Electronics
    const electronics = new Category('Electronics');
    const phones = new Category('Phones');
    phones.add(new ProductItem('iPhone 16 Pro', 1199.99));
    phones.add(new ProductItem('Samsung Galaxy S25', 999.99));
    phones.add(new ProductItem('Google Pixel 9', 799.99));

    const laptops = new Category('Laptops');
    laptops.add(new ProductItem('MacBook Pro 16"', 2499.99));
    laptops.add(new ProductItem('Dell XPS 15', 1799.99));
    laptops.add(new ProductItem('ThinkPad X1 Carbon', 1599.99));

    electronics.add(phones);
    electronics.add(laptops);

    // Clothing
    const clothing = new Category('Clothing');
    const men = new Category('Men');
    men.add(new ProductItem('Cotton T-Shirt', 29.99));
    men.add(new ProductItem('Slim Fit Jeans', 59.99));

    const women = new Category('Women');
    women.add(new ProductItem('Summer Dress', 79.99));
    women.add(new ProductItem('Leather Jacket', 199.99));

    clothing.add(men);
    clothing.add(women);

    root.add(electronics);
    root.add(clothing);

    return root;
  }
}

NestJS Integration

The CatalogService is registered as an @Injectable() NestJS provider responsible for constructing the composite tree. ProductItem and Category are plain TypeScript classes (not NestJS providers) because they represent domain objects instantiated dynamically. The module exports CatalogService so other modules can reuse the catalog-building logic.

When to Use

You need to represent a tree structure where clients should treat individual items and groups uniformly.
You want operations like totaling prices or counting elements to work recursively across the entire tree.
You are building hierarchical data structures such as catalogs, menus, file systems, or organizational charts.

When NOT to Use

Your data is flat (not hierarchical) — a simple list would suffice.
The operations on leaves and composites are fundamentally different, making a uniform interface misleading.
You need strict type safety to distinguish between leaves and composites at compile time.

Decorator

Attach additional responsibilities to an object dynamically.

Iterator

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.

Flyweight

Use sharing to support large numbers of fine-grained objects efficiently.