helium.go

package helium

import (
	"context"
	"fmt"
	stdlog "log"
	"os"
	"reflect"
	"strings"

	"go.uber.org/atomic"
	"go.uber.org/dig"
	"go.uber.org/zap"

	"github.com/im-kulikov/helium/logger"
	"github.com/im-kulikov/helium/module"
	"github.com/im-kulikov/helium/settings"
)

type (
	// App implementation for helium.
	App interface {
		Run(ctx context.Context) error
	}

	// Helium struct.
	Helium struct {
		di *dig.Container
	}

	// Settings struct.
	Settings struct {
		File         string
		Type         string
		Name         string
		Prefix       string
		BuildTime    string
		BuildVersion string
		Defaults     settings.Defaults
	}
)

var (
	// nolint:gochecknoglobals
	appName = atomic.NewString("helium")

	// nolint:gochecknoglobals
	appVersion = atomic.NewString("dev")
)

// New helium instance.
func New(cfg *Settings, mod ...module.Module) (*Helium, error) {
	h := &Helium{di: dig.New()}

	modules := module.Combine(mod...)

	if cfg != nil {
		if cfg.Prefix == "" {
			cfg.Prefix = cfg.Name
		}

		cfg.Prefix = strings.ToUpper(cfg.Prefix)

		if tmp := os.Getenv(cfg.Prefix + "_CONFIG"); tmp != "" {
			cfg.File = tmp
		}

		if tmp := os.Getenv(cfg.Prefix + "_CONFIG_TYPE"); tmp != "" {
			cfg.Type = tmp
		}

		core := settings.Core{
			File:         cfg.File,
			Type:         cfg.Type,
			Name:         cfg.Name,
			Prefix:       cfg.Prefix,
			BuildTime:    cfg.BuildTime,
			BuildVersion: cfg.BuildVersion,
		}

		appName.Store(cfg.Name)
		appVersion.Store(cfg.BuildVersion)

		modules = append(modules, core.Provider())
		modules = append(modules, settings.DIProvider(h.di))
	}

	if err := module.Provide(h.di, modules); err != nil {
		return nil, err
	}

	if cfg == nil || cfg.Defaults == nil {
		return h, nil
	}

	return h, h.di.Invoke(cfg.Defaults)
}

// Invoke dependencies from DI container.
func (h Helium) Invoke(fn interface{}, args ...dig.InvokeOption) error {
	return h.di.Invoke(fn, args...)
}

// Run trying invoke app instance from DI container and start app with Run call.
func (h Helium) Run() error {
	return h.di.Invoke(func(ctx context.Context, app App) error {
		return app.Run(ctx)
	})
}

// Catch errors.
func Catch(err error) {
	if err == nil {
		return
	}

	log, logErr := logger.
		NewLogger(logger.NewLoggerConfig(settings.Viper()), &settings.Core{
			Name:         appName.Load(),
			BuildVersion: appVersion.Load(),
		})
	if logErr != nil {
		stdlog.Fatal(err)
	} else {
		log.Fatal("Can't run app",
			zap.Error(err))
	}
}

// CatchTrace catch errors for debugging use that function just for debug your application.
func CatchTrace(err error) {
	if err == nil {
		return
	}

	// digging into the root of the problem
loop:
	for {
		var (
			ok bool
			v  = reflect.ValueOf(err)
			fn reflect.Value
		)

		switch {
		case v.Type().Kind() != reflect.Struct,
			!v.FieldByName("Reason").IsValid():
			break loop
		case v.FieldByName("Func").IsValid():
			fn = v.FieldByName("Func")
		}

		// nolint:forbidigo
		fmt.Printf("Place: %#v\nReason: %s\n\n", fn, err)

		if err, ok = v.FieldByName("Reason").Interface().(error); ok {
			continue
		}

		if err, ok = v.Interface().(error); ok {
			break
		}
	}

	panic(err)
}