Chain of Responsibility Design Pattern

public abstract class Approver {

    private Approver next;

    public Approver linkTo(Approver next) {
        this.next = next;
        return next;                 // returns the LINK, so wiring reads in order
    }

    public final Decision review(Expense expense) {
        if (canHandle(expense)) {
            return approve(expense);
        }
        if (next == null) {
            // Never return quietly. An expense that vanishes is worse than one
            // that's rejected, because nobody finds out for a month.
            throw new NoApproverFound(expense);
        }
        return next.review(expense);
    }

    protected abstract boolean canHandle(Expense e);
    protected abstract Decision approve(Expense e);
}

public final class ManagerApprover extends Approver {
    protected boolean canHandle(Expense e) { return e.amount().lte(Money.gbp(5_000)); }
    protected Decision approve(Expense e)  { return Decision.approvedBy("manager", e); }
}

// Assembled once, in one place:
Approver head = new TeamLeadApprover();
head.linkTo(new ManagerApprover())
    .linkTo(new DirectorApprover())
    .linkTo(new BoardApprover());     // always accepts — terminates the chain

head.review(expense);

// Worth knowing: the linked-list version above is GoF's, but most modern Java
// writes `List<Approver>` and a loop — same pattern, no `next` field to wire
// wrong, and the order is visible as a list you can print and test.

from typing import Callable, Iterable

# Python rarely builds the linked list. A list of predicates-and-actions is the
# same pattern with less machinery, and the ORDER is right there in the source.

Approver = tuple[str, Callable[[Expense], bool], Callable[[Expense], Decision]]

CHAIN: list[Approver] = [
    ("team lead", lambda e: e.amount <= 500,   lambda e: Decision("team lead", e)),
    ("manager",   lambda e: e.amount <= 5_000, lambda e: Decision("manager", e)),
    ("director",  lambda e: e.amount <= 50_000, lambda e: Decision("director", e)),
    ("board",     lambda e: True,              lambda e: Decision("board", e)),
]


def review(expense: Expense, chain: Iterable[Approver] = CHAIN) -> Decision:
    for name, handles, approve in chain:
        if handles(expense):
            return approve(expense)
    raise NoApproverFound(expense)      # only reachable if you drop the fallback


# The standard library uses the classic form: a logging.Logger passes a record
# to its own handlers, then to its PARENT logger's handlers, all the way up to
# the root — unless a logger sets `propagate = False`, which cuts the chain.
# Duplicated log lines are almost always this pattern misconfigured.

#include <memory>
#include <optional>

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

    void setNext(std::shared_ptr<Approver> next) { next_ = std::move(next); }

    Decision review(const Expense& e) {
        if (canHandle(e)) return approve(e);
        if (!next_) throw NoApproverFound{e};
        return next_->review(e);
    }

protected:
    virtual bool canHandle(const Expense&) const = 0;
    virtual Decision approve(const Expense&) = 0;

private:
    std::shared_ptr<Approver> next_;
};

// A vector of std::function is usually the better C++ too — no virtual
// dispatch, no ownership graph, and the chain is data you can build at runtime:
//
//   using Rule = std::function<std::optional<Decision>(const Expense&)>;
//   std::vector<Rule> chain = { teamLead, manager, director, board };
//
//   for (const auto& rule : chain)
//       if (auto d = rule(expense)) return *d;
//   throw NoApproverFound{expense};
//
// C++ exception handling is itself a chain of responsibility: a throw walks up
// the stack offering the exception to each enclosing catch until one matches.

// ASP.NET Core's middleware pipeline IS this pattern, and it's the version most
// C# developers meet first. Each component gets the request and decides whether
// to handle it or call next().

public interface IApprover
{
    Decision Review(Expense expense);
}

public sealed class ManagerApprover(IApprover next) : IApprover
{
    public Decision Review(Expense expense) =>
        expense.Amount <= 5_000m
            ? Decision.ApprovedBy("manager", expense)
            : next.Review(expense);
}

