run providers concurrent function

lifecycle.go

@@ -42,7 +42,7 @@ func (l *lifecycle) Wait() error {
 	var err error
 	select {
 	case <-l.ctx.Done():
-		err = l.ctx.Err()
+		err = context.Cause(l.ctx)
 	case err = <-errors.WaitChanel(l.waitGroup):
 		l.Stop(err)
 	}
@@ -129,7 +129,14 @@ func getProviderName(creator interface{}, index int) string {
 		return reference
 	}
 
-	parts := strings.Split(reference, ".")
+	splitCount := -1
+
+	if strings.HasPrefix(reference, concurrentFuncRefName) {
+		reference = concurrentFuncRefName
+		splitCount = 3
+	}
+
+	parts := strings.SplitN(reference, ".", splitCount)
 
 	return parts[len(parts)-(1+index)]
 }

options.go

@@ -1,6 +1,15 @@
 package vabastegi
 
-import "context"
+import (
+	"context"
+	"io"
+	"time"
+
+	"github.com/mrsoftware/errors"
+)
+
+// ErrApplicationTimeout .
+var ErrApplicationTimeout = errors.New("application timeout")
 
 // Options of Vabastegi.
 type Options struct {
@@ -40,3 +49,20 @@ func WithContext(ctx context.Context) Option {
 		options.Ctx = ctx
 	}
 }
+
+// WithTimeout used if you need to pass timout for application booting.
+func WithTimeout(timeout time.Duration) Option {
+	return func(options *Options) {
+		// ignoring cancel
+		ctx, _ := context.WithTimeoutCause(options.Ctx, timeout, ErrApplicationTimeout)
+
+		options.Ctx = ctx
+	}
+}
+
+// WithEventLogger register event handlers for logger.
+func WithEventLogger(writer io.Writer, level logLevel) Option {
+	return func(options *Options) {
+		options.EventHandlers = append(options.EventHandlers, NewEventLogger(writer, level))
+	}
+}

vabastegi.go

@@ -2,7 +2,11 @@ package vabastegi
 
 import (
 	"context"
+	"reflect"
+	"runtime"
 	"time"
+
+	"github.com/mrsoftware/errors"
 )
 
 // Provider is a dependency provider for application.
@@ -51,18 +55,22 @@ func (a *App[T]) Builds(providers ...Provider[T]) (err error) {
 	defer func() { a.Events.Publish(&OnApplicationShutdownExecuted{Runtime: time.Since(startAt), Err: err}) }()
 
 	for _, provider := range providers {
-		if err = a.Build(a.Lifecycle.GetContext(), provider); err == nil {
-			continue
+		if err = a.Build(a.Lifecycle.GetContext(), provider); err != nil {
+			return err
 		}
-
-		return err
 	}
 
 	return nil
 }
 
 // Build use the provider to set a dependency.
 func (a *App[T]) Build(ctx context.Context, provider Provider[T]) (err error) {
+	select {
+	case <-ctx.Done():
+		return context.Cause(ctx)
+	default:
+	}
+
 	startAt := time.Now()
 
 	a.Events.Publish(&OnBuildExecuting{
@@ -92,3 +100,22 @@ func (a *App[ـ]) Log(level logLevel, message string, args ...interface{}) {
 func (a *App[_]) Wait() error {
 	return a.Lifecycle.Wait()
 }
+
+var concurrentFuncRefName = runtime.FuncForPC(reflect.ValueOf(Concurrent[any]).Pointer()).Name()
+
+// Concurrent is if you need to run multiple provider concurrently.
+func Concurrent[T any](providers ...Provider[T]) Provider[T] {
+	return func(ctx context.Context, app *App[T]) error {
+		wg := errors.NewWaitGroup(errors.WaitGroupWithContext(ctx))
+
+		for _, provider := range providers {
+			provider := provider
+
+			wg.DoWithContext(ctx, func(ctx context.Context) error {
+				return app.Builds(provider)
+			})
+		}
+
+		return wg.Wait()
+	}
+}