Template Method Pattern

The Problem

Different report types (sales, inventory, customer) follow the same overall process — gather data, process it, format a report, generate a summary — but differ in the specifics at each step. Duplicating the algorithm structure across each report type leads to code repetition and inconsistency.

The Solution

The Template Method pattern defines the algorithm skeleton in ReportGenerator’s generate() method. Subclasses override gatherData() and formatReport() to provide type-specific behavior while the overall sequence remains fixed. A default processData() implementation is optionally overridable.

Structure

Abstract Class (ReportGenerator) — Defines the generate() template method.
Concrete Classes — SalesReportGenerator, InventoryReportGenerator, CustomerReportGenerator.
Client — TemplateMethodController selects the generator by type.

Implementation

Three report generators:

SalesReportGenerator — Revenue, average order value, breakdown by region.
InventoryReportGenerator — Low-stock items, total inventory value, stock by category.
CustomerReportGenerator — Revenue, average spend, tier distribution, top 3 customers.

export interface ReportData {
  title: string;
  generatedAt: string;
  type: string;
  data: Record<string, any>;
  summary: Record<string, any>;
}

export abstract class ReportGenerator {
  generate(): ReportData {
    const rawData = this.gatherData();
    const processedData = this.processData(rawData);
    const report = this.formatReport(processedData);
    return report;
  }

  protected abstract gatherData(): Record<string, any>[];

  protected processData(data: Record<string, any>[]): Record<string, any> {
    return {
      records: data,
      totalRecords: data.length,
      processedAt: new Date().toISOString(),
    };
  }

  protected abstract formatReport(processedData: Record<string, any>): ReportData;
}

import { ReportGenerator, ReportData } from './report-generator';

export class SalesReportGenerator extends ReportGenerator {
  protected gatherData(): Record<string, any>[] {
    return [
      { orderId: 'ORD001', product: 'Laptop', amount: 999.99, date: '2026-02-01', region: 'North' },
      { orderId: 'ORD002', product: 'Headphones', amount: 49.99, date: '2026-02-03', region: 'South' },
      { orderId: 'ORD003', product: 'Tablet', amount: 449.99, date: '2026-02-05', region: 'North' },
      { orderId: 'ORD004', product: 'Smartphone', amount: 699.99, date: '2026-02-07', region: 'East' },
      { orderId: 'ORD005', product: 'Monitor', amount: 349.99, date: '2026-02-10', region: 'West' },
      { orderId: 'ORD006', product: 'Keyboard', amount: 79.99, date: '2026-02-12', region: 'North' },
    ];
  }

  protected formatReport(processedData: Record<string, any>): ReportData {
    const records = processedData.records as Record<string, any>[];
    const totalRevenue = records.reduce((sum, r) => sum + r.amount, 0);
    const avgOrderValue = totalRevenue / records.length;

    const byRegion: Record<string, number> = {};
    for (const record of records) {
      byRegion[record.region] = (byRegion[record.region] ?? 0) + record.amount;
    }

    return {
      title: 'Sales Report',
      generatedAt: new Date().toISOString(),
      type: 'sales',
      data: processedData,
      summary: {
        totalRevenue: Math.round(totalRevenue * 100) / 100,
        averageOrderValue: Math.round(avgOrderValue * 100) / 100,
        totalOrders: records.length,
        revenueByRegion: byRegion,
      },
    };
  }
}

import { ReportGenerator, ReportData } from './report-generator';

export class InventoryReportGenerator extends ReportGenerator {
  protected gatherData(): Record<string, any>[] {
    return [
      { sku: 'SKU001', name: 'Laptop', stock: 45, reorderLevel: 10, category: 'electronics', unitCost: 650 },
      { sku: 'SKU002', name: 'Headphones', stock: 120, reorderLevel: 30, category: 'electronics', unitCost: 25 },
      { sku: 'SKU003', name: 'Running Shoes', stock: 8, reorderLevel: 15, category: 'sports', unitCost: 45 },
      { sku: 'SKU004', name: 'Novel', stock: 200, reorderLevel: 50, category: 'books', unitCost: 5 },
      { sku: 'SKU005', name: 'Tablet', stock: 3, reorderLevel: 10, category: 'electronics', unitCost: 300 },
      { sku: 'SKU006', name: 'Yoga Mat', stock: 75, reorderLevel: 20, category: 'sports', unitCost: 12 },
    ];
  }