public sealed class BoardApprover : IApprover        // the terminator
{
    public Decision Review(Expense expense) => Decision.ApprovedBy("board", expense);
}

// Built inside-out, so the LAST one added is the first consulted:
IApprover chain =
    new TeamLeadApprover(
        new ManagerApprover(
            new DirectorApprover(
                new BoardApprover())));

// The framework version of the same shape:
//
//     app.Use(async (ctx, next) => { if (!Authorised(ctx)) { ctx.Response.StatusCode = 403; return; }
//                                    await next(); });
//
// Returning without awaiting next() short-circuits the pipeline — that IS
// "this one is mine", and forgetting the await is the classic pipeline bug.

// Express middleware is a chain of responsibility that most JavaScript
// developers use daily without naming it: each function either responds
// (handling the request) or calls next() to pass it along.

const chain = [
  { name: 'team lead', handles: e => e.amount <= 500 },
  { name: 'manager', handles: e => e.amount <= 5_000 },
  { name: 'procurement', handles: e => e.vendorIsNew },
  { name: 'director', handles: e => e.amount <= 50_000 },
  { name: 'board', handles: () => true },          // terminator
]

export const review = expense => {
  for (const link of chain) {
    if (link.handles(expense)) return { approvedBy: link.name, expense }
  }
  throw new NoApproverFound(expense)
}

// The linked version, when each handler needs its own state or async work:
const link = (handles, approve, next) => async expense =>
  handles(expense) ? approve(expense) : next(expense)

// DOM event bubbling is the browser's own chain: an event offered to the
// target, then to each ancestor in turn, until something calls
// stopPropagation() — which is precisely "this one is mine".

package approvals

// The idiomatic Go chain is a slice, because there is no inheritance to build a
// linked list with and no reason to want one.

type Approver struct {
	Name    string
	Handles func(Expense) bool
	Approve func(Expense) Decision
}

func Review(e Expense, chain []Approver) (Decision, error) {
	for _, a := range chain {
		if a.Handles(e) {
			return a.Approve(e), nil
		}
	}
	return Decision{}, fmt.Errorf("no approver for %s: %w", e.ID, ErrUnhandled)
}

// The http.Handler middleware form, where every link wraps the next:
//
//	func RequireAuth(next http.Handler) http.Handler {
//		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
//			if !authorised(r) {
//				http.Error(w, "forbidden", http.StatusForbidden)
//				return          // ← handled here; the chain stops
//			}
//			next.ServeHTTP(w, r)
//		})
//	}
//
// Note the two shapes differ in an important way: the slice version returns an
// ERROR when nothing matches, so an unhandled request cannot be silent. The
// middleware version can silently do nothing if a handler forgets to write a
// response — the same trap as the missing terminator.

type Decision = { approvedBy: string; expense: Expense }

interface Link {
  readonly name: string
  handles(expense: Expense): boolean
  approve(expense: Expense): Decision
}

const chain: readonly Link[] = [
  { name: 'team lead', handles: e => e.amount <= 500, approve: e => ({ approvedBy: 'team lead', expense: e }) },
  { name: 'manager', handles: e => e.amount <= 5_000, approve: e => ({ approvedBy: 'manager', expense: e }) },
  { name: 'board', handles: () => true, approve: e => ({ approvedBy: 'board', expense: e }) },
]

export function review(expense: Expense): Decision {
  for (const link of chain) {
    if (link.handles(expense)) return link.approve(expense)
  }
  throw new NoApproverFound(expense)
}

// The type system can close the hole the pattern is famous for. Declare the
// return as Decision (not Decision | undefined) and the compiler will not let
// `review` fall off the end without throwing — so "nobody handled it" becomes a
// compile error rather than a silent afternoon.
//
// If a chain genuinely may not handle something, say so in the type and force
// every caller to deal with it:
//   function review(e: Expense): Decision | Unhandled