Contracts and dependency injection

// internal/pricing/contract.go
package pricing

import "context"

// Service defines the pricing package boundary.
type Service interface {
	// Quote prices qty units of sku, in cents.
	Quote(ctx context.Context, sku string, qty int) (int64, error)
}

// Catalog is the one thing pricing needs from the product catalog.
type Catalog interface {
	UnitPrice(ctx context.Context, sku string) (int64, error)
}

// internal/pricing/service.go
type Deps struct {
	Logger  *slog.Logger
	Config  *config.Config
	Catalog Catalog
}

func New(deps Deps) (Service, error) {
	return &service{deps: deps}, nil
}

// Code generated by forge. DO NOT EDIT.
// Source: contract.go in this package.

// MockCatalog is a test mock for the Catalog interface.
//
// The embedded contractkit.Recorder records every call so tests can
// assert call counts and captured arguments. Set XxxFunc fields to
// override per-method behaviour; unset methods return the canonical
// "MockCatalog.<Method>Func not set" error.
type MockCatalog struct {
	contractkit.Recorder
	UnitPriceFunc func(context.Context, string) (int64, error)
}

// UnitPrice records the call and delegates to UnitPriceFunc when set.
func (m *MockCatalog) UnitPrice(ctx context.Context, sku string) (int64, error) {
	m.Recorder.Record("UnitPrice", ctx, sku)
	if m.UnitPriceFunc != nil {
		return m.UnitPriceFunc(ctx, sku)
	}
	return 0, contractkit.MockNotSet("MockCatalog", "UnitPrice")
}

// Compile-time check.
var _ Catalog = (*MockCatalog)(nil)

func (o *forgeMiddlewareService) Quote(ctx context.Context, sku string, qty int) (int64, error) {
	return o.chain.Around(ctx, "pricing.Quote", func(ctx context.Context) (int64, error) {
		return o.inner.Quote(ctx, sku, qty)
	})
}

type Deps struct {
	DB     orm.Context
	Logger *slog.Logger
	Config *config.Config
	// Add your dependencies here (e.g. Repo Repository). Required ones get
	// a validateDeps() check below. Tag intentionally-optional fields with
	// the `forge:optional-dep` directive directly above the field.
}

// validateDeps returns an error if any required Deps field is nil. The
// gate runs once at construction so handlers need no per-RPC nil-checks.
func (d Deps) validateDeps() error {
	if d.Logger == nil {
		return fmt.Errorf("customers: Deps.Logger is required")
	}
	if d.Config == nil {
		return fmt.Errorf("customers: Deps.Config is required")
	}
	if d.DB == nil {
		return fmt.Errorf("Deps.DB is required by the generated CRUD handlers — set DATABASE_URL (the generated bootstrap constructs the ORM client from it)")
	}
	…
}

func New(deps Deps) (*Service, error) {
	if err := deps.validateDeps(); err != nil {
		return nil, err
	}
	return &Service{deps: deps}, nil
}

// ORMDeps is the pool the ORM client runs on.
type ORMDeps struct {
	DB *DB
}

// NewORM is the ORM client over the serving pool — what a handler's
// `DB orm.Context` Deps field resolves to. No database, no client.
func NewORM(d ORMDeps) (*orm.Client, error) {
	if d.DB.DB == nil {
		return nil, nil
	}
	return orm.NewClientWithDB(d.DB.DB, "postgres")
}

func (g *Graph) newCustomers() (*customers.Service, error) {
	return customers.New(customers.Deps{
		Logger: g.Log,
		Config: g.Cfg,
	})
}

func (g *Graph) newCustomers() (*customers.Service, error) {
	return customers.New(customers.Deps{
		Logger: g.Log,
		Config: g.Cfg,
		DB:     g.ORM(),
	})
}

func (g *Graph) newPricing() (pricing.Service, error) {
	svc, err := pricing.New(pricing.Deps{
		Logger: g.Log,
		Config: g.Cfg,
	})
	if err != nil {
		return nil, err
	}
	return pricing.NewServiceWithForgeMiddleware(svc), nil
}

⚠️  1 node(s) no root reaches are left out of the composition graph, because forge cannot fill their Deps: Pricing. graph_gen.go has no accessor for them and compose.go gets no constructor until a root reaches one — then generate names every provider it lacks. `forge lint --graph` reports each (forge-graph-unreachable)