main.go

package main

import (
	"fmt"
	"log"

	"github.com/zignd/depot"
)

type Config struct {
	DatabaseURL string
}

type Logger struct {
	Prefix string
}

type Database struct {
	Config Config
	Logger Logger
}

type Service struct {
	DB *Database
}

func main() {
	fmt.Println("=== Example: Batch Error Checking ===")
	fmt.Println()

	// Create a new depot
	dp := depot.New(depot.Config{LazyMode: true})

	// Register multiple dependencies using RegisterMany
	// This is cleaner than individual registrations
	dp.RegisterMany(
		depot.Singleton(func() Config {
			return Config{DatabaseURL: "postgres://localhost/mydb"}
		}),
		depot.Singleton(func(c Config) Logger {
			return Logger{Prefix: fmt.Sprintf("[%s]", c.DatabaseURL)}
		}),
		depot.Singleton(func(c Config, l Logger) *Database {
			return &Database{Config: c, Logger: l}
		}),
		// Intentionally register an invalid dependency to show error tracking
		depot.Singleton(nil), // This will error
		depot.Singleton(func(db *Database) *Service {
			return &Service{DB: db}
		}),
	)

	// Check all registration errors at once
	if errs := dp.Errors(); errs != nil {
		fmt.Println("Registration errors found:")
		for i, err := range errs {
			fmt.Printf("  %d. %v\n", i+1, err)
		}
		log.Fatal("Cannot proceed due to registration errors")
	}

	// If we get here, all registrations succeeded
	fmt.Println("All registrations successful!")

	// Resolve a dependency
	service, err := depot.Get[*Service](dp)
	if err != nil {
		log.Fatalf("Failed to resolve Service: %v", err)
	}

	fmt.Printf("\nService resolved successfully!\n")
	fmt.Printf("Database URL: %s\n", service.DB.Config.DatabaseURL)
	fmt.Printf("Logger Prefix: %s\n", service.DB.Logger.Prefix)
}