business-layer-extensions

Business Layer Extensions

The business layer layers cross-cutting concerns onto core domain logic with a decorator pattern: each extension wraps an ExtBusiness and delegates to it. Wrap, never modify the core Business. An extension that adds tracing to one method must still implement every other method as a plain pass-through.

It comes in three coordinated pieces: the seam on the bus (Piece 1), the extension package itself (Piece 2), and the wiring that registers it (Piece 3).

Checklist

1. Seam exists? Confirm the target <x>bus.go has ExtBusiness, Extension, and the reverse-apply loop in NewBusiness. If not, add them (piece 1).
2. Create extensions/<x><concern>/<x><concern>.go (piece 2).
3. Implement EVERY ExtBusiness method — wrap the relevant ones, pass the rest straight through to ext.bus. Missing one fails to satisfy the interface and won't compile.
4. Wire into api/services/*/main.go in the right order (piece 3).

Piece 1 — the seam (in <x>bus/<x>bus.go)

// ExtBusiness lists every public method an extension can wrap.
type ExtBusiness interface {
	Create(ctx context.Context, input CreateInput) (Model, error)
	// ... every other public business method
}

// Extension wraps a new layer of business logic around the existing logic.
type Extension func(ExtBusiness) ExtBusiness

func NewBusiness(log *logger.Logger, delegate *delegate.Delegate, storer Storer, extensions ...Extension) ExtBusiness {
	b := ExtBusiness(&Business{ /* ... */ })

	for i := len(extensions) - 1; i >= 0; i-- { // reverse: first-listed = outermost
		if ext := extensions[i]; ext != nil {
			b = ext(b)
		}
	}
	return b
}

Piece 2 — the extension (extensions/<x><concern>/<x><concern>.go)

Package name is <x><concern> (e.g. widgetotel, widgetlog). Struct holds the wrapped bus plus any deps; NewExtension returns the closure.

// Package widgetotel provides an extension for WidgetBus to add OTEL related
// code on top of it without changing the existing logic.
package widgetotel

type Extension struct {
	bus widgetbus.ExtBusiness
}

func NewExtension() widgetbus.Extension {
	return func(bus widgetbus.ExtBusiness) widgetbus.ExtBusiness {
		return &Extension{bus: bus}
	}
}

// Wrapped method — adds the concern, then delegates.
func (ext *Extension) Create(ctx context.Context, input widgetbus.CreateWidgetInput) (widgetbus.Widget, error) {
	ctx, span := otel.AddSpan(ctx, "business.widgetbus.create")
	defer span.End()

	w, err := ext.bus.Create(ctx, input)
	if err != nil {
		span.RecordError(err)
		span.SetStatus(codes.Error, err.Error())
		return w, err
	}
	span.SetStatus(codes.Ok, "")
	return w, nil
}

// Pass-through method — NOT relevant to this concern, but REQUIRED for the interface.
func (ext *Extension) Delete(ctx context.Context, w widgetbus.Widget) error {
	return ext.bus.Delete(ctx, w)
}