package main

import (
    "github.com/danceable/container"
    "github.com/danceable/container/bind"
    
    "go.mongodb.org/mongo-driver/v2/mongo"
    "go.mongodb.org/mongo-driver/v2/mongo/options"
    "go.mongodb.org/mongo-driver/v2/mongo/readpref"
)

func main() {
    c := container.New()
    
    // bind to container
    c.Bind(func()  (*mongo.Client, error) {
        uri := "mongodb://test_username:test_passwrod@mongodb:27017"
    
        return mongo.Connect(options.Client().ApplyURI(uri))
    }, bind.Singleton())
    
    // resolve from container
    var client *mongo.Client
    if err := c.Resolve(&client); err != nil {
        log.Fatal(err)
    }
    
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    
    // ping the DB
    client.Ping(ctx, readpref.Primary())
}

package main

import (
    "github.com/danceable/container"
    "github.com/danceable/container/bind"
)

type Counter interface {
    Count() int
}

// counter
type InMemoryCounter struct {
    count int
    
    lock sync.Mutex
}

// Ensure InMemoryCounter implements Counter interface.
var _ Counter = &InMemoryCounter{}

func (c *InMemoryCounter) Count() int {
    c.lock.Lock()
    defer c.lock.Unlock()
    
    c.count++
    
    return c.count
}

type User struct {
    ID       int
    Username string
    Password string
}

func main() {
    c := container.New()
    
    // bind counter
    c.Bind(func() *InMemoryCounter {
        return new(InMemoryCounter)
    }, bind.Singleton())
    
    // bind user
    c.Bind(func(counter Counter) *User {
        return &User{
            ID: counter.Count(),
        }
    }, bind.Lazy())
    
    // example1: call anonymouse function
    c.Call(func(user1 *User) {
        log.Println("user1 ID:", user1.ID)
    })
    
    // example2: call named function
    c.Call(LogUserID)
}

func LogUserID(user *User) {
    log.Println("user ID:", user.ID)
}

go get github.com/danceable/provider

type SimpleProvider struct{}

func (p *SimpleProvider) Register(ctx context.Context, c provider.Container) error {
    // ...
    
    return nil
}

func (p *SimpleProvider) Boot(ctx context.Context, c provider.Container) error {
    // ...
    
    return nil
}

func (p *SimpleProvider) Terminate(ctx context.Context) error {
    // ...
    
    return nil
}

provider.Register(&DatabaseProvider{})
provider.Register(&CacheProvider{})

ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
defer cancel()

if err := provider.Run(ctx); err != nil {
    log.Fatal(err)
}