kratos-wire-provider

<quick_start> To add a provider to the biz layer:

1. Add to ProviderSet in internal/biz/biz.go:

var ProviderSet = wire.NewSet(
	NewSymbolValidator,
	NewSymbolUseCase,
	NewProductUseCase,  // Add your constructor
)

2. Regenerate Wire code:

cd services/{service-name}
make generate

</quick_start>

<provider_sets>

ProviderSet Locations

Data Layer (internal/data/data.go):

• Repository implementations
• Database connection
• Transaction manager

var ProviderSet = wire.NewSet(
	NewData,           // Database setup
	NewTransaction,    // Transaction manager
	repo.NewSymbolRepo,
	repo.NewProductRepo,
)

Business Layer (internal/biz/biz.go):

• Use cases
• Validators

var ProviderSet = wire.NewSet(
	NewSymbolValidator,
	NewSymbolUseCase,
	NewProductUseCase,
)

Service Layer (internal/service/service.go):

• Service handlers

var ProviderSet = wire.NewSet(
	NewSymbolService,
	NewProductService,
)

Server Layer (internal/server/server.go):

• HTTP and gRPC servers

var ProviderSet = wire.NewSet(
	NewHTTPServer,
	NewGRPCServer,
)

</provider_sets>

<wire_process>

Wire Generation Process

File: cmd/{service}/wire.go defines dependencies:

//go:build wireinject

func InitApp(*conf.Server, *conf.Data, log.Logger) (*App, error) {
	wire.Build(
		server.ProviderSet,
		service.ProviderSet,
		biz.ProviderSet,
		data.ProviderSet,
		newApp,
	)
	return &App{}, nil
}

Generated: cmd/{service}/wire_gen.go (auto-generated, never edit)

Command: make generate runs:

GOWORK=off go generate ./cmd/{service}/...

</wire_process>

<ordering_rules>

Provider Ordering

Within ProviderSet:

• Alphabetical order (recommended)
• OR grouped by functionality
• Be consistent with existing pattern

Between ProviderSets (in wire.Build):

1. server.ProviderSet (outermost layer)
2. service.ProviderSet
3. biz.ProviderSet
4. data.ProviderSet (innermost layer)
5. newApp (application constructor) </ordering_rules>

<common_tasks>

Common Tasks

Add new repository:

1. Add constructor to data.ProviderSet
2. Run make generate

Add new use case:

1. Add constructor to biz.ProviderSet
2. Run make generate

Add new service handler:

1. Add constructor to service.ProviderSet
2. Run make generate

Troubleshooting:

• If Wire errors, check constructor signatures match interface returns
• Ensure all dependencies are provided in ProviderSets
• Check for circular dependencies
• Run GOWORK=off go mod tidy if module issues </common_tasks>

<wire_annotations>

Wire Annotations

Optional: Use Wire build tags for conditional providers:

//go:build wireinject
// +build wireinject

Providers must:

• Return types that match interface declarations
• Have all parameters available in dependency graph
• Not create circular dependencies </wire_annotations>

<success_criteria> Wire integration is successful when:

• Constructor added to appropriate ProviderSet
• Alphabetical/consistent ordering maintained
• make generate completes without errors
• wire_gen.go updated successfully
• Service compiles: make build
• Tests pass: make test
• No circular dependency errors </success_criteria>

<error_messages>

Common Wire Errors

"no provider found for X": → Add constructor for X to appropriate ProviderSet

"cycle in dependency graph": → Circular dependency detected, refactor to break cycle

"provider returns interface but is not implemented": → Check constructor returns interface type, struct implements all methods

"multiple providers for type": → Same type provided by multiple constructors, remove duplicate </error_messages>