Golang Google Wire

Persona: You are a Go architect using wire for compile-time DI. You let the compiler catch missing dependencies, treat wire_gen.go as committed source, and re-run wire ./... after every graph change.

Dependencies:

• wire: go install github.com/google/wire/cmd/wire@latest

Using google/wire for Compile-Time Dependency Injection in Go

Code-generation DI toolkit. Wire resolves the dependency graph at compile time and emits plain Go constructor calls — no runtime container, no reflection. Errors appear when you run wire ./..., not at first request.

Note: google/wire was archived in August 2025 (feature-complete; bug fixes still accepted).

Official Resources: pkg.go.dev · github.com/google/wire · User Guide · Best Practices

This skill is not exhaustive. Please refer to library documentation and code examples for more information. Context7 can help as a discoverability platform.

go get -tool github.com/google/wire/cmd/wire@latest
go get github.com/google/wire

wire vs. Runtime DI

For lifecycle, lazy loading, and a full matrix see samber/cc-skills-golang@golang-dependency-injection.

Providers

A provider is any Go function — inputs are dependencies, outputs are provided types. Three return forms:

func NewConfig() *Config                          { return &Config{Addr: ":8080"} }
func NewDB(cfg *Config) (*sql.DB, error)          { return sql.Open("postgres", cfg.DSN) }
func NewRedis(cfg *Config) (*redis.Client, func(), error) { // cleanup chained in reverse order
    c := redis.NewClient(&redis.Options{Addr: cfg.RedisAddr})
    return c, func() { c.Close() }, nil
}

Provider Sets

wire.NewSet groups providers for reuse. Sets can reference other sets.

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

// service/wire.go
var ServiceSet = wire.NewSet(
    NewUserRepo,
    NewUserService,
    wire.Bind(new(UserStore), new(*UserRepo)), // interface binding
)

Keep sets small: library sets expose a stable surface (adding inputs or removing outputs breaks downstream injectors). One set per package is a useful default.

Injectors and //go:build wireinject

The injector file declares the initialization function. Wire generates its body into wire_gen.go and replaces the stub.

//go:build wireinject

package main

import "github.com/google/wire"

// Wire generates the body of this function.
func InitApp() (*App, func(), error) {
    wire.Build(InfraSet, ServiceSet, NewApp)
    return nil, nil, nil // replaced by codegen
}

The //go:build wireinject tag prevents the stub from being compiled into the binary — only wire_gen.go (which has no such tag) makes it through go build. Without this tag, both files define the same function, causing a compile error.

Alternative syntax when a dummy return is inconvenient:

func InitApp() (*App, func(), error) {
    panic(wire.Build(InfraSet, ServiceSet, NewApp))
}

Interface Bindings

Wire forbids implicit interface satisfaction — you must declare bindings explicitly so the graph is unambiguous when multiple types implement the same interface.

var Set = wire.NewSet(
    NewPostgresUserRepo,
    wire.Bind(new(UserStore), new(*PostgresUserRepo)), // tell wire: *PostgresUserRepo satisfies UserStore
)

Explicit bindings prevent graph breakage when a new type implementing the same interface is added elsewhere.

Struct Providers and Values

wire.Struct fills struct fields from the graph without a manual constructor. Tag fields wire:"-" to exclude them.

wire.Struct(new(Server), "Logger", "DB") // inject named fields
wire.Struct(new(Server), "*")            // inject all non-excluded fields
wire.Value(Foo{X: 42})                   // constant expression (no fn calls / channels)
wire.InterfaceValue(new(io.Reader), os.Stdin) // interface-typed literal
wire.FieldsOf(new(Config), "DSN", "Addr")    // promote struct fields as graph nodes

See advanced.md for the wire:"-" exclusion tag and wire.FieldsOf details.

Disambiguating Duplicate Types

Wire forbids two providers for the same type. Wrap the underlying type in distinct named types so each has exactly one provider:

type PrimaryDSN string
type ReplicaDSN string

Full Application Example

// wire.go — injector, excluded from binary via build tag
//go:build wireinject

package main

func InitApp() (*App, func(), error) {
    wire.Build(config.ConfigSet, infra.InfraSet, service.ServiceSet, NewApp)
    return nil, nil, nil
}

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

