example_test.go

package dofactory_test

import (
	"fmt"

	"github.com/samber/do/v2"

	"github.com/d-enk/dofactory"
)

type Service struct {
	Name string
}

func NewService(name string) *Service {
	return &Service{Name: name}
}

func ExampleNewService() {
	injector := do.New()

	// Provide service name
	do.ProvideValue(injector, "MyService")

	// Convert factory to provider
	factoryProvider := dofactory.ToProvider[*Service](NewService)

	// Register provider
	do.Provide(injector, factoryProvider)

	// Retrieve the instance from the container
	service := do.MustInvoke[*Service](injector)

	fmt.Println(service.Name) // Output: MyService
}

func NewServiceWithError(name string, withError bool) (*Service, error) {
	if withError {
		return nil, fmt.Errorf("ERROR")
	}

	return &Service{Name: name}, nil
}

func ExampleNewServiceWithError() {
	injector := do.New()

	do.ProvideValue(injector, "MyService")

	factoryProvider := dofactory.ToProvider[*Service](NewServiceWithError)

	do.ProvideTransient(injector, factoryProvider)

	// Register flag - NO error
	do.ProvideValue(injector, false)
	fmt.Println(do.Invoke[*Service](injector))

	// Set flag - error
	do.OverrideValue(injector, true)
	fmt.Println(do.Invoke[*Service](injector))

	// output:
	// &{MyService} <nil>
	// <nil> ERROR
}

type (
	ConvertibleService Service
	ConvertibleName    string
)

func NewConvertibleService(name ConvertibleName) *ConvertibleService {
	return &ConvertibleService{Name: string(name)}
}

func (*ConvertibleService) String() string { return "interface{ String() string }" }

func ExampleNewConvertibleService() {
	injector := do.New()

	// Provide service name
	do.ProvideValue(injector, "MyService")
	do.ProvideValue(injector, ConvertibleName("MyConvertibleService"))

	// Register Service factory provider with conversion to ConvertibleService
	do.Provide(injector, dofactory.ToProvider[*ConvertibleService](NewService))

	// Register ConvertibleService factory provider with conversion to Service
	do.Provide(injector, dofactory.ToProvider[*Service](NewConvertibleService))

	// Register ConvertibleService factory provider with conversion to interface
	do.Provide(injector, dofactory.ToProvider[interface{ String() string }](NewConvertibleService))

	fmt.Println(do.MustInvoke[*ConvertibleService](injector).Name) // MyService

	fmt.Println(do.MustInvoke[*Service](injector).Name) // MyConvertibleService

	fmt.Println(do.MustInvoke[interface{ String() string }](injector))

	// Output:
	// MyService
	// MyConvertibleService
	// interface{ String() string }
}