Factory Method Design Pattern

interface Exporter {
    void export(List<Row> rows);
}

public abstract class ReportJob {

    // The factory method. Abstract, so every subclass must answer it.
    protected abstract Exporter createExporter();

    // The real work. Note what isn't here: any concrete exporter class.
    public final void run() {
        List<Row> rows = query();
        createExporter().export(rows);
    }

    protected abstract List<Row> query();
}

public class InvoiceJob extends ReportJob {
    @Override protected Exporter createExporter() { return new PdfExporter(); }
    @Override protected List<Row> query() { return invoiceRepo.unpaid(); }
}

public class AnalyticsJob extends ReportJob {
    @Override protected Exporter createExporter() { return new CsvExporter(); }
    @Override protected List<Row> query() { return events.lastWeek(); }
}

// Adding XlsxExporter means adding one subclass. ReportJob.run() is untouched.

from abc import ABC, abstractmethod
from typing import Protocol


class Exporter(Protocol):
    def export(self, rows: list[Row]) -> None: ...


class ReportJob(ABC):
    @abstractmethod
    def create_exporter(self) -> Exporter: ...

    @abstractmethod
    def query(self) -> list[Row]: ...

    def run(self) -> None:
        self.create_exporter().export(self.query())


class InvoiceJob(ReportJob):
    def create_exporter(self) -> Exporter:
        return PdfExporter()

    def query(self) -> list[Row]:
        return invoice_repo.unpaid()


# Worth knowing: because Python has first-class functions and classes are
# objects, you very often don't need the subclass at all —
#
#     class ReportJob:
#         def __init__(self, make_exporter: Callable[[], Exporter], ...):
#             self._make_exporter = make_exporter
#
# is the same idea with none of the inheritance. Reach for the subclass form
# when the creator has other behaviour worth inheriting too.

#include <memory>
#include <vector>

struct Exporter {
    virtual ~Exporter() = default;
    virtual void export_rows(const std::vector<Row>&) = 0;
};

class ReportJob {
public:
    virtual ~ReportJob() = default;

    void run() {
        create_exporter()->export_rows(query());
    }

protected:
    // Returns a smart pointer: the creator hands over ownership and the caller
    // never has to know the concrete type in order to destroy it correctly.
    virtual std::unique_ptr<Exporter> create_exporter() = 0;
    virtual std::vector<Row> query() = 0;
};

class InvoiceJob : public ReportJob {
protected:
    std::unique_ptr<Exporter> create_exporter() override {
        return std::make_unique<PdfExporter>();
    }
    std::vector<Row> query() override { return invoice_repo.unpaid(); }
};

// The virtual destructor on Exporter is not optional here — deleting a
// PdfExporter through an Exporter* without it is undefined behaviour.

public interface IExporter
{
    void Export(IReadOnlyList<Row> rows);
}

public abstract class ReportJob
{
    // The factory method.
    protected abstract IExporter CreateExporter();
    protected abstract IReadOnlyList<Row> Query();

    public void Run() => CreateExporter().Export(Query());
}

public sealed class InvoiceJob : ReportJob
{
    protected override IExporter CreateExporter() => new PdfExporter();
    protected override IReadOnlyList<Row> Query() => _invoices.Unpaid();
}

// In practice a .NET codebase usually reaches for the container instead:
//
//     services.AddKeyedTransient<IExporter, PdfExporter>("pdf");
//     ... ctor: IServiceProvider sp
//     sp.GetRequiredKeyedService<IExporter>(format)
//
// Same decoupling, chosen by configuration rather than by subclass.

// The exporters only have to satisfy a shape, so no interface declaration and
// no base class is strictly required.

class ReportJob {
  // Subclasses override this. The base throws so a missing override is a loud
  // failure rather than a silent undefined.
  createExporter() {
    throw new Error('createExporter() must be overridden')
  }

  async run() {
    const rows = await this.query()
    return this.createExporter().export(rows)
  }
}

class InvoiceJob extends ReportJob {
  createExporter() { return new PdfExporter() }
  query() { return invoiceRepo.unpaid() }
}

// The idiomatic JavaScript alternative is usually a plain function, because
// functions are values and you rarely need the class ceremony:
//
//   const runReport = (query, makeExporter) =>
//     query().then(rows => makeExporter().export(rows))
//
//   runReport(invoiceRepo.unpaid, () => new PdfExporter())

package report

// Go has no inheritance, so the classic "subclass overrides the factory method"
// form does not exist. The equivalent — and the more direct expression of the
// same intent — is to accept the factory as a function value.

type Exporter interface {
	Export(rows []Row) error
}

type Job struct {
	Query         func() ([]Row, error)
	NewExporter   func() Exporter // the factory method, as data
}

func (j Job) Run() error {
	rows, err := j.Query()
	if err != nil {
		return err
	}
	return j.NewExporter().Export(rows)
}

// Wiring, in main():
//
//	invoice := report.Job{
//		Query:       invoiceRepo.Unpaid,
//		NewExporter: func() report.Exporter { return PdfExporter{} },
//	}
//
// Adding ParquetExporter adds one function literal at the wiring site and
// changes nothing in Run().

interface Exporter {
  export(rows: Row[]): Promise<void>
}

abstract class ReportJob {
  // `abstract` makes the override a compile-time requirement, which is the one
  // thing the JavaScript version can only enforce at runtime.
  protected abstract createExporter(): Exporter
  protected abstract query(): Promise<Row[]>

  async run(): Promise<void> {
    await this.createExporter().export(await this.query())
  }
}

class InvoiceJob extends ReportJob {
  protected createExporter(): Exporter { return new PdfExporter() }
  protected query(): Promise<Row[]> { return invoiceRepo.unpaid() }
}

// A type-safe registry is often the better fit and keeps exhaustiveness checks:
//
//   const EXPORTERS = { pdf: () => new PdfExporter(),
//                       csv: () => new CsvExporter() } as const
//   type Format = keyof typeof EXPORTERS   // 'pdf' | 'csv'
//
// Now an unhandled format is a compile error, not a runtime surprise.