Wire generates wire_gen.go (plain Go, committed, DO NOT EDIT). For a full example with per-package sets, cleanup-heavy graphs, and generated output, see recipes.md.

Codegen Workflow

wire ./...           # regenerate all injectors in the module
wire check ./...     # validate graph without regenerating (fast CI check)

Run wire ./... after every constructor signature change. Add //go:generate go run github.com/google/wire/cmd/wire to injector files so go generate ./... also works. Commit wire_gen.go — it must stay in sync for CI builds.

Best Practices

1. Never edit wire_gen.go — it is overwritten on every wire ./... run. Treat it as a build artifact that happens to be committed; source of truth is the provider and injector files. 2. Always add //go:build wireinject to injector files — omitting it causes duplicate-symbol compile errors because both the stub and the generated file define the same function. 3. Use named types to distinguish values of the same underlying type — wire enforces one provider per type; named types like type DSN string let you have PrimaryDSN and ReplicaDSN coexist. 4. Keep library provider sets minimal and backward-compatible — adding new required inputs breaks downstream injectors; removing outputs does too. Introduce only newly-created types in the same release. 5. Return (T, func(), error) from cleanup providers and let wire chain them — wire generates the correct reverse-order cleanup and handles partial failures (if construction fails midway, only already-built cleanups run). 6. Keep injector files focused — one function per file, one package import at a time. Fat injectors with dozens of wire.Build arguments are hard to reason about; delegate to per-package sets.

Common Mistakes

Testing

Wire generates plain Go constructors, so unit tests use manual injection — no container to clone or reset. For testing patterns (test injectors swapping real providers for fakes, CI stale-check for wire_gen.go), see testing.md.

Further Reading

• advanced.md — cleanup chains, multiple injectors, set nesting, error catalogue, codegen flags, quick reference
• recipes.md — HTTP server, multi-injector build, cleanup-heavy graph, CLI embedding
• testing.md — test injectors, fake bindings, CI stale check

Cross-References

• → See samber/cc-skills-golang@golang-dependency-injection skill for DI concepts and library comparison
• → See samber/cc-skills-golang@golang-uber-dig skill for runtime reflection-based DI without lifecycle
• → See samber/cc-skills-golang@golang-uber-fx skill for runtime DI with lifecycle hooks, modules, and signal-aware Run()
• → See samber/cc-skills-golang@golang-samber-do skill for generics-based DI without reflection
• → See samber/cc-skills-golang@golang-structs-interfaces skill for interface design patterns
• → See samber/cc-skills-golang@golang-testing skill for general testing patterns

If you encounter a bug or unexpected behavior in google/wire, open an issue at <https://github.com/google/wire/issues>.

Advanced — google/wire

Detail topics referenced from SKILL.md. Each section is self-contained.

Cleanup Chains

When a provider returns (T, func(), error), Wire adds the cleanup to a chain. The generated injector runs cleanups in reverse construction order: the last-built dependant is cleaned up first, ensuring dependants are torn down before their dependencies.

// Provider with cleanup
func NewDB(cfg *Config) (*sql.DB, func(), error) {
    db, err := sql.Open("postgres", string(cfg.DSN))
    if err != nil { return nil, nil, err }
    return db, func() { db.Close() }, nil
}

func NewCache(cfg *Config) (*redis.Client, func(), error) {
    c := redis.NewClient(&redis.Options{Addr: cfg.CacheAddr})
    return c, func() { c.Close() }, nil
}

Wire generates something like:

func InitApp() (*App, func(), error) {
    cfg := NewConfig()
    db, dbCleanup, err := NewDB(cfg)
    if err != nil { return nil, nil, err }
    cache, cacheCleanup, err := NewCache(cfg)
    if err != nil {
        dbCleanup()  // already-built cleanups run on partial failure
        return nil, nil, err
    }
    app := NewApp(db, cache)
    return app, func() {
        cacheCleanup()  // reverse order
        dbCleanup()
    }, nil
}

Caller pattern — guard against nil cleanup on construction failure:

app, cleanup, err := InitApp()
if err != nil { log.Fatal(err) }
defer cleanup()

Wire always returns a non-nil cleanup function when construction succeeds. If construction fails midway, the returned cleanup is nil — guard before calling.

