How to pass database connection to Discord bot event handlers in Go without globals?

[Tom_Artist]

I’m building a Discord bot using Go that needs to query a MySQL database when users send messages. The problem is with the event handler function that processes user messages.

func validateError(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

func SetupDatabase() (*sql.DB, error) {
    database, dbErr := databaseRepo.CreateConnection(DbConnectionString)
    return database, dbErr
}

func StartBot() {
    // initialize discord session
    botSession, sessionErr := discordgo.New("Bot " + ApiToken)
    validateError(sessionErr)
    
    mysqlDb, dbError := SetupDatabase()
    defer mysqlDb.Close()
    validateError(dbError)
    
    databaseRepo = dbRepo.CreateUserRepo(mysqlDb)
    
    // register message handler - this is where I need database access
    botSession.AddHandler(handleUserMessage)
    
    // configure bot permissions
    botSession.Identify.Intents = discordgo.IntentsAllWithoutPrivileged
    
    // start the bot
    sessionErr = botSession.Open()
    validateError(sessionErr)
    defer botSession.Close()
    
    // wait for shutdown signal
    fmt.Println("Bot is online...")
    shutdown := make(chan os.Signal, 1)
    signal.Notify(shutdown, syscall.SIGINT, syscall.SIGTERM, os.Interrupt)
    <-shutdown
}

The issue is that botSession.AddHandler(handleUserMessage) only accepts handler functions with this specific signature:

func(session *discordgo.Session, message *discordgo.MessageCreate)
func(session *discordgo.Session, presence *discordgo.PresenceUpdate)

I can’t figure out how to get my database connection into the handler function without using global variables or creating a new database connection every time a message arrives. Both approaches seem wrong to me. What’s the proper way to handle this situation in Go?

[SpinningGalaxy]

I’ve had good luck with dependency injection using a config struct. Just bundle everything the bot needs into one struct and pass it around - no globals or messy closures. Testing becomes much simpler since you can mock whatever dependencies you need.

[benmoore]

I’ve had good luck using closures to capture the database connection in handler functions. Been doing this for several Discord bots and it’s pretty clean.

func createMessageHandler(db *sql.DB, repo *dbRepo.UserRepo) func(*discordgo.Session, *discordgo.MessageCreate) {
    return func(session *discordgo.Session, message *discordgo.MessageCreate) {
        // database operations here
        user, err := repo.GetUser(message.Author.ID)
        if err != nil {
            log.Printf("Database error: %v", err)
            return
        }
        // handle user data
    }
}

func StartBot() {
    botSession, sessionErr := discordgo.New("Bot " + ApiToken)
    validateError(sessionErr)
    
    mysqlDb, dbError := SetupDatabase()
    validateError(dbError)
    
    databaseRepo := dbRepo.CreateUserRepo(mysqlDb)
    
    // create handler with database access
    messageHandler := createMessageHandler(mysqlDb, databaseRepo)
    botSession.AddHandler(messageHandler)
    
    // rest of bot setup
}

The closure grabs your database connection and repo when you create it, so they’re available in the handler without globals or making new connections each time.

[FlyingLeaf]

The Problem:

Your Discord bot, built using Go, isn’t correctly accessing your MySQL database within your message event handler. You’re trying to avoid using global variables or creating a new database connection for every message, which are both suboptimal approaches. The core challenge is integrating your database interaction into the discordgo.Session.AddHandler function’s required signature, which only accepts handlers with specific argument types.

Understanding the “Why” (The Root Cause):

The discordgo.Session.AddHandler function expects a function with a specific signature to process events. Directly passing the database connection and repository into this function is problematic because it violates principles of clean code and testability. Global variables introduce tight coupling and make testing difficult. Creating a new connection per message leads to excessive database load and resource consumption. The solution needs to maintain a single database connection while cleanly passing it to the handler.

Step-by-Step Guide:

1. Use a Struct to Manage Dependencies: The most effective solution is to encapsulate both your database connection and your database repository within a struct. This struct will then contain the handler function as a method. This approach elegantly handles dependency injection and keeps your code organized.

   type BotHandler struct {
       db   *sql.DB
       repo *dbRepo.UserRepo
   }
   
   func (b *BotHandler) handleUserMessage(session *discordgo.Session, message *discordgo.MessageCreate) {
       // Access b.db and b.repo here
       user, err := b.repo.GetUser(message.Author.ID)
       if err != nil {
           log.Printf("Database error: %v", err)
           return
       }
       // Handle user data
   }
   
   func StartBot() {
       botSession, sessionErr := discordgo.New("Bot " + ApiToken)
       validateError(sessionErr)
   
       mysqlDb, dbError := SetupDatabase()
       validateError(dbError)
       defer mysqlDb.Close()
   
       handler := &BotHandler{
           db:   mysqlDb,
           repo: dbRepo.CreateUserRepo(mysqlDb),
       }
   
       botSession.AddHandler(handler.handleUserMessage)
       // ... rest of your bot setup ...
   }
   

2. Verify Database Connection: Before starting the bot, ensure your SetupDatabase() function successfully connects to your MySQL database. Add comprehensive error handling to SetupDatabase() to catch any connection issues early. Check your database credentials, hostname, and port settings.

3. Test the Database Interaction: After implementing the BotHandler struct, thoroughly test the handleUserMessage function. Create unit tests to verify that it correctly interacts with your database repository and handles potential errors gracefully.

Common Pitfalls & What to Check Next:

• Error Handling: Always handle potential errors from database operations. Use log.Printf to provide informative error messages that include the context. Consider using a more robust error handling system if needed (e.g., structured logging).
• Database Performance: If your bot handles a large number of messages, monitor your database performance. Optimize database queries and consider connection pooling techniques to prevent performance bottlenecks.
• Concurrency: Be mindful of concurrency issues if you’re handling multiple messages concurrently. Use proper synchronization mechanisms if necessary to prevent race conditions.
• Data Validation: Ensure that data received from Discord is properly sanitized and validated before using it in database queries. This prevents SQL injection vulnerabilities.

Still running into issues? Share your (sanitized) config files, the exact command you ran, and any other relevant details. The community is here to help!