new structure

Author: elisiei

cmd/bot/bot.go

@@ -1,10 +1,10 @@
 package main
 
 import (
-	_ "go.fm/commands/chart"
-	_ "go.fm/commands/fm"
-	_ "go.fm/commands/profile"
-	_ "go.fm/commands/setuser"
-	_ "go.fm/commands/stats"
-	_ "go.fm/commands/update"
+	_ "go.fm/internal/bot/commands/chart"
+	_ "go.fm/internal/bot/commands/fm"
+	_ "go.fm/internal/bot/commands/profile"
+	_ "go.fm/internal/bot/commands/setuser"
+	_ "go.fm/internal/bot/commands/stats"
+	_ "go.fm/internal/bot/commands/update"
 )

cmd/bot/commands.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"go.fm/internal/bot/bot"
+	"go.fm/internal/bot/logging"
+)
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}
+
+func main() {
+	token := os.Getenv("DISCORD_TOKEN")
+	lastfmKey := os.Getenv("LASTFM_API_KEY")
+	dbPath := getEnv("DATABASE_PATH", "file:database.db?_foreign_keys=on")
+
+	if token == "" || lastfmKey == "" {
+		logging.Fatal("DISCORD_TOKEN and LASTFM_API_KEY must be set")
+	}
+
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer cancel()
+
+	b, err := bot.NewBot(ctx, token, dbPath, lastfmKey)
+	if err != nil {
+		logging.Fatalf("failed to create bot: %v", err)
+	}
+
+	if err := b.Run(ctx); err != nil {
+		logging.Fatalf("bot stopped with error: %v", err)
+	}
+}

cmd/bot/main.go

@@ -0,0 +1,97 @@
+package bot
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/nxtgo/arikawa/v3/api/cmdroute"
+	"github.com/nxtgo/arikawa/v3/gateway"
+	"github.com/nxtgo/arikawa/v3/state"
+	"go.fm/internal/bot/bot/events"
+	"go.fm/internal/bot/commands"
+	"go.fm/internal/bot/lastfm"
+	"go.fm/internal/bot/logging"
+	"go.fm/internal/bot/persistence/sqlc"
+)
+
+// package for bot stuff idk.
+// functions that open connections should also return
+// a function to close that connection :pray:
+
+type Bot struct {
+	State    *state.State
+	Query    *sqlc.Queries
+	Database *sql.DB
+	LastFM   *lastfm.Services
+	Cache    *lastfm.Cache
+	Registry *events.Registry
+}
+
+func NewBot(ctx context.Context, token, dbPath, lastfmKey string) (*Bot, error) {
+	logging.Info("starting bot...")
+
+	// database
+	q, db, err := sqlc.Start(ctx, dbPath)
+	if err != nil {
+		return nil, err
+	}
+
+	// lastfm
+	cache := lastfm.NewCache()
+	lastfm := lastfm.NewServices(lastfmKey, cache)
+
+	// bot state
+	st := state.New("Bot " + token)
+	st.AddIntents(gateway.IntentGuilds)
+	st.AddIntents(gateway.IntentGuildMessages)
+
+	// events
+	reg := events.NewRegistry()
+	events.RegisterDefaultEvents(reg)
+
+	// commands
+	r := cmdroute.NewRouter()
+	commands.RegisterCommands(r, st, q, cache)
+	if err := commands.Sync(st); err != nil {
+		logging.Fatalf("failed syncing commands: %v", err)
+	}
+	st.AddInteractionHandler(r)
+
+	return &Bot{
+		State:    st,
+		Query:    q,
+		Database: db,
+		LastFM:   lastfm,
+		Cache:    cache,
+		Registry: reg,
+	}, nil
+}
+
+func (b *Bot) Run(ctx context.Context) error {
+	b.State.AddHandler(func(e *gateway.ReadyEvent) {
+		b.Registry.Dispatch(events.TypeName(e), e)
+	})
+
+	if err := b.State.Open(ctx); err != nil {
+		return err
+	}
+	defer b.State.Close()
+	defer b.Database.Close()
+	defer b.Cache.Close()
+
+	logging.Info("bot is running")
+
+	stop := make(chan os.Signal, 1)
+	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
+
+	select {
+	case <-ctx.Done():
+	case <-stop:
+	}
+
+	logging.Info("shutting down")
+	return nil
+}

events/events.go

