--- name: kratos-wire-provider description: Manages Wire dependency injection providers in go-kratos microservices. Adds constructors to ProviderSets and regenerates Wire code. Use when integrating new components into dependency injection. --- Add constructor functions to appropriate Wire ProviderSets and regenerate dependency injection code for go-kratos microservices. <\/objective> To add a provider to the biz layer: 1. **Add to ProviderSet** in `internal\/biz\/biz.go`: ```go var ProviderSet = wire.NewSet( NewSymbolValidator, NewSymbolUseCase, NewProductUseCase, \/\/ Add your constructor ) ``` 2. **Regenerate Wire code**: ```bash cd services\/{service-name} make generate ``` <\/quick_start> ## ProviderSet Locations **Data Layer** (`internal\/data\/data.go`): - Repository implementations - Database connection - Transaction manager ```go var ProviderSet = wire.NewSet( NewData, \/\/ Database setup NewTransaction, \/\/ Transaction manager repo.NewSymbolRepo, repo.NewProductRepo, ) ``` **Business Layer** (`internal\/biz\/biz.go`): - Use cases - Validators ```go var ProviderSet = wire.NewSet( NewSymbolValidator, NewSymbolUseCase, NewProductUseCase, ) ``` **Service Layer** (`internal\/service\/service.go`): - Service handlers ```go var ProviderSet = wire.NewSet( NewSymbolService, NewProductService, ) ``` **Server Layer** (`internal\/server\/server.go`): - HTTP and gRPC servers ```go var ProviderSet = wire.NewSet( NewHTTPServer, NewGRPCServer, ) ``` <\/provider_sets> ## Wire Generation Process **File**: `cmd\/{service}\/wire.go` defines dependencies: ```go \/\/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: ```bash GOWORK=off go generate .\/cmd\/{service}\/... ``` <\/wire_process> ## 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 **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 **Optional**: Use Wire build tags for conditional providers: ```go \/\/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> 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> ## 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>