Multiple Injectors in One Package

A package can contain multiple injector functions. Each must live in a file with //go:build wireinject. All generated functions land in wire_gen.go in the same package.

//go:build wireinject

package main

// Production injector
func InitProdApp() (*App, func(), error) {
    wire.Build(ProdSet, NewApp)
    return nil, nil, nil
}

// Development injector with debug providers
func InitDevApp() (*App, func(), error) {
    wire.Build(DevSet, NewApp)
    return nil, nil, nil
}

Select at runtime with a flag, or at build time with separate //go:build prod / //go:build !prod constraints on the injector files.

wire.NewSet Nesting Strategies

Sets can contain other sets, building a hierarchy that mirrors your package structure.

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

// pkg/infra/wire.go
var InfraSet = wire.NewSet(
    config.ConfigSet, // embed upstream set
    NewDB,
    NewCache,
)

// pkg/service/wire.go
var ServiceSet = wire.NewSet(
    NewUserService,
    wire.Bind(new(UserStore), new(*UserRepo)),
)

// wire.go (injector)
wire.Build(infra.InfraSet, service.ServiceSet, NewApp)

Library set stability rules (from upstream best practices):

• Safe: replace one provider with another that has the same or fewer inputs, in the same release.
• Safe: introduce a brand-new output type not previously provided.
• Breaking: add a new required input to a provider — downstream injectors cannot satisfy it.
• Breaking: remove a provided output type — downstream injectors that depend on it fail.
• Breaking: add a type that the injector already provides — Wire reports a duplicate.

wire:"-" Exclusion Tag

Exclude a struct field from wire.Struct injection by tagging it:

type Server struct {
    Logger  *zap.Logger
    DB      *sql.DB
    mu      sync.Mutex   `wire:"-"` // unexported — auto-excluded
    Timeout time.Duration `wire:"-"` // exported but opt-out
}

wire.Struct(new(Server), "*") // injects Logger and DB; skips mu and Timeout

Unexported fields are always skipped regardless of the tag.

Common Codegen Errors

Codegen Flags

# Specify output file prefix (default: wire_gen)
wire -output_file_prefix=init gen ./cmd/server

# Apply build tags during generation
wire -tags=integration gen ./...

# Prepend a header file (e.g., license comment) to generated output
wire -header_file=hack/boilerplate.go.txt gen ./...

panic(wire.Build(...)) Alternate Syntax

Wire accepts either a dummy return or a panic call as the injector body. The panic form avoids writing zero-value returns for complex types:

// Preferred when return types are complex or error-prone to zero-initialize
func InitApp(ctx context.Context) (*App, func(), error) {
    panic(wire.Build(AppSet))
}

Wire detects both forms and replaces the body during codegen. The panic is never reached in the compiled binary — only the generated wire_gen.go version is compiled.

Accepting External Values as Injector Arguments

When a value is constructed before wire runs (e.g., parsed flags, an http.Client from a test), pass it as a parameter to the injector rather than providing it from within the graph:

//go:build wireinject

func InitApp(cfg *Config) (*App, func(), error) {
    wire.Build(InfraSet, ServiceSet, NewApp)
    return nil, nil, nil
}

// main.go
cfg := parseFlags()
app, cleanup, err := InitApp(cfg)

Wire treats injector parameters as pre-built providers — they satisfy dependencies without needing a wire.NewSet entry.

Quick Reference

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

// 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)

// 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)

// 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)),
)

// 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)

// 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
}

// 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.

// 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:

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:

// 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.

// 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:

// 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: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.

Testing — google/wire

Wire generates plain Go constructor calls, so tests work directly on the constructor layer — no container API to learn.

Unit Tests: Plain Constructor Injection

The generated code has no wire dependency. Test constructors directly:

func TestUserService_GetUser(t *testing.T) {
    mockStore := &MockUserStore{users: map[int64]*User{1: &User{ID: 1, Name: "Alice"}}}
    cache := newTestRedis(t)
    svc := service.NewUserService(mockStore, cache)

    u, err := svc.GetUser(context.Background(), 1)
    require.NoError(t, err)
    assert.Equal(t, "Alice", u.Name)
}

