handling panics in public getters

internal/app/command_generate.go

@@ -22,6 +22,12 @@ func newGenerator(options *Options, params *config.Parameters) *di.Generator {
 		Version:   options.Version,
 		BuildTime: options.BuildTime,
 		Logger:    terminalLogger{},
+		ErrorWrapping: di.ErrorHandling{
+			Package:      params.ErrorHandling.Package,
+			WrapPackage:  params.ErrorHandling.WrapPackage,
+			WrapFunction: params.ErrorHandling.WrapFunction,
+			Verb:         params.ErrorHandling.Verb,
+		},
 	}
 }
 

internal/config/parameters.go

@@ -13,14 +13,22 @@ import (
 var errInvalidPath = errors.New("invalid path")
 
 type Parameters struct {
-	Version   string    `json:"version" yaml:"version"`
-	Container Container `json:"container" yaml:"container"`
+	Version       string        `json:"version" yaml:"version"`
+	Container     Container     `json:"container" yaml:"container"`
+	ErrorHandling ErrorHandling `json:"errorHandling" yaml:"errorHandling"`
 }
 
 type Container struct {
 	Dir string `json:"dir" yaml:"dir"`
 }
 
+type ErrorHandling struct {
+	Package      string `json:"package" yaml:"package"`
+	WrapPackage  string `json:"wrapPackage" yaml:"wrapPackage"`
+	WrapFunction string `json:"function" yaml:"function"`
+	Verb         string `json:"verb" yaml:"verb"`
+}
+
 func Load() (*Parameters, error) {
 	config := newConfig()
 	err := config.ReadInConfig()
@@ -93,6 +101,9 @@ func initConfig(config *viper.Viper) error {
 
 	config.Set("version", Version)
 	config.Set("container.dir", dir)
+	config.Set("errorHandling.package", "errors")
+	config.Set("errorHandling.wrapPackage", "fmt")
+	config.Set("errorHandling.wrapFunction", "Errorf")
 	err = config.SafeWriteConfig()
 	if err != nil {
 		return errors.Errorf("write config: %w", err)

internal/di/definitions.go

@@ -13,6 +13,7 @@ type RootContainerDefinition struct {
 	Imports    map[string]*ImportDefinition
 	Services   []*ServiceDefinition
 	Containers []*ContainerDefinition
+	Factories  map[string]*FactoryDefinition
 }
 
 func (c RootContainerDefinition) Type(definition TypeDefinition) func(statement *jen.Statement) {
@@ -150,13 +151,28 @@ func (d TypeDefinition) String() string {
 	return s.String()
 }
 
-type FactoryFile struct {
-	Imports  map[string]*ImportDefinition
-	Services []string
+type FactoryDefinitions struct {
+	Imports   map[string]*ImportDefinition
+	Factories map[string]*FactoryDefinition
 }
 
-type Tags struct {
-	Options         []string
-	FactoryFilename string
-	PublicName      string
+func NewFactoryDefinitions() *FactoryDefinitions {
+	return &FactoryDefinitions{
+		Imports:   map[string]*ImportDefinition{},
+		Factories: map[string]*FactoryDefinition{},
+	}
+}
+
+func (d *FactoryDefinitions) merge(df *FactoryDefinitions) {
+	for k, v := range df.Factories {
+		d.Factories[k] = v
+	}
+	for k, v := range df.Imports {
+		d.Imports[k] = v
+	}
+}
+
+type FactoryDefinition struct {
+	Name         string
+	ReturnsError bool
 }

internal/di/definitions_parser.go

@@ -68,6 +68,7 @@ func (p *DefinitionsParser) parseContainerAST(file *ast.File) (*RootContainerDef
 		Imports:    imports,
 		Services:   services,
 		Containers: containers,
+		Factories:  make(map[string]*FactoryDefinition, 0),
 	}
 
 	return definition, nil
@@ -314,6 +315,12 @@ func parseTypeDefinition(expr ast.Expr) (TypeDefinition, error) {
 	return TypeDefinition{}, errors.Errorf("%w: %s", ErrUnexpectedType, "parse type")
 }
 
+type Tags struct {
+	Options         []string
+	FactoryFilename string
+	PublicName      string
+}
+
 func parseFieldTags(field *ast.Field) Tags {
 	if field.Tag == nil || len(field.Tag.Value) == 0 {
 		return Tags{}
@@ -335,3 +342,21 @@ func validateInternalContainer(container *ast.StructType) error {
 
 	return nil
 }
+
+type FuncDeclaration struct {
+	ReturnsErr bool
+}
+
+func parseFuncDeclaration(decl *ast.FuncDecl) (FuncDeclaration, error) {
+	declaration := FuncDeclaration{}
+
+	if decl.Type.Results != nil {
+		for _, field := range decl.Type.Results.List {
+			if id, ok := field.Type.(*ast.Ident); ok && id.Name == "error" {
+				declaration.ReturnsErr = true
+			}
+		}
+	}
+
+	return declaration, nil
+}

internal/di/definitions_parser_test.go

@@ -58,17 +58,17 @@ func TestParseContainerFromSource(t *testing.T) {
 }
 
 func TestParseFactoryFromSource(t *testing.T) {
-	factory, err := di.ParseFactoryFromSource(testFactorySource)
+	factory, err := di.ParseFactoriesFromSource(testFactorySource)
 
 	require.NoError(t, err)
 	require.NotNil(t, factory)
 	assert.NotNil(t, factory.Imports["usecase"])
 	assert.NotNil(t, factory.Imports["domain"])
 	assert.NotNil(t, factory.Imports["httpadapter"])
 	assert.NotNil(t, factory.Imports["inmemory"])
-	assert.Contains(t, factory.Services, "EntityRepository")
-	assert.Contains(t, factory.Services, "UseCase")
-	assert.Contains(t, factory.Services, "Handler")
+	assert.Contains(t, factory.Factories, "EntityRepository")
+	assert.Contains(t, factory.Factories, "UseCase")
+	assert.Contains(t, factory.Factories, "Handler")
 }
 
 func assertExpectedContainerImports(t *testing.T, imports map[string]*di.ImportDefinition) {

internal/di/factories_generator.go

@@ -47,7 +47,10 @@ func (g *FactoriesGenerator) Generate() ([]*File, error) {
 						jen.Id("ctx").Qual("context", "Context"),
 						jen.Id("c").Qual(g.params.packageName(LookupPackage), "Container"),
 					).
-					Do(g.container.Type(service.Type)).
+					Params(
+						jen.Do(g.container.Type(service.Type)),
+						jen.Error(),
+					).
 					Block(jen.Panic(jen.Lit("not implemented"))),
 			)
 		}

internal/di/factories_generator_test.go

@@ -21,7 +21,7 @@ func TestFactoriesGenerator_Generate(t *testing.T) {
 				Name:    "Container",
 				Package: "testpkg",
 				Imports: map[string]*di.ImportDefinition{
-					"domain": {Path: `"example.com/test/domain"`},
+					"domain": {Path: "example.com/test/domain"},
 				},
 				Services: []*di.ServiceDefinition{
 					{