Right pattern to use fx.Populate() to avoid adding more parameters to constructors

[debedb]

This is somewhat related to #725.

I would like to avoid adding adding parameters into constructors as I add fields to the underlying struct. I can use param objects but this looks like a lot of boilerplate:

type X struct {
  Foo Foo
  Bar Bar
}

type XParams struct {
   fx.In

   X
}

func NewX(params XParams) *X {
   return &X{Foo: params.Foo,
                    Bar: params.Bar}
}

Sure I could use something like https://github.com/jinzhu/copier in NewX but that is some extra dependency.

So I would like to use fx.Populate() instead of the constructor. But if I do something like:

package dependencies

import "go.uber.org/fx"

type Foo string

type Bar string

type Baz string

type DependenciesType struct {
	fx.In

	Foo Foo
	Bar Bar
	Baz Baz
}

func NewFoo() Foo {
	return "foo"
}

func NewBar() Bar {
	return "bar"
}

func NewBaz() Baz {
	return "baz"
}

var Dependencies DependenciesType

var DependenciesModule = fx.Options(
	fx.Provide(NewFoo),
	fx.Provide(NewBar),
	fx.Provide(NewBaz),
	fx.Populate(&Dependencies),
)

I will get

cannot depend on a pointer to a parameter object, use a value instead: *dependencies.DependenciesType is a pointer to a struct that embeds dig.In

What would be the proper way to do something like this then?

[jstncbllr]

Seems like you have X and XParams a bit backwards... I think you want something more like

type (
	Foo     string
	Bar     string
	XParams struct {
		fx.In
		F Foo
		B Bar
	}
	X struct{ p XParams }
)

func NewX(params XParams) X { return X{params} }

func init() {
	fx.New(
		fx.Supply(Bar("bar"),Foo("foo")),
		fx.Provide(NewX),
		fx.Invoke(func(x X) {
			fmt.Printf("%+v\n", x)
		}),
	)
}