@@ -0,0 +1,62 @@
+package events
+
+import (
+	"reflect"
+
+	"github.com/nxtgo/arikawa/v3/gateway"
+	"go.fm/internal/bot/logging"
+)
+
+func TypeName(evt any) string {
+	return reflect.TypeOf(evt).String()
+}
+
+// Handler is a generic event handler signature.
+type Handler func(evt any)
+
+// Registry holds all event handlers by event type.
+type Registry struct {
+	Handlers map[string][]Handler
+	logger   func(name string) *logging.Logger
+}
+
+// NewRegistry creates a new event registry.
+func NewRegistry() *Registry {
+	return &Registry{
+		Handlers: make(map[string][]Handler),
+		logger: func(name string) *logging.Logger {
+			return logging.WithFields(logging.F{"event_name": name})
+		},
+	}
+}
+
+// On registers a handler for a given event type.
+func (r *Registry) On(eventName string, h Handler) {
+	r.Handlers[eventName] = append(r.Handlers[eventName], h)
+}
+
+// Dispatch executes all handlers for a given event.
+func (r *Registry) Dispatch(eventName string, evt any) {
+	log := r.logger(eventName)
+	for _, h := range r.Handlers[eventName] {
+		func() {
+			defer func() {
+				if rec := recover(); rec != nil {
+					log.Errorw("panic in event handler", logging.F{"recover": rec})
+				}
+			}()
+			h(evt)
+		}()
+	}
+}
+
+func RegisterDefaultEvents(r *Registry) {
+	r.On(TypeName(&gateway.ReadyEvent{}), func(evt any) {
+		if c, ok := evt.(*gateway.ReadyEvent); ok {
+			r.logger("ready").Infow("client ready", logging.F{
+				"tag":    c.User.Tag(),
+				"guilds": len(c.Guilds),
+			})
+		}
+	})
+}

internal/bot/bot/bot.go

@@ -14,12 +14,12 @@ import (
 	"github.com/nxtgo/arikawa/v3/api"
 	"github.com/nxtgo/arikawa/v3/discord"
 	"github.com/nxtgo/arikawa/v3/utils/sendpart"
-	"go.fm/bild/font"
-	"go.fm/bild/imgio"
-	"go.fm/bild/transform"
-	"go.fm/commands"
-	lastfm "go.fm/last.fm"
-	"go.fm/pkg/reply"
+	"go.fm/internal/bot/commands"
+	"go.fm/internal/bot/discord/reply"
+	"go.fm/internal/bot/image/font"
+	"go.fm/internal/bot/image/imgio"
+	"go.fm/internal/bot/image/transform"
+	"go.fm/internal/bot/lastfm"
 )
 
 var (

internal/bot/bot/events/events.go

@@ -2,31 +2,32 @@ package commands
 
 import (
 	"context"
+	"os"
+	"time"
+
 	"github.com/nxtgo/arikawa/v3/api"
 	"github.com/nxtgo/arikawa/v3/api/cmdroute"
 	"github.com/nxtgo/arikawa/v3/state"
-	"go.fm/db"
-	lastfm "go.fm/last.fm"
-	"go.fm/pkg/reply"
-	"go.fm/zlog"
-	"os"
-	"time"
+	"go.fm/internal/bot/discord/reply"
+	"go.fm/internal/bot/lastfm"
+	"go.fm/internal/bot/logging"
+	"go.fm/internal/bot/persistence/sqlc"
 )
 
 var allCommands = []api.CreateCommandData{}
 var registry = map[string]CommandHandler{}
 
 func Register(meta api.CreateCommandData, handler CommandHandler) {
-	zlog.Log.Debugf("registered command %s", meta.Name)
+	logging.Debugf("registered command %s", meta.Name)
 
 	allCommands = append(allCommands, meta)
 	registry[meta.Name] = handler
 }
 
-func RegisterCommands(r *cmdroute.Router, st *state.State, q *db.Queries, c *lastfm.Cache) {
+func RegisterCommands(r *cmdroute.Router, st *state.State, q *sqlc.Queries, c *lastfm.Cache) {
 	lastFMApiKey := os.Getenv("LASTFM_API_KEY")
 	if lastFMApiKey == "" {
-		zlog.Log.Fatal("missing LASTFM_API_KEY env")
+		logging.Fatal("missing LASTFM_API_KEY env")
 	}
 
 	for name, handler := range registry {
@@ -52,7 +53,7 @@ func RegisterCommands(r *cmdroute.Router, st *state.State, q *db.Queries, c *las
 			// debugging purposes
 			start := time.Now()
 			err := h(commandContext)
-			zlog.Log.Debugw("executed command %s", zlog.F{"time": time.Since(start)}, name)
+			logging.Debugw("executed command %s", logging.F{"time": time.Since(start)}, name)
 
 			if err != nil {
 				commandContext.Reply.QuickEmbed(reply.ErrorEmbed(err.Error()))
@@ -64,6 +65,6 @@ func RegisterCommands(r *cmdroute.Router, st *state.State, q *db.Queries, c *las
 }
 
 func Sync(st *state.State) error {
-	defer zlog.Log.Infow("synced commands", zlog.F{"count": len(allCommands)})
+	defer logging.Infow("synced commands", logging.F{"count": len(allCommands)})
 	return cmdroute.OverwriteCommands(st, allCommands)
 }