platform

type App ¶

type App struct {
	// contains filtered or unexported fields
}

App is the application container: logger, metrics, health checks and the values modules share with each other.

Modules find each other through the container instead of through edits in main.go, which is why adding or removing a module needs no manual changes in project code.

func NewApp(log *slog.Logger) *App

func (a *App) AddHealthCheck(name string, check func(context.Context) error)

func (a *App) Logger() *slog.Logger

func (a *App) Metrics() *prometheus.Registry

func (a *App) Role() string

func (a *App) Serves(role string) bool

func (a *App) Service() string

type Config ¶

type Config struct {
	Service         string        // service name in logs
	Role            string        // what this process does: all, api or worker; all by default
	OpsAddr         string        // ops server address, :9090 by default
	ShutdownTimeout time.Duration // overall shutdown timeout, 20s by default
	Logger          *slog.Logger

	// OnStarted is called once every module and the ops server are up. Tests and local
	// runs use it to learn the actual ops address.
	OnStarted func(opsAddr string)
}

Config holds startup parameters. Empty fields fall back to defaults.

type HealthChecker ¶

type HealthChecker interface {
	Health(ctx context.Context) error
}

HealthChecker adds the module to the /health response.

type Module ¶

type Module interface {
	// Name identifies the module in logs, health output and errors.
	Name() string

	// Init prepares the module and puts whatever it shares into the container.
	// Modules are initialised in the order they are listed.
	Init(ctx context.Context, app *App) error
}

Module is an infrastructure part of the application: database, queues, API, admin UI.

Only Name and Init are required. Everything else is optional: the platform checks for Starter, Stopper and HealthChecker and calls them when implemented, so a module without background work stays a few lines long.

type Starter ¶

type Starter interface {
	Start(ctx context.Context) error
}

Starter runs background work: queue workers, servers, subscriptions. It is called after the domain is wired so that every handler is registered before traffic starts.

type Stopper ¶

type Stopper interface {
	Stop(ctx context.Context) error
}

Stopper releases resources. Modules are stopped in reverse order of initialisation, sharing one shutdown timeout.

type Wire ¶

type Wire func(app *App) error

Wire builds the project domain: use cases, handlers, workers. It runs between Init and Start of every module, so queues and servers begin work with handlers in place.