  protected formatReport(processedData: Record<string, any>): ReportData {
    const records = processedData.records as Record<string, any>[];
    const lowStockItems = records.filter((r) => r.stock < r.reorderLevel);
    const totalInventoryValue = records.reduce((sum, r) => sum + r.stock * r.unitCost, 0);

    const byCategory: Record<string, number> = {};
    for (const record of records) {
      byCategory[record.category] = (byCategory[record.category] ?? 0) + record.stock;
    }

    return {
      title: 'Inventory Report',
      generatedAt: new Date().toISOString(),
      type: 'inventory',
      data: processedData,
      summary: {
        totalProducts: records.length,
        totalInventoryValue: Math.round(totalInventoryValue * 100) / 100,
        lowStockItems: lowStockItems.map((i) => ({ sku: i.sku, name: i.name, stock: i.stock, reorderLevel: i.reorderLevel })),
        stockByCategory: byCategory,
      },
    };
  }
}

import { ReportGenerator, ReportData } from './report-generator';

export class CustomerReportGenerator extends ReportGenerator {
  protected gatherData(): Record<string, any>[] {
    return [
      { customerId: 'C001', name: 'Alice Johnson', totalSpent: 2499.97, orderCount: 5, tier: 'gold', joinDate: '2024-03-15' },
      { customerId: 'C002', name: 'Bob Smith', totalSpent: 149.98, orderCount: 2, tier: 'bronze', joinDate: '2025-08-20' },
      { customerId: 'C003', name: 'Carol Williams', totalSpent: 5899.94, orderCount: 12, tier: 'platinum', joinDate: '2023-01-10' },
      { customerId: 'C004', name: 'David Brown', totalSpent: 799.99, orderCount: 3, tier: 'silver', joinDate: '2025-01-05' },
      { customerId: 'C005', name: 'Eve Davis', totalSpent: 3249.95, orderCount: 8, tier: 'gold', joinDate: '2024-06-22' },
    ];
  }

  protected formatReport(processedData: Record<string, any>): ReportData {
    const records = processedData.records as Record<string, any>[];
    const totalRevenue = records.reduce((sum, r) => sum + r.totalSpent, 0);
    const avgSpendPerCustomer = totalRevenue / records.length;
    const totalOrders = records.reduce((sum, r) => sum + r.orderCount, 0);

    const byTier: Record<string, number> = {};
    for (const record of records) {
      byTier[record.tier] = (byTier[record.tier] ?? 0) + 1;
    }

    const topCustomers = [...records]
      .sort((a, b) => b.totalSpent - a.totalSpent)
      .slice(0, 3)
      .map((c) => ({ name: c.name, totalSpent: c.totalSpent, tier: c.tier }));

    return {
      title: 'Customer Report',
      generatedAt: new Date().toISOString(),
      type: 'customer',
      data: processedData,
      summary: {
        totalCustomers: records.length,
        totalRevenue: Math.round(totalRevenue * 100) / 100,
        averageSpendPerCustomer: Math.round(avgSpendPerCustomer * 100) / 100,
        totalOrders,
        customersByTier: byTier,
        topCustomers,
      },
    };
  }
}

NestJS Integration

Each concrete generator is decorated with @Injectable() and registered as a provider. The controller injects all generators and selects the correct one based on the route parameter. The abstract ReportGenerator base class is not injectable — it serves as a contract for subclasses. This maps well to NestJS’s provider system where injectable services can use inheritance.

When to Use

Several classes have similar algorithms that differ in only a few steps.
You want to enforce a fixed algorithm structure while allowing customization of specific steps.
You want to consolidate shared behavior in a base class and let subclasses fill in the gaps.

When NOT to Use

Each implementation has a completely different algorithm — forcing them into a template creates awkward, empty overrides.
The number of customizable steps is so large that subclasses override nearly every method, defeating the purpose.

Strategy

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

Factory Method

Define an interface for creating an object, but let subclasses decide which class to instantiate.