Skip to content

Solizardking/clawd-bot / .agents/skills/golang-google-wire

golang-google-wire

Verified

Compile-time dependency injection in Golang using google/wire — wire.NewSet, wire.Build, wire.Bind (interface→concrete), wire.Struct, wire.Value, wire.InterfaceValue, wire.FieldsOf, cleanup functions, //go:build wireinject injector files, and generated wire_gen.go. Apply when using or adopting google/wire, when the codebase imports `github.com/google/wire`, or when wiring an application graph at compile time via `wire.Build`. For runtime DI with reflection, see `samber/cc-skills-golang@golang-uber-dig` skill.

FileKindSize
SKILL.mdskill md10.9 KB
evals/evals.jsonconfig14.5 KB
references/advanced.mdmarkdown6.8 KB
references/recipes.mdmarkdown6.6 KB
references/testing.mdmarkdown5.0 KB

references/recipes.md

View on GitHub
# Recipes — google/wire

End-to-end examples. Each recipe is self-contained.

## HTTP Server with Postgres and Redis

A typical service: parsed config → DB (with cleanup) → Redis (with cleanup) → repo → service → HTTP server.

```
myapp/
├── config/
│   ├── config.go
│   └── wire.go
├── infra/
│   ├── db.go
│   ├── cache.go
│   └── wire.go
├── repo/
│   ├── user.go
│   └── wire.go
├── service/
│   ├── user.go
│   └── wire.go
├── transport/
│   ├── handler.go
│   └── wire.go
├── wire.go        // injector — //go:build wireinject
├── wire_gen.go    // generated — commit this
└── main.go
```

```go
// config/config.go
type Config struct {
    Addr      string
    DSN       string
    CacheAddr string
}

func NewConfig() *Config {
    return &Config{
        Addr:      env("ADDR", ":8080"),
        DSN:       mustEnv("DATABASE_URL"),
        CacheAddr: env("REDIS_ADDR", "localhost:6379"),
    }
}

// config/wire.go
var ConfigSet = wire.NewSet(NewConfig)
```

```go
// infra/db.go
func NewDB(cfg *config.Config) (*sql.DB, func(), error) {
    db, err := sql.Open("postgres", cfg.DSN)
    if err != nil { return nil, nil, err }
    if err := db.Ping(); err != nil { db.Close(); return nil, nil, err }
    return db, func() { db.Close() }, nil
}

// infra/cache.go
func NewRedis(cfg *config.Config) (*redis.Client, func(), error) {
    c := redis.NewClient(&redis.Options{Addr: cfg.CacheAddr})
    if err := c.Ping(context.Background()).Err(); err != nil {
        return nil, nil, err
    }
    return c, func() { c.Close() }, nil
}

// infra/wire.go
var InfraSet = wire.NewSet(NewDB, NewRedis)
```

```go
// repo/user.go
type UserStore interface {
    GetUser(ctx context.Context, id int64) (*User, error)
}

type PostgresUserRepo struct{ db *sql.DB }

func NewUserRepo(db *sql.DB) *PostgresUserRepo { return &PostgresUserRepo{db: db} }

// repo/wire.go
var RepoSet = wire.NewSet(
    NewUserRepo,
    wire.Bind(new(UserStore), new(*PostgresUserRepo)),
)
```

```go
// service/user.go
type UserService struct {
    store  repo.UserStore
    cache  *redis.Client
}

func NewUserService(store repo.UserStore, cache *redis.Client) *UserService {
    return &UserService{store: store, cache: cache}
}

// service/wire.go
var ServiceSet = wire.NewSet(NewUserService)
```

```go
// wire.go
//go:build wireinject

package main

func InitApp() (*transport.Handler, func(), error) {
    wire.Build(
        config.ConfigSet,
        infra.InfraSet,
        repo.RepoSet,
        service.ServiceSet,
        transport.NewHandler,
    )
    return nil, nil, nil
}
```

