Multiple Database Connections

Nimbus supports connecting to multiple SQL databases at the same time. Register each connection with a name, then resolve it anywhere in your application. The first registered connection (or one named "default") automatically becomes the global DB.

Configuration

Define your connections in config/database.go:

type DatabaseConfig struct {
    Driver   string
    DSN      string

    // Named SQL connections
    Connections map[string]ConnectionCfg

    // NoSQL
    MongoURI      string
    MongoDatabase string
}

type ConnectionCfg struct {
    Driver       string
    DSN          string
    Debug        bool
    MaxOpenConns int
    MaxIdleConns int
}

func Database() DatabaseConfig {
    return DatabaseConfig{
        Driver: env.Get("DB_DRIVER", "sqlite"),
        DSN:    env.Get("DB_DSN", "database.sqlite"),
        Connections: map[string]ConnectionCfg{
            "default": {
                Driver: env.Get("DB_DRIVER", "sqlite"),
                DSN:    env.Get("DB_DSN", "database.sqlite"),
            },
            "analytics": {
                Driver: env.Get("ANALYTICS_DB_DRIVER", "postgres"),
                DSN:    env.Get("ANALYTICS_DB_DSN", ""),
            },
            "logs": {
                Driver: env.Get("LOGS_DB_DRIVER", "postgres"),
                DSN:    env.Get("LOGS_DB_DSN", ""),
            },
        },
        MongoURI:      env.Get("MONGO_URI", ""),
        MongoDatabase: env.Get("MONGO_DATABASE", ""),
    }
}

Registering Connections

Option A — ConnectAll (recommended)

Pass a slice of ConnectionConfig and Nimbus opens & registers everything in one call:

import "github.com/CodeSyncr/nimbus/database"

configs := []database.ConnectionConfig{
    {Name: "default",   Driver: cfg.Driver, DSN: cfg.DSN, Debug: isDev},
    {Name: "analytics", Driver: "postgres", DSN: analyticsDSN},
    {Name: "logs",      Driver: "postgres", DSN: logsDSN, MaxOpenConns: 25},
}

if err := database.ConnectAll(configs); err != nil {
    log.Fatalf("database: %v", err)
}
defer database.CloseAll()

Option B — Manual AddConnection

db, _ := database.Connect("postgres", dsn)
database.AddConnection("default", db)

analyticsDB, _ := database.Connect("postgres", analyticsDSN)
database.AddConnection("analytics", analyticsDB)

Using Connections

// Resolve by name → *gorm.DB
db := database.Connection("analytics")
db.Find(&events)

// MustConnection panics if not registered (for boot-time checks)
db = database.MustConnection("analytics")

// Convenience from the nimbus package
db = nimbus.Connection("analytics")

Query Builder on a Connection

database.On returns a Query builder scoped to the named connection:

// Query builder on a specific connection
var events []AnalyticsEvent
database.On("analytics").
    Where("event_type = ?", "click").
    Where("created_at > ?", since).
    Get(&events)

// Model-scoped query builder
var logs []AuditLog
database.OnModel("logs", &AuditLog{}).
    Where("user_id = ?", uid).
    OrderBy("created_at", "desc").
    Limit(50).
    Get(&logs)

API Reference

ConnectionConfig

Switching the Default

The first connection registered is the default. You can switch it at runtime:

// Make "analytics" the global default
database.SetDefault("analytics")

// Now database.Get() / nimbus.DB() returns the analytics connection

Combining SQL + NoSQL

Both the SQL connection manager and the NoSQL connection manager work side by side. Use nimbus plugin:install nosql to scaffold the NoSQL boot wiring automatically, or configure it manually:

import (
    "github.com/CodeSyncr/nimbus/database"
    "github.com/CodeSyncr/nimbus/database/nosql"
)

// SQL connections
database.ConnectAll(sqlConfigs)

// NoSQL connections (auto-wired by bootNoSQL if using plugin:install)
mongo, _ := nosql.ConnectMongo(ctx, nosql.MongoConfig{...})
nosql.Register("mongo", mongo)
nimbus.SetNoSQL(mongo)

// Use both in a handler
func CreateOrder(c *nimbus.Context) error {
    // Write to SQL via *nimbus.DB
    c.DB.Create(&order)

    // Write to MongoDB via *nimbus.NoSQL
    store := nimbus.GetNoSQL()
    store.Collection("order_events").InsertOne(c.Request.Context(), OrderEvent{
        OrderID: order.ID,
        Action:  "created",
    })
    return c.JSON(order)
}

// Or inject both via container
type OrderController struct {
    DB    *nimbus.DB
    Mongo *nimbus.NoSQL
}

func NewOrderController(app *nimbus.App) *OrderController {
    return &OrderController{
        DB:    app.Container.MustMake("db").(*nimbus.DB),
        Mongo: app.Container.MustMake("nosql").(*nimbus.NoSQL),
    }
}

← NoSQL Query Builder  |  Database & ORM →