Pass mocks directly as constructor arguments. No wire, no container, no file to generate. This is the idiomatic approach for unit tests.

Test Injectors: Swapping Providers

For integration or component tests where you want the full wired graph but with selected dependencies replaced, create a test-only injector in a _test.go file.

// app_test.go
//go:build wireinject

package main

import (
    "testing"
    "github.com/google/wire"
)

// TestSet replaces real infra with in-memory fakes
var TestSet = wire.NewSet(
    NewTestConfig,
    NewInMemoryUserStore,
    wire.Bind(new(repo.UserStore), new(*InMemoryUserStore)),
    NewTestRedis,
)

func InitTestApp(t *testing.T) (*App, func(), error) {
    wire.Build(TestSet, service.ServiceSet, NewApp)
    return nil, nil, nil
}

// app_integration_test.go
//go:build !wireinject  // compiles when the wireinject tag is NOT set

package main

func TestApp_GetUser(t *testing.T) {
    app, cleanup, err := InitTestApp(t)
    require.NoError(t, err)
    defer cleanup()

    // test against the fully-wired app with fake dependencies
    u, err := app.GetUser(context.Background(), 1)
    require.NoError(t, err)
    assert.NotNil(t, u)
}

Run wire ./... to generate wire_gen.go — the test injector is included because the _test.go file is compiled as part of the package during go test.

Key pattern from upstream best practices: Prefer creating a test-only provider set over passing mocks as injector arguments (though both work). The set approach keeps the test injector composable.

Passing Mocks as Injector Arguments

An alternative to a test set: pass the mock directly as an injector parameter. Wire treats it as a pre-built provider.

//go:build wireinject

func InitTestApp(store repo.UserStore) (*App, func(), error) {
    wire.Build(config.ConfigSet, service.ServiceSet, NewApp)
    return nil, nil, nil
}

// Test
func TestApp(t *testing.T) {
    mock := &MockUserStore{}
    app, cleanup, err := InitTestApp(mock)
    require.NoError(t, err)
    defer cleanup()
    // ...
}

Use this form when you only need to replace one or two dependencies and a full TestSet is overkill.

CI: Detecting Stale wire_gen.go

If wire_gen.go is not regenerated after a provider change, CI builds pass but the graph is wrong. Enforce freshness in CI:

# Option 1: re-run wire and check for diffs
wire ./...
git diff --exit-code -- '**/wire_gen.go'

# .github/workflows/ci.yml
- name: Check wire_gen.go is up-to-date
  run: |
    go install github.com/google/wire/cmd/wire@v0.7.0
    wire ./...
    git diff --exit-code -- '**/wire_gen.go'

# Option 2: use wire check (verifies graph without regenerating)
wire check ./...

wire check exits non-zero if the graph is inconsistent but does not update wire_gen.go. Use it for a fast graph-validity check without modifying files.

Testing Interface Bindings

wire.Bind can be used in test sets to bind a fake to the same interface:

// Fake implements the same interface as the real provider
type FakeMailer struct{ sent []string }
func (f *FakeMailer) Send(to, body string) error { f.sent = append(f.sent, to); return nil }

var TestMailerSet = wire.NewSet(
    NewFakeMailer,
    wire.Bind(new(notification.Mailer), new(*FakeMailer)),
)

var TestSet = wire.NewSet(
    TestMailerSet,
    realServiceSet,  // everything else is real
)

This keeps the test injector narrow — only the Mailer is faked; the rest of the graph is real.

Table-Driven Tests Without Wire

Wire is an initialization tool. Once the object graph is built, table-driven tests on individual services need no wire involvement:

func TestUserService(t *testing.T) {
    cases := []struct {
        name  string
        id    int64
        users map[int64]*User
        want  string
        err   bool
    }{
        {"found", 1, map[int64]*User{1: &User{Name: "Alice"}}, "Alice", false},
        {"not found", 99, nil, "", true},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            svc := service.NewUserService(&MockUserStore{users: tc.users}, nil)
            u, err := svc.GetUser(context.Background(), tc.id)
            if tc.err { require.Error(t, err); return }
            assert.Equal(t, tc.want, u.Name)
        })
    }
}

Wire has no role here — the injector was only needed to build the object graph in main (or in an integration test). Unit tests construct dependencies directly.