Hello.

I'm considering introducing DI into my project. Your DI implementation container looks good enough :) But I have a question: how to create services that are created through user's configuration? Here's an example:

package main

import (
	"github.com/goava/di"
	"github.com/spf13/viper"
)

type ServiceInterface interface {
	Do()
}

type DependencyA interface {}
type ServiceImplementationA struct {DependencyA}
func (s *ServiceImplementationA) Do() {}

type DependencyB interface {}
type ServiceImplementationB struct {DependencyB}
func (s *ServiceImplementationB) Do() {}

func NewService(config *viper.Viper) ServiceInterface {
	if viper.GetString("preferred_service") == "B" {
		// Resolve as ServiceImplementationB
	}

	// Otherwise resolve as ServiceImplementationA
}

func main() {
	container, _ := di.New(
		di.Provide(viper.New),
		di.Provide(NewService),
	)
	var service ServiceInterface
	container.Resolve(&service)
}

Depending on the configuration, I want to create a service interface implementation. But each implementation has its own dependencies list (I have not provided them manually in the example). I need a way to somehow call container.Resolve(&concreteImplementation) from the NewService function.

Is there any way to do this? Or maybe I just misunderstand how it should be done at all?

The title :) https://play.golang.org/p/ZvWhZaxyzM6

package main

import (
	"context"
	"log"

	"github.com/goava/di"
)

type Interface interface {
	Do(ctx context.Context) error
}

type FuncInterface func(ctx context.Context) error
func (c FuncInterface) Do(ctx context.Context) error {
	return c(ctx)
}

func createFirst() FuncInterface {
	return func(ctx context.Context) error {
		return nil
	}
}

func createSecond() FuncInterface {
	return func(ctx context.Context) error {
		return nil
	}
}

func main() {
	container, err := di.New(
		di.Provide(createFirst, di.As(new(Interface))),
		di.Provide(createSecond, di.As(new(Interface))),
	)
	if err != nil {
		log.Fatal(err)
	}

	var interfaces []Interface
	err = container.Resolve(&interfaces)
	if err != nil {
		log.Fatal(err)
	}
}

The error:

main.FuncInterface already exists in dependency graph

Actually, the title. I've prepared an example that shows the problem: https://play.golang.org/p/vZ2JvfmvJBB

package main

import (
	"log"

	"github.com/goava/di"
)

type Dependency struct {}

func NewDependency() *Dependency {
	return &Dependency{}
}

type Params struct {
	di.Inject

	Dependency *Dependency `di:""`
}

func InvokeWithDependencyAsParam(params Params) {
	// Some code
}

func main() {
	_, err := di.New(
		di.Provide(NewDependency),
		di.Invoke(InvokeWithDependencyAsParam),
	)
	if err != nil {
		log.Fatal(err)
	}
}

I started to try to implement this but I dont really understand how the internals are working right now. My Idea was to add another Option to di which is called Decorate.

package main

import (
	"fmt"

	"github.com/goava/di"
)

func main() {
	container, err := di.New(
		di.Provide(NewExample),
	)
	if err != nil {
		panic(err)
	}
	
	container.Invoke(func(e Example) {
		fmt.Println(e) // Will print "Example"
	})

       err = container.Decorate(DecorateExample)
       if err != nil {
		panic(err)
	}

	container.Invoke(func(e Example) {
		fmt.Println(e) // Will print "Example is now Decorated"
	})
}

type Example string

func NewExample() Example {
	return "Example"
}

func DecorateExample(e Example) Example {
	return e + " is now Decorated"
}

This can also be expaned to have options like priority to allow ordered decorations. Of course this only works when the decorated type isnt used before decoration. So you would have to call Decorate before Invoking anything.

When I provide the Container with multiple implementations of an Object and have one that doesnt have a Name the container doesnt know how to resolve it properly and returns an error when resolving a named entry

