Decorator Pattern

The Problem

An e-commerce platform needs to process orders with varying combinations of cross-cutting concerns: sometimes orders need validation, sometimes logging, sometimes a discount is applied, and sometimes all three. Creating subclasses for every combination leads to an exponential number of classes.

The Solution

The Decorator pattern wraps the base OrderProcessor in one or more decorator objects that each add a specific behavior while preserving the same interface. Decorators delegate to the wrapped object and augment the result. They can be stacked in any order, and the client specifies which decorators to apply at runtime.

Structure

Component Interface (OrderProcessor) — Defines the process(order) method.
Concrete Component (BaseOrderProcessor) — Core implementation that creates an order and calculates the total.
Decorators (LoggingDecorator, ValidationDecorator, DiscountDecorator) — Each wraps an OrderProcessor, calls the wrapped object’s method, and adds its own behavior.
TypeScript Method Decorator (TrackExecution) — A NestJS-style method decorator that measures execution time, demonstrating that GoF Decorator and language-level decorators serve complementary purposes.

Implementation

The BaseOrderProcessor takes a list of items, sums their prices, and returns a ProcessedOrder with a steps array tracking what happened.

The ValidationDecorator checks that items and prices are valid. The LoggingDecorator logs details to the console. The DiscountDecorator applies a 10% discount. Each decorator appends its action to the steps array.

export interface OrderItem {
  name: string;
  price: number;
}

export interface OrderData {
  items: OrderItem[];
}

export interface ProcessedOrder {
  orderId: string;
  steps: string[];
  total: number;
  timestamp: string;
}

export interface OrderProcessor {
  process(order: OrderData): ProcessedOrder;
}

import {
  OrderProcessor,
  OrderData,
  ProcessedOrder,
} from './order-processor.interface';

export class BaseOrderProcessor implements OrderProcessor {
  process(order: OrderData): ProcessedOrder {
    const total = order.items.reduce((sum, item) => sum + item.price, 0);

    return {
      orderId: `ORD-${Date.now()}`,
      steps: ['Base processing: order created'],
      total: parseFloat(total.toFixed(2)),
      timestamp: new Date().toISOString(),
    };
  }
}

import { BadRequestException } from '@nestjs/common';
import {
  OrderProcessor,
  OrderData,
  ProcessedOrder,
} from './order-processor.interface';

export class ValidationDecorator implements OrderProcessor {
  constructor(private readonly wrapped: OrderProcessor) {}

  process(order: OrderData): ProcessedOrder {
    if (!order.items || order.items.length === 0) {
      throw new BadRequestException('Order must contain at least one item');
    }

    for (const item of order.items) {
      if (item.price <= 0) {
        throw new BadRequestException(
          `Item "${item.name}" has an invalid price: ${item.price}. Price must be greater than 0`,
        );
      }
    }

    const result = this.wrapped.process(order);
    result.steps.push('Validation: all items validated successfully');
    return result;
  }
}

import {
  OrderProcessor,
  OrderData,
  ProcessedOrder,
} from './order-processor.interface';

export class LoggingDecorator implements OrderProcessor {
  constructor(private readonly wrapped: OrderProcessor) {}

  process(order: OrderData): ProcessedOrder {
    console.log(`[LoggingDecorator] Processing order with ${order.items.length} items`);
    const result = this.wrapped.process(order);
    result.steps.push('Logging: order processing logged');
    console.log(`[LoggingDecorator] Order ${result.orderId} processed, total: $${result.total}`);
    return result;
  }
}

import {
  OrderProcessor,
  OrderData,
  ProcessedOrder,
} from './order-processor.interface';

export class DiscountDecorator implements OrderProcessor {
  constructor(
    private readonly wrapped: OrderProcessor,
    private readonly discountPercentage: number = 10,
  ) {}

  process(order: OrderData): ProcessedOrder {
    const result = this.wrapped.process(order);
    const discountAmount = result.total * (this.discountPercentage / 100);
    result.total = parseFloat((result.total - discountAmount).toFixed(2));
    result.steps.push(
      `Discount: ${this.discountPercentage}% discount applied (-$${discountAmount.toFixed(2)})`,
    );
    return result;
  }
}

export function TrackExecution(): MethodDecorator {
  return function (
    _target: object,
    propertyKey: string | symbol,
    descriptor: PropertyDescriptor,
  ) {
    const originalMethod = descriptor.value;

    descriptor.value = function (...args: unknown[]) {
      const start = performance.now();
      const result = originalMethod.apply(this, args);
      const end = performance.now();
      const duration = (end - start).toFixed(2);
      console.log(
        `[TrackExecution] ${String(propertyKey)} executed in ${duration}ms`,
      );
      return result;
    };

    return descriptor;
  };
}

NestJS Integration

The DecoratorController is the only NestJS-managed class. The BaseOrderProcessor and its decorators are plain classes instantiated at request time, allowing fully dynamic composition based on the request payload. The @TrackExecution() TypeScript method decorator shows how NestJS’s native decorator system parallels the GoF Decorator at the language level.

When to Use

You need to add responsibilities to objects dynamically and transparently.
You want to combine multiple independent behaviors in different configurations at runtime.
Subclassing is impractical because the number of combinations would lead to a class explosion.
You are building a processing pipeline where steps can be added, removed, or reordered.

When NOT to Use

You only need one fixed combination of behaviors that will never change.
Decorators rely on a stable component interface; if it changes frequently, maintenance becomes burdensome.

Composite

Compose objects into tree structures to represent part-whole hierarchies.

Strategy

Define a family of algorithms, encapsulate each one, and make them interchangeable.

Chain of Responsibility

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.