chassis

Chassis

Chassis is a library that eliminates a bunch of the boilerplate when building new Discord bots. This library builds on top of the disgo library for the Discord API and adds convenience features related to:

• Bot initialization (setup and starting).
• Slash command handling.
• Error handling.

[!NOTE] This library should not be considered stable. There may be breaking changes between versions. See the Status and Contributions section below for more information.

Features

The aim of this library is to allow implementer to skip the process of writing code to handle setup+connecting to the API, writing event handlers for directing slash commands to the right place, and error handling. When all of the features are used in conjunction, an implementer can avoid doing those things and focus on writing the actual specific logic of their bot. For more detail on specific features, see each section below for more information.

Usage

Below you can find a very simple that demonstrates how to use this library. This bot has two separate slash commands with separate handlers for each. It shows how to attach handlers and how to connect the bot so it can start serving requests.

package main

import (
 	"context"
 	"log/slog"
 	"os"
 	"os/signal"

 	"github.com/disgoorg/disgo/discord"
 	"github.com/disgoorg/disgo/events"
 	"github.com/mrflynn/chassis"
)

func helloHandler(
 	_ context.Context,
 	_ *events.ApplicationCommandInteractionCreate,
 	_ *slog.Logger,
) (message discord.MessageCreate, err error) {
 	return discord.NewMessageCreateBuilder().
		SetContent("world!").
		Build(), nil
}

func helpHandler(
 	_ context.Context,
 	_ *events.ApplicationCommandInteractionCreate,
 	_ *slog.Logger,
) (message discord.MessageCreate, err error) {
 	return discord.NewMessageCreateBuilder().
		SetContent("No help for you").
		Build(), nil
}

var commands = []discord.ApplicationCommandCreate{
 	discord.SlashCommandCreate{Name: "hello"},
 	discord.SlashCommandCreate{Name: "help"},
}

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

 	bot := &chassis.Frame{Commands: commands}

 	chassis.AttachHandlers(
		bot,
		chassis.SlashCommandHandlerRef[discord.SlashCommandCreate, discord.MessageCreate]{
 			Command: chassis.PointerOf(commands[0].(discord.SlashCommandCreate)),
 			Handler: helloHandler,
		},
		chassis.SlashCommandHandlerRef[discord.SlashCommandCreate, discord.MessageCreate]{
 			Command: chassis.PointerOf(commands[1].(discord.SlashCommandCreate)),
 			Handler: helpHandler,
		},
 	)

 	if err := bot.Start(ctx, ""); err != nil {
		panic(err)
 	}

 	<-ctx.Done()
}

If you need more complex functionality, like handlers that are methods of the bot itself (to access custom struct fields), you can embed Frame and call AttachHandlers on those methods.

Motivation

As I've written a fair number of custom Discord bots for communities that I'm a member of, I find myself writing the same boilerplate code for every bot. This library distills and generalizes the setup, command, and error handling code I've implemented for each so I can avoid writing the same code every time I create a new bot. To be clear, this library is based on my tastes and needs so it's probably perfectly generalized nor comprehensive (if you need that, just use the underlying disgo package), but it covers enough of the base functionality one would want in a bot (even moderately complex ones), that I figured I would share what I built with the world.

Status and Contributions

This library should not be considered stable. There will probably be breaking changes between minor versions until 1.0.0. As I add more features there may be a need to refactor or rewrite large portions of this library to accommodate them. Please keep this in mind if you choose to use this library.

I probably won't accept feature requests that go beyond the scope of what's here unless it's something I need or can see myself needing in the future. Bug fixes are of course welcome.