I am currently using uber-go/fx and I want to switch to DI, but sadly DI is missing a core feature to not run the invokes in compile state, instead having a Start() and Stop() function to kick off the Invokes and run until a control signal got sent, like CTRL+C.

	container := di.New(
// options
	)

	startCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()
	if err := container.Start(startCtx); err != nil {
		log.Fatal(err)
	}

       <- container.Done()

	stopCtx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
	defer cancel()
	if err := container.Stop(stopCtx); err != nil {
		log.Fatal(err)
	}

or less verbose if someone doesnt need full controll over the start and stop system

	container := di.New(
// options
	)

         container.Run()

When calling "Invoke" function in multiple goroutine, it can lead to concurrent read and map write in this part of the code :

// check cycle verified
if !c.verified[param.Key()] {
	err := checkCycles(c, param)
	if err != nil {
		return err
	}
	c.verified[param.Key()] = true
}

Closes #2. Implements #5. @zeromake try this branch. I rework a struct field injection mechanism. Tags support with embedded di.Injectable or di.Parameter(for backward compatibility).

package main

import (
	"net/http"

	"github.com/goava/di"
)

type Application struct {
	di.Injectable
	Server *http.Server   `di:""`
	Mux    *http.ServeMux `di:""`
}

func New() *Application {
	return &Application{}
}

func main() {
	var app *Application
	_, err := di.New(
		di.Provide(func() *http.Server { return &http.Server{} }),
		di.Provide(http.NewServeMux),
		di.Provide(New),
		di.Resolve(&app),
	)
	if err != nil {
		panic(err)
	}
	if app.Server == nil {
		panic("server not found")
	}
	if app.Mux == nil {
		panic("mux not found")
	}
}

I am currently using a patched version of uber-go/fx and uber-go/dig where I already added these Features. It allows to execute code and add more options based on things that are in the Container.

type Configuration struct {
 	 Enabled bool
}

di.New(
di.Provide(func () *Configuration {
		return &Configuration{ true }
}),
di.Provide(func(configuration *Configuration) di.Option {
	if configuration.Enabled {
		return di.Invoke(func () { fmt.Println("Hello World") })
	}
		return nil
})
)

Currently injected structs resolve using tag constraint like so:

type Parameters struct {
	di.Inject
	
	// use tag for the container to know that field need to be injected.
	Leader   *DatabaseConfig `type:"leader"`
	Follower *DatabaseConfig `type:"follower"`
}

But things start to break down if that same struct is used in other ways, for example marshalling:

type Parameters struct {
	di.Inject
	
	// use tag for the container to know that field need to be injected.
	Leader   *DatabaseConfig `type:"leader"   json:"leader"`
	Follower *DatabaseConfig `type:"follower" json:"follower"`
}

To avoid conflicting with other libs that also use tags to provide features on structs, I propose that we change how goava/di looks for struct tags that look like this instead:

type Parameters struct {
	di.Inject
	
	// use tag for the container to know that field need to be injected.
	Leader   *DatabaseConfig `di:"type=leader"`
	Follower *DatabaseConfig `di:"type=follower"`
}

Implement tag system

Tags are embedded expanders for injecting type. Embed it in your injecting type:

type Command interface {
  // ...
}

type ListConsoleCommand struct {
  di.Tags `console.command:"list"`
}

func NewListConsoleCommand() {
  return &ListConsoleCommand{}
}

Provide your type as interface:

c, err := di.New(
   di.Provide(NewListConsoleCommand, di.As(new(Command)))
   // or
   di.Provide(NewListConsoleCommandWithoutTags, di.As(new(Command)), di.WithTag("console.command", "list"))
)

And use Resolve() with WithTag() option for fetch instance with concrete tag-value combination:

 var command Command
 container.Resolve(&command, WithTag("console.command", "list"))

Does it possible to disable singleton behavior for some dependencies? Probably some ResolveOption or ProvideOption for that.

For example I want use goava/di container for testing with mocks. I have two different setups:

• di.New(...) with production implementation of interfaces which is used for release builds.
• di.New(...) with mocks which replace external APIs implementations.

Majority of mock libs assumes that each test recreate mock object but di container always returns same instance of mock object. I can call di.New for each test case but it is not looks good.