```go
// main.go
func main() {
    handler, cleanup, err := InitApp()
    if err != nil { log.Fatal(err) }
    defer cleanup()

    srv := &http.Server{Addr: ":8080", Handler: handler}
    log.Fatal(srv.ListenAndServe())
}
```

## Multiple Build Variants (Prod vs Dev)

Use separate injector files with `//go:build` constraints to select different provider sets at build time.

```go
// wire_prod.go
//go:build wireinject && !dev

package main

func InitApp() (*App, func(), error) {
    wire.Build(ProdSet, NewApp)
    return nil, nil, nil
}

// wire_dev.go
//go:build wireinject && dev

package main

func InitApp() (*App, func(), error) {
    wire.Build(DevSet, NewApp) // DevSet swaps real DB for in-memory SQLite
    return nil, nil, nil
}
```

Use `-output_file_prefix` to write separate output files — both commands would otherwise overwrite the same `wire_gen.go`:

```bash
wire -tags dev -output_file_prefix=wire_gen_dev gen .
wire -output_file_prefix=wire_gen_prod gen .
```

Add build constraints to the generated files so only one compiles per build:

```go
// wire_gen_prod.go — add at the top (after wire writes it)
//go:build !dev

// wire_gen_dev.go — add at the top
//go:build dev
```

Commit both generated files. At build time, only the matching file is compiled.

## Cleanup-Heavy Graph

When several providers need shutdown coordination, wire's reverse-order cleanup is essential.

```go
// Providers return (T, func(), error)
func NewDBPool(cfg *Config) (*pgxpool.Pool, func(), error) {
    pool, err := pgxpool.New(context.Background(), cfg.DSN)
    if err != nil { return nil, nil, err }
    return pool, func() { pool.Close() }, nil
}

func NewOTelExporter(cfg *Config) (*otlptrace.Exporter, func(), error) {
    exp, err := otlptracegrpc.New(context.Background(), ...)
    if err != nil { return nil, nil, err }
    return exp, func() { exp.Shutdown(context.Background()) }, nil
}

func NewTracerProvider(exp *otlptrace.Exporter) (*trace.TracerProvider, func(), error) {
    tp := trace.NewTracerProvider(trace.WithBatcher(exp))
    return tp, func() { tp.Shutdown(context.Background()) }, nil
}
```

Wire generates shutdown in reverse: `TracerProvider` → `OTelExporter` → `DBPool`. Each cleanup runs before its dependencies shut down — guaranteeing in-flight spans are flushed before the exporter closes.

## Embedding Wire in a CLI

Wire produces a struct, not an app framework. You control the lifecycle:

```go
// wire.go
//go:build wireinject

package cmd

func InitServer(cfg *Config) (*http.Server, func(), error) {
    wire.Build(InfraSet, ServiceSet, NewHTTPServer)
    return nil, nil, nil
}

// cmd/serve.go
func runServe(cfg *Config) error {
    srv, cleanup, err := InitServer(cfg)
    if err != nil { return err }
    defer cleanup()

    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()
    <-quit
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    return srv.Shutdown(ctx)
}
```

Unlike `fx.Run()`, wire does not manage the lifecycle loop. Implement signal handling and graceful shutdown explicitly. This is a feature for CLI tools that spin up short-lived services and need precise control over the shutdown sequence.

## Passing External Values to Wire

Values built before wire runs (parsed config, test doubles) become injector parameters:

```go
//go:build wireinject

// cfg is resolved outside the graph — treated as a provided *Config
func InitApp(cfg *Config) (*App, func(), error) {
    wire.Build(InfraSet, ServiceSet, NewApp)
    return nil, nil, nil
}

// main.go
cfg, err := config.Load()
if err != nil { log.Fatal(err) }
app, cleanup, err := InitApp(cfg)
```

The parameter `cfg *Config` satisfies any downstream provider that requests `*Config` — no `wire.Value` or extra set entry needed.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall