Best practice for multiple package and multiple level project

[aliok]

Any best practices around how to use dig with a project that has multiple nested dependencies?

As in, main --> route --> endpoint --> handler --> ...

I am exploring the option to let each component register itself, instead of referencing 4 level deep things in my main.

My goal is to keep main.go clean by ensuring that each module registers and resolves its dependencies internally.

ModuleB is dependency to ModuleA:

package moduleB

type ConfigB struct {
	APIServerURL string
}

func NewConfigB() *ConfigB {
	return &ConfigB{APIServerURL: "https://api.example.com"}
}

func RegisterModuleB(container *dig.Container) error {
        return container.Provide(NewConfigB)
}

ModuleA:

package moduleA

type ConfigA struct {
	DBHost string
}

func NewConfigA() *ConfigA {
	return &ConfigA{DBHost: "localhost:5432"}
}

func RegisterModuleA(container *dig.Container) error {
	if err := moduleB.RegisterModuleB(container); err != nil {
		return err
	}

	return container.Provide(NewConfigA)
}

main only knows about moduleA:

package main

func main() {
	container := dig.New()

	moduleA.RegisterModuleA(container)

	container.Invoke(func(a *moduleA.ConfigA) {
		fmt.Println("DB Host (ModuleA):", a.DBHost)
	})

}

But this time, I happen to carry the container deep in my dependency chain, which is tolerable.

What are the best practices you've been using?