Wire: Go Dependency Injection Tool

Wire is a code generation tool for automated dependency injection in Go.

Core Concepts:

• Dependency Representation: Dependencies between components are represented as function parameters. This encourages explicit initialization and avoids the use of global variables.
• No Runtime Overhead: Wire operates without runtime state or reflection. It generates standard Go code that performs the initialization, meaning the resulting code is clean, performant, and useful even if you were to perform the initialization by hand.
• Code Generation: Instead of using a container at runtime, Wire analyzes your provider functions and generates the necessary 'wire' code to connect them.

Wire uses two main concepts to automate dependency injection:

1. Providers: These are regular Go functions that return a specific type. For example, func NewGreeter(m Message) Greeter is a provider for the Greeter type.
2. Injectors: These are functions that call wire.Build with a set of providers and return the target type. The injector's signature determines what dependencies are passed in from the outside.

To prevent the injector code from being included in your final application binary, you should use a build constraint at the top of your wire.go file:

//+build wireinject

Note: A build constraint requires a blank, trailing line after it.

// wire.go
//+build wireinject

func InitializeEvent() Event {
    wire.Build(NewEvent, NewGreeter, NewMessage)
    return Event{}
}

When injecting common types like string, int, or bool, you may encounter conflicts if multiple providers attempt to provide the same base type. To prevent this, wrap the common type in a new, domain-specific type.

For example, instead of injecting a raw string for a connection string, define a custom type:

type MySQLConnectionString string

Wire is built on two fundamental abstractions:

1. Providers: Ordinary Go functions that produce a value. They can take dependencies as parameters and return errors.
2. Injectors: Functions that define the dependency graph. You write the function signature (including parameters and return types), and Wire generates the function body by calling providers in the correct dependency order.

To use injectors, you must include the // +build wireinject build tag in the file so the stub is not included in your final application binary.

// +build wireinject

package main

import (
    "context"
    "github.com/google/wire"
    "example.com/foobarbaz"
)

func initializeBaz(ctx context.Context) (foobarbaz.Baz, error) {
    wire.Build(foobarbaz.MegaSet)
    return foobarbaz.Baz{}, nil
}

Beyond basic provider initialization, Wire supports several advanced dependency injection patterns:

• Provider Sets: Group multiple providers together into a single unit using sets.
• Binding Interfaces: Map a concrete implementation to an interface so the injector can satisfy interface requirements.
• Binding Values: Provide specific constant values or configuration objects directly into the dependency graph.
• Cleanup Functions: Support for functions that handle resource teardown (e.g., closing database connections) during the initialization lifecycle.

If your providers return an error (e.g., func NewEvent(g Greeter) (Event, error)), Wire automatically detects this. It will update the generated injector signature to return an error and insert the necessary error checking logic into the generated wire_gen.go file.

Example Injector Signature:

func InitializeEvent() (Event, error) {
    wire.Build(NewEvent, NewGreeter, NewMessage)
    return Event{}, nil
}

Generated Code Result:

func InitializeEvent() (Event, error) {
    message := NewMessage()
    greeter := NewGreeter(message)
    event, err := NewEvent(greeter)
    if err != nil {
        return Event{}, err
    }
    return event, nil
}

// wire.go
func InitializeEvent() (Event, error) {
    wire.Build(NewEvent, NewGreeter, NewMessage)
    return Event{}, nil
}

After defining your injectors, run the wire command in the package directory to generate the implementation in a wire_gen.go file.

wire

To update the generated code later, you can use the standard Go command:

go generate