Getting Started

// Register constructors
forge.ProvideConstructor(c, func(db *Database, logger forge.Logger) *UserService {
    return &UserService{db: db, logger: logger}
})
// Resolve by type (no string keys needed)
userService, err := forge.InjectType[*UserService](c)

eventBus, _ := vessel.InjectType[interfaces.EventBus](app.Container())

dbExt := database.NewExtension(
    database.WithDefault("primary"),
    database.WithDatabases(
        database.DatabaseConfig{
            Name: "primary",
            Type: database.TypePostgres,
            DSN:  os.Getenv("DATABASE_URL"),
        },
        database.DatabaseConfig{
            Name: "cache",
            Type: database.TypeRedis,
            DSN:  os.Getenv("REDIS_URL"),
        },
    ),
)

app := forge.New(
    forge.WithAppName("my-app"),
    forge.WithAppVersion("1.0.0"),
    forge.WithExtensions(dbExt),
)

ctx := context.Background()
if err := app.Start(ctx); err != nil {
    panic(err)
}
defer app.Stop(ctx)

manager, err := database.GetManager(app.Container())
if err != nil {
    panic(err)
}

primarySQL, err := manager.SQL("primary")
cacheRedis, err := manager.Redis("cache")

primarySQL, err := database.GetSQL(app.Container(), "primary")
cacheRedis, err := database.GetRedis(app.Container(), "cache")

type UserRepository struct {
    DB *bun.DB
}

_ = forge.ProvideConstructor(app.Container(),
    func(manager *database.DatabaseManager) (*UserRepository, error) {
        db, err := manager.SQL("primary")
        if err != nil {
            return nil, err
        }
        return &UserRepository{DB: db}, nil
    },
)

repo, err := forge.InjectType[*UserRepository](app.Container())