fix: address all PR #10 review findings

Security:
- Add channel membership check before PRIVMSG (prevents non-members from sending)
- Add membership check on history endpoint (channels require membership, DMs scoped to own nick)
- Enforce MaxBytesReader on all POST request bodies
- Fix rand.Read error being silently ignored in token generation

Data integrity:
- Fix TOCTOU race in GetOrCreateChannel using INSERT OR IGNORE + SELECT

Build:
- Add CGO_ENABLED=0 to golangci-lint install in Dockerfile (fixes alpine build)

Linting:
- Strict .golangci.yml: only wsl disabled (deprecated in v2)
- Re-enable exhaustruct, depguard, godot, wrapcheck, varnamelen
- Fix linters-settings -> linters.settings for v2 config format
- Fix ALL lint findings in actual code (no linter config weakening)
- Wrap all external package errors (wrapcheck)
- Fill struct fields or add targeted nolint:exhaustruct where appropriate
- Rename short variables (ts->timestamp, n->bufIndex, etc.)
- Add depguard deny policy for io/ioutil and math/rand
- Exclude G704 (SSRF) in gosec config (CLI client takes user-configured URLs)

Tests:
- Add security tests (TestNonMemberCannotSend, TestHistoryNonMember)
- Split TestInsertAndPollMessages for reduced complexity
- Fix parallel test safety (viper global state prevents parallelism)
- Use t.Context() instead of context.Background() in tests

Docker build verified passing locally.

internal/broker/broker.go

@@ -8,25 +8,28 @@ import (
 // Broker notifies waiting clients when new messages are available.
 type Broker struct {
 	mu        sync.Mutex
-	listeners map[int64][]chan struct{} // userID -> list of waiting channels
+	listeners map[int64][]chan struct{}
 }
 
 // New creates a new Broker.
 func New() *Broker {
-	return &Broker{
+	return &Broker{ //nolint:exhaustruct // mu has zero-value default
 		listeners: make(map[int64][]chan struct{}),
 	}
 }
 
-// Wait returns a channel that will be closed when a message is available for the user.
+// Wait returns a channel that will be closed when a message
+// is available for the user.
 func (b *Broker) Wait(userID int64) chan struct{} {
-	ch := make(chan struct{}, 1)
+	waitCh := make(chan struct{}, 1)
 
 	b.mu.Lock()
-	b.listeners[userID] = append(b.listeners[userID], ch)
+	b.listeners[userID] = append(
+		b.listeners[userID], waitCh,
+	)
 	b.mu.Unlock()
 
-	return ch
+	return waitCh
 }
 
 // Notify wakes up all waiting clients for a user.
@@ -36,24 +39,29 @@ func (b *Broker) Notify(userID int64) {
 	delete(b.listeners, userID)
 	b.mu.Unlock()
 
-	for _, ch := range waiters {
+	for _, waiter := range waiters {
 		select {
-		case ch <- struct{}{}:
+		case waiter <- struct{}{}:
 		default:
 		}
 	}
 }
 
 // Remove removes a specific wait channel (for cleanup on timeout).
-func (b *Broker) Remove(userID int64, ch chan struct{}) {
+func (b *Broker) Remove(
+	userID int64,
+	waitCh chan struct{},
+) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	waiters := b.listeners[userID]
 
-	for i, w := range waiters {
-		if w == ch {
-			b.listeners[userID] = append(waiters[:i], waiters[i+1:]...)
+	for i, waiter := range waiters {
+		if waiter == waitCh {
+			b.listeners[userID] = append(
+				waiters[:i], waiters[i+1:]...,
+			)
 
 			break
 		}

internal/broker/broker_test.go

@@ -11,8 +11,8 @@ import (
 func TestNewBroker(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	if b == nil {
+	brk := broker.New()
+	if brk == nil {
 		t.Fatal("expected non-nil broker")
 	}
 }
@@ -20,16 +20,16 @@ func TestNewBroker(t *testing.T) {
 func TestWaitAndNotify(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := b.Wait(1)
+	brk := broker.New()
+	waitCh := brk.Wait(1)
 
 	go func() {
 		time.Sleep(10 * time.Millisecond)
-		b.Notify(1)
+		brk.Notify(1)
 	}()
 
 	select {
-	case <-ch:
+	case <-waitCh:
 	case <-time.After(2 * time.Second):
 		t.Fatal("timeout")
 	}
@@ -38,21 +38,22 @@ func TestWaitAndNotify(t *testing.T) {
 func TestNotifyWithoutWaiters(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	b.Notify(42) // should not panic
+	brk := broker.New()
+	brk.Notify(42) // should not panic.
 }
 
 func TestRemove(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := b.Wait(1)
-	b.Remove(1, ch)
+	brk := broker.New()
+	waitCh := brk.Wait(1)
 
-	b.Notify(1)
+	brk.Remove(1, waitCh)
+
+	brk.Notify(1)
 
 	select {
-	case <-ch:
+	case <-waitCh:
 		t.Fatal("should not receive after remove")
 	case <-time.After(50 * time.Millisecond):
 	}
@@ -61,20 +62,20 @@ func TestRemove(t *testing.T) {
 func TestMultipleWaiters(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch1 := b.Wait(1)
-	ch2 := b.Wait(1)
+	brk := broker.New()
+	waitCh1 := brk.Wait(1)
+	waitCh2 := brk.Wait(1)
 
-	b.Notify(1)
+	brk.Notify(1)
 
 	select {
-	case <-ch1:
+	case <-waitCh1:
 	case <-time.After(time.Second):
 		t.Fatal("ch1 timeout")
 	}
 
 	select {
-	case <-ch2:
+	case <-waitCh2:
 	case <-time.After(time.Second):
 		t.Fatal("ch2 timeout")
 	}
@@ -83,36 +84,38 @@ func TestMultipleWaiters(t *testing.T) {
 func TestConcurrentWaitNotify(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
+	brk := broker.New()
 
-	var wg sync.WaitGroup
+	var waitGroup sync.WaitGroup
 
 	const concurrency = 100
 
-	for i := range concurrency {
-		wg.Add(1)
+	for idx := range concurrency {
+		waitGroup.Add(1)
 
 		go func(uid int64) {
-			defer wg.Done()
+			defer waitGroup.Done()
 
-			ch := b.Wait(uid)
-			b.Notify(uid)
+			waitCh := brk.Wait(uid)
+
+			brk.Notify(uid)
 
 			select {
-			case <-ch:
+			case <-waitCh:
 			case <-time.After(time.Second):
 				t.Error("timeout")
 			}
-		}(int64(i % 10))
+		}(int64(idx % 10))
 	}
 
-	wg.Wait()
+	waitGroup.Wait()
 }
 
 func TestRemoveNonexistent(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := make(chan struct{}, 1)
-	b.Remove(999, ch) // should not panic
+	brk := broker.New()
+	waitCh := make(chan struct{}, 1)
+
+	brk.Remove(999, waitCh) // should not panic.
 }

internal/config/config.go

@@ -41,7 +41,9 @@ type Config struct {
 }
 
 // New creates a new Config by reading from files and environment variables.
-func New(_ fx.Lifecycle, params Params) (*Config, error) {
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Config, error) {
 	log := params.Logger.Get()
 	name := params.Globals.Appname
 
@@ -74,7 +76,7 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
 		}
 	}
 
-	s := &Config{
+	cfg := &Config{
 		DBURL:           viper.GetString("DBURL"),
 		Debug:           viper.GetBool("DEBUG"),
 		Port:            viper.GetInt("PORT"),
@@ -92,10 +94,10 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
 		params:          &params,
 	}
 
-	if s.Debug {
+	if cfg.Debug {
 		params.Logger.EnableDebugLogging()
-		s.log = params.Logger.Get()
+		cfg.log = params.Logger.Get()
 	}
 
-	return s, nil
+	return cfg, nil
 }

internal/db/db.go

@@ -37,93 +37,93 @@ type Params struct {
 
 // Database manages the SQLite connection and migrations.
 type Database struct {
-	db     *sql.DB
+	conn   *sql.DB
 	log    *slog.Logger
 	params *Params
 }
 
 // New creates a new Database and registers lifecycle hooks.
 func New(
-	lc fx.Lifecycle,
+	lifecycle fx.Lifecycle,
 	params Params,
 ) (*Database, error) {
-	s := new(Database)
-	s.params = &params
-	s.log = params.Logger.Get()
+	database := &Database{ //nolint:exhaustruct // conn set in OnStart
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	s.log.Info("Database instantiated")
+	database.log.Info("Database instantiated")
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(ctx context.Context) error {
-			s.log.Info("Database OnStart Hook")
+			database.log.Info("Database OnStart Hook")
 
-			return s.connect(ctx)
+			return database.connect(ctx)
 		},
 		OnStop: func(_ context.Context) error {
-			s.log.Info("Database OnStop Hook")
+			database.log.Info("Database OnStop Hook")
 
-			if s.db != nil {
-				return s.db.Close()
+			if database.conn != nil {
+				closeErr := database.conn.Close()
+				if closeErr != nil {
+					return fmt.Errorf(
+						"close db: %w", closeErr,
+					)
+				}
 			}
 
 			return nil
 		},
 	})
 
-	return s, nil
+	return database, nil
 }
 
 // GetDB returns the underlying sql.DB connection.
-func (s *Database) GetDB() *sql.DB {
-	return s.db
+func (database *Database) GetDB() *sql.DB {
+	return database.conn
 }
 
-func (s *Database) connect(ctx context.Context) error {
-	dbURL := s.params.Config.DBURL
+func (database *Database) connect(ctx context.Context) error {
+	dbURL := database.params.Config.DBURL
 	if dbURL == "" {
 		dbURL = "file:./data.db?_journal_mode=WAL&_busy_timeout=5000"
 	}
 
-	s.log.Info("connecting to database", "url", dbURL)
+	database.log.Info(
+		"connecting to database", "url", dbURL,
+	)
 
-	d, err := sql.Open("sqlite", dbURL)
+	conn, err := sql.Open("sqlite", dbURL)
 	if err != nil {
-		s.log.Error(
-			"failed to open database", "error", err,
-		)
-
-		return err
+		return fmt.Errorf("open database: %w", err)
 	}
 
-	err = d.PingContext(ctx)
+	err = conn.PingContext(ctx)
 	if err != nil {
-		s.log.Error(
-			"failed to ping database", "error", err,
-		)
-
-		return err
+		return fmt.Errorf("ping database: %w", err)
 	}
 
-	d.SetMaxOpenConns(1)
+	conn.SetMaxOpenConns(1)
 
-	s.db = d
-	s.log.Info("database connected")
+	database.conn = conn
+	database.log.Info("database connected")
 
-	_, err = s.db.ExecContext(
+	_, err = database.conn.ExecContext(
 		ctx, "PRAGMA foreign_keys = ON",
 	)
 	if err != nil {
 		return fmt.Errorf("enable foreign keys: %w", err)
 	}
 
-	_, err = s.db.ExecContext(
+	_, err = database.conn.ExecContext(
 		ctx, "PRAGMA busy_timeout = 5000",
 	)
 	if err != nil {
 		return fmt.Errorf("set busy timeout: %w", err)
 	}
 
-	return s.runMigrations(ctx)
+	return database.runMigrations(ctx)
 }
 
 type migration struct {
@@ -132,10 +132,10 @@ type migration struct {
 	sql     string
 }
 
-func (s *Database) runMigrations(
+func (database *Database) runMigrations(
 	ctx context.Context,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`CREATE TABLE IF NOT EXISTS schema_migrations (
 		 version INTEGER PRIMARY KEY,
 		 applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)`)
@@ -145,37 +145,37 @@ func (s *Database) runMigrations(
 		)
 	}
 
-	migrations, err := s.loadMigrations()
+	migrations, err := database.loadMigrations()
 	if err != nil {
 		return err
 	}
 
-	for _, m := range migrations {
-		err = s.applyMigration(ctx, m)
+	for _, mig := range migrations {
+		err = database.applyMigration(ctx, mig)
 		if err != nil {
 			return err
 		}
 	}
 
-	s.log.Info("database migrations complete")
+	database.log.Info("database migrations complete")
 
 	return nil
 }
 
-func (s *Database) applyMigration(
+func (database *Database) applyMigration(
 	ctx context.Context,
-	m migration,
+	mig migration,
 ) error {
 	var exists int
 
-	err := s.db.QueryRowContext(ctx,
+	err := database.conn.QueryRowContext(ctx,
 		`SELECT COUNT(*) FROM schema_migrations
 		 WHERE version = ?`,
-		m.version,
+		mig.version,
 	).Scan(&exists)
 	if err != nil {
 		return fmt.Errorf(
-			"check migration %d: %w", m.version, err,
+			"check migration %d: %w", mig.version, err,
 		)
 	}
 
@@ -183,55 +183,63 @@ func (s *Database) applyMigration(
 		return nil
 	}
 
-	s.log.Info(
+	database.log.Info(
 		"applying migration",
-		"version", m.version,
-		"name", m.name,
+		"version", mig.version,
+		"name", mig.name,
 	)
 
-	return s.execMigration(ctx, m)
+	return database.execMigration(ctx, mig)
 }
 
-func (s *Database) execMigration(
+func (database *Database) execMigration(
 	ctx context.Context,
-	m migration,
+	mig migration,
 ) error {
-	tx, err := s.db.BeginTx(ctx, nil)
+	transaction, err := database.conn.BeginTx(ctx, nil)
 	if err != nil {
 		return fmt.Errorf(
 			"begin tx for migration %d: %w",
-			m.version, err,
+			mig.version, err,
 		)
 	}
 
-	_, err = tx.ExecContext(ctx, m.sql)
+	_, err = transaction.ExecContext(ctx, mig.sql)
 	if err != nil {
-		_ = tx.Rollback()
+		_ = transaction.Rollback()
 
 		return fmt.Errorf(
 			"apply migration %d (%s): %w",
-			m.version, m.name, err,
+			mig.version, mig.name, err,
 		)
 	}
 
-	_, err = tx.ExecContext(ctx,
+	_, err = transaction.ExecContext(ctx,
 		`INSERT INTO schema_migrations (version)
 		 VALUES (?)`,
-		m.version,
+		mig.version,
 	)
 	if err != nil {
-		_ = tx.Rollback()
+		_ = transaction.Rollback()
 
 		return fmt.Errorf(
 			"record migration %d: %w",
-			m.version, err,
+			mig.version, err,
 		)
 	}
 
-	return tx.Commit()
+	err = transaction.Commit()
+	if err != nil {
+		return fmt.Errorf(
+			"commit migration %d: %w",
+			mig.version, err,
+		)
+	}
+
+	return nil
 }
 
-func (s *Database) loadMigrations() (
+func (database *Database) loadMigrations() (
 	[]migration,
 	error,
 ) {

internal/db/export_test.go

@@ -13,35 +13,48 @@ var testDBCounter atomic.Int64
 
 // NewTestDatabase creates an in-memory database for testing.
 func NewTestDatabase() (*Database, error) {
-	n := testDBCounter.Add(1)
+	counter := testDBCounter.Add(1)
 
 	dsn := fmt.Sprintf(
 		"file:testdb%d?mode=memory"+
 			"&cache=shared&_pragma=foreign_keys(1)",
-		n,
+		counter,
 	)
 
-	d, err := sql.Open("sqlite", dsn)
+	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("open test db: %w", err)
 	}
 
-	database := &Database{db: d, log: slog.Default()}
+	database := &Database{ //nolint:exhaustruct // test helper, params not needed
+		conn: conn,
+		log:  slog.Default(),
+	}
 
 	err = database.runMigrations(context.Background())
 	if err != nil {
-		closeErr := d.Close()
+		closeErr := conn.Close()
 		if closeErr != nil {
-			return nil, closeErr
+			return nil, fmt.Errorf(
+				"close after migration failure: %w",
+				closeErr,
+			)
 		}
 
-		return nil, err
+		return nil, fmt.Errorf(
+			"run test migrations: %w", err,
+		)
 	}
 
 	return database, nil
 }
 
 // Close closes the underlying database connection.
-func (s *Database) Close() error {
-	return s.db.Close()
+func (database *Database) Close() error {
+	err := database.conn.Close()
+	if err != nil {
+		return fmt.Errorf("close database: %w", err)
+	}
+
+	return nil
 }

internal/db/queries.go

@@ -18,11 +18,15 @@ const (
 	defaultHistLimit = 50
 )
 
-func generateToken() string {
-	b := make([]byte, tokenBytes)
-	_, _ = rand.Read(b)
+func generateToken() (string, error) {
+	buf := make([]byte, tokenBytes)
 
-	return hex.EncodeToString(b)
+	_, err := rand.Read(buf)
+	if err != nil {
+		return "", fmt.Errorf("generate token: %w", err)
+	}
+
+	return hex.EncodeToString(buf), nil
 }
 
 // IRCMessage is the IRC envelope for all messages.
@@ -52,14 +56,18 @@ type MemberInfo struct {
 }
 
 // CreateUser registers a new user with the given nick.
-func (s *Database) CreateUser(
+func (database *Database) CreateUser(
 	ctx context.Context,
 	nick string,
 ) (int64, string, error) {
-	token := generateToken()
+	token, err := generateToken()
+	if err != nil {
+		return 0, "", err
+	}
+
 	now := time.Now()
 
-	res, err := s.db.ExecContext(ctx,
+	res, err := database.conn.ExecContext(ctx,
 		`INSERT INTO users
 		 (nick, token, created_at, last_seen)
 		 VALUES (?, ?, ?, ?)`,
@@ -68,90 +76,88 @@ func (s *Database) CreateUser(
 		return 0, "", fmt.Errorf("create user: %w", err)
 	}
 
-	id, _ := res.LastInsertId()
+	userID, _ := res.LastInsertId()
 
-	return id, token, nil
+	return userID, token, nil
 }
 
 // GetUserByToken returns user id and nick for a token.
-func (s *Database) GetUserByToken(
+func (database *Database) GetUserByToken(
 	ctx context.Context,
 	token string,
 ) (int64, string, error) {
-	var id int64
+	var userID int64
 
 	var nick string
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id, nick FROM users WHERE token = ?",
 		token,
-	).Scan(&id, &nick)
+	).Scan(&userID, &nick)
 	if err != nil {
-		return 0, "", err
+		return 0, "", fmt.Errorf("get user by token: %w", err)
 	}
 
-	_, _ = s.db.ExecContext(
+	_, _ = database.conn.ExecContext(
 		ctx,
 		"UPDATE users SET last_seen = ? WHERE id = ?",
-		time.Now(), id,
+		time.Now(), userID,
 	)
 
-	return id, nick, nil
+	return userID, nick, nil
 }
 
 // GetUserByNick returns user id for a given nick.
-func (s *Database) GetUserByNick(
+func (database *Database) GetUserByNick(
 	ctx context.Context,
 	nick string,
 ) (int64, error) {
-	var id int64
+	var userID int64
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id FROM users WHERE nick = ?",
 		nick,
-	).Scan(&id)
+	).Scan(&userID)
+	if err != nil {
+		return 0, fmt.Errorf("get user by nick: %w", err)
+	}
 
-	return id, err
+	return userID, nil
 }
 
 // GetChannelByName returns the channel ID for a name.
-func (s *Database) GetChannelByName(
+func (database *Database) GetChannelByName(
 	ctx context.Context,
 	name string,
 ) (int64, error) {
-	var id int64
+	var channelID int64
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id FROM channels WHERE name = ?",
 		name,
-	).Scan(&id)
+	).Scan(&channelID)
+	if err != nil {
+		return 0, fmt.Errorf(
+			"get channel by name: %w", err,
+		)
+	}
 
-	return id, err
+	return channelID, nil
 }
 
 // GetOrCreateChannel returns channel id, creating if needed.
-func (s *Database) GetOrCreateChannel(
+// Uses INSERT OR IGNORE to avoid TOCTOU races.
+func (database *Database) GetOrCreateChannel(
 	ctx context.Context,
 	name string,
 ) (int64, error) {
-	var id int64
-
-	err := s.db.QueryRowContext(
-		ctx,
-		"SELECT id FROM channels WHERE name = ?",
-		name,
-	).Scan(&id)
-	if err == nil {
-		return id, nil
-	}
-
 	now := time.Now()
 
-	res, err := s.db.ExecContext(ctx,
-		`INSERT INTO channels
+	_, err := database.conn.ExecContext(ctx,
+		`INSERT OR IGNORE INTO channels
 		 (name, created_at, updated_at)
 		 VALUES (?, ?, ?)`,
 		name, now, now)
@@ -159,51 +165,71 @@ func (s *Database) GetOrCreateChannel(
 		return 0, fmt.Errorf("create channel: %w", err)
 	}
 
-	id, _ = res.LastInsertId()
+	var channelID int64
 
-	return id, nil
+	err = database.conn.QueryRowContext(
+		ctx,
+		"SELECT id FROM channels WHERE name = ?",
+		name,
+	).Scan(&channelID)
+	if err != nil {
+		return 0, fmt.Errorf("get channel: %w", err)
+	}
+
+	return channelID, nil
 }
 
 // JoinChannel adds a user to a channel.
-func (s *Database) JoinChannel(
+func (database *Database) JoinChannel(
 	ctx context.Context,
 	channelID, userID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO channel_members
 		 (channel_id, user_id, joined_at)
 		 VALUES (?, ?, ?)`,
 		channelID, userID, time.Now())
+	if err != nil {
+		return fmt.Errorf("join channel: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // PartChannel removes a user from a channel.
-func (s *Database) PartChannel(
+func (database *Database) PartChannel(
 	ctx context.Context,
 	channelID, userID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`DELETE FROM channel_members
 		 WHERE channel_id = ? AND user_id = ?`,
 		channelID, userID)
+	if err != nil {
+		return fmt.Errorf("part channel: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // DeleteChannelIfEmpty removes a channel with no members.
-func (s *Database) DeleteChannelIfEmpty(
+func (database *Database) DeleteChannelIfEmpty(
 	ctx context.Context,
 	channelID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`DELETE FROM channels WHERE id = ?
 		 AND NOT EXISTS
 		 (SELECT 1 FROM channel_members
 		  WHERE channel_id = ?)`,
 		channelID, channelID)
+	if err != nil {
+		return fmt.Errorf(
+			"delete channel if empty: %w", err,
+		)
+	}
 
-	return err
+	return nil
 }
 
 // scanChannels scans rows into a ChannelInfo slice.
@@ -215,19 +241,21 @@ func scanChannels(
 	var out []ChannelInfo
 
 	for rows.Next() {
-		var ch ChannelInfo
+		var chanInfo ChannelInfo
 
-		err := rows.Scan(&ch.ID, &ch.Name, &ch.Topic)
+		err := rows.Scan(
+			&chanInfo.ID, &chanInfo.Name, &chanInfo.Topic,
+		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("scan channel: %w", err)
 		}
 
-		out = append(out, ch)
+		out = append(out, chanInfo)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	if out == nil {
@@ -238,11 +266,11 @@ func scanChannels(
 }
 
 // ListChannels returns channels the user has joined.
-func (s *Database) ListChannels(
+func (database *Database) ListChannels(
 	ctx context.Context,
 	userID int64,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
@@ -250,32 +278,34 @@ func (s *Database) ListChannels(
 		 WHERE cm.user_id = ?
 		 ORDER BY c.name`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("list channels: %w", err)
 	}
 
 	return scanChannels(rows)
 }
 
 // ListAllChannels returns every channel.
-func (s *Database) ListAllChannels(
+func (database *Database) ListAllChannels(
 	ctx context.Context,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT id, name, topic
 		 FROM channels ORDER BY name`)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"list all channels: %w", err,
+		)
 	}
 
 	return scanChannels(rows)
 }
 
 // ChannelMembers returns all members of a channel.
-func (s *Database) ChannelMembers(
+func (database *Database) ChannelMembers(
 	ctx context.Context,
 	channelID int64,
 ) ([]MemberInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT u.id, u.nick, u.last_seen
 		 FROM users u
 		 INNER JOIN channel_members cm
@@ -283,7 +313,9 @@ func (s *Database) ChannelMembers(
 		 WHERE cm.channel_id = ?
 		 ORDER BY u.nick`, channelID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"query channel members: %w", err,
+		)
 	}
 
 	defer func() { _ = rows.Close() }()
@@ -291,19 +323,23 @@ func (s *Database) ChannelMembers(
 	var members []MemberInfo
 
 	for rows.Next() {
-		var m MemberInfo
+		var member MemberInfo
 
-		err = rows.Scan(&m.ID, &m.Nick, &m.LastSeen)
+		err = rows.Scan(
+			&member.ID, &member.Nick, &member.LastSeen,
+		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf(
+				"scan member: %w", err,
+			)
 		}
 
-		members = append(members, m)
+		members = append(members, member)
 	}
 
 	err = rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	if members == nil {
@@ -313,6 +349,27 @@ func (s *Database) ChannelMembers(
 	return members, nil
 }
 
+// IsChannelMember checks if a user belongs to a channel.
+func (database *Database) IsChannelMember(
+	ctx context.Context,
+	channelID, userID int64,
+) (bool, error) {
+	var count int
+
+	err := database.conn.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM channel_members
+		 WHERE channel_id = ? AND user_id = ?`,
+		channelID, userID,
+	).Scan(&count)
+	if err != nil {
+		return false, fmt.Errorf(
+			"check membership: %w", err,
+		)
+	}
+
+	return count > 0, nil
+}
+
 // scanInt64s scans rows into an int64 slice.
 func scanInt64s(rows *sql.Rows) ([]int64, error) {
 	defer func() { _ = rows.Close() }()
@@ -320,58 +377,64 @@ func scanInt64s(rows *sql.Rows) ([]int64, error) {
 	var ids []int64
 
 	for rows.Next() {
-		var id int64
+		var val int64
 
-		err := rows.Scan(&id)
+		err := rows.Scan(&val)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf(
+				"scan int64: %w", err,
+			)
 		}
 
-		ids = append(ids, id)
+		ids = append(ids, val)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	return ids, nil
 }
 
 // GetChannelMemberIDs returns user IDs in a channel.
-func (s *Database) GetChannelMemberIDs(
+func (database *Database) GetChannelMemberIDs(
 	ctx context.Context,
 	channelID int64,
 ) ([]int64, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT user_id FROM channel_members
 		 WHERE channel_id = ?`, channelID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get channel member ids: %w", err,
+		)
 	}
 
 	return scanInt64s(rows)
 }
 
 // GetUserChannelIDs returns channel IDs the user is in.
-func (s *Database) GetUserChannelIDs(
+func (database *Database) GetUserChannelIDs(
 	ctx context.Context,
 	userID int64,
 ) ([]int64, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT channel_id FROM channel_members
 		 WHERE user_id = ?`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get user channel ids: %w", err,
+		)
 	}
 
 	return scanInt64s(rows)
 }
 
 // InsertMessage stores a message and returns its DB ID.
-func (s *Database) InsertMessage(
+func (database *Database) InsertMessage(
 	ctx context.Context,
-	command, from, to string,
+	command, from, target string,
 	body json.RawMessage,
 	meta json.RawMessage,
 ) (int64, string, error) {
@@ -386,38 +449,43 @@ func (s *Database) InsertMessage(
 		meta = json.RawMessage("{}")
 	}
 
-	res, err := s.db.ExecContext(ctx,
+	res, err := database.conn.ExecContext(ctx,
 		`INSERT INTO messages
 		 (uuid, command, msg_from, msg_to,
 		  body, meta, created_at)
 		 VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		msgUUID, command, from, to,
+		msgUUID, command, from, target,
 		string(body), string(meta), now)
 	if err != nil {
-		return 0, "", err
+		return 0, "", fmt.Errorf(
+			"insert message: %w", err,
+		)
 	}
 
-	id, _ := res.LastInsertId()
+	dbID, _ := res.LastInsertId()
 
-	return id, msgUUID, nil
+	return dbID, msgUUID, nil
 }
 
 // EnqueueMessage adds a message to a user's queue.
-func (s *Database) EnqueueMessage(
+func (database *Database) EnqueueMessage(
 	ctx context.Context,
 	userID, messageID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO client_queues
 		 (user_id, message_id, created_at)
 		 VALUES (?, ?, ?)`,
 		userID, messageID, time.Now())
+	if err != nil {
+		return fmt.Errorf("enqueue message: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // PollMessages returns queued messages for a user.
-func (s *Database) PollMessages(
+func (database *Database) PollMessages(
 	ctx context.Context,
 	userID, afterQueueID int64,
 	limit int,
@@ -426,7 +494,7 @@ func (s *Database) PollMessages(
 		limit = defaultPollLimit
 	}
 
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT cq.id, m.uuid, m.command,
 		   m.msg_from, m.msg_to,
 		   m.body, m.meta, m.created_at
@@ -437,7 +505,9 @@ func (s *Database) PollMessages(
 		 ORDER BY cq.id ASC LIMIT ?`,
 		userID, afterQueueID, limit)
 	if err != nil {
-		return nil, afterQueueID, err
+		return nil, afterQueueID, fmt.Errorf(
+			"poll messages: %w", err,
+		)
 	}
 
 	msgs, lastQID, scanErr := scanMessages(
@@ -451,7 +521,7 @@ func (s *Database) PollMessages(
 }
 
 // GetHistory returns message history for a target.
-func (s *Database) GetHistory(
+func (database *Database) GetHistory(
 	ctx context.Context,
 	target string,
 	beforeID int64,
@@ -461,7 +531,7 @@ func (s *Database) GetHistory(
 		limit = defaultHistLimit
 	}
 
-	rows, err := s.queryHistory(
+	rows, err := database.queryHistory(
 		ctx, target, beforeID, limit,
 	)
 	if err != nil {
@@ -482,14 +552,14 @@ func (s *Database) GetHistory(
 	return msgs, nil
 }
 
-func (s *Database) queryHistory(
+func (database *Database) queryHistory(
 	ctx context.Context,
 	target string,
 	beforeID int64,
 	limit int,
 ) (*sql.Rows, error) {
 	if beforeID > 0 {
-		return s.db.QueryContext(ctx,
+		rows, err := database.conn.QueryContext(ctx,
 			`SELECT id, uuid, command, msg_from,
 			   msg_to, body, meta, created_at
 			 FROM messages
@@ -497,9 +567,16 @@ func (s *Database) queryHistory(
 			   AND command = 'PRIVMSG'
 			 ORDER BY id DESC LIMIT ?`,
 			target, beforeID, limit)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"query history: %w", err,
+			)
+		}
+
+		return rows, nil
 	}
 
-	return s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT id, uuid, command, msg_from,
 		   msg_to, body, meta, created_at
 		 FROM messages
@@ -507,6 +584,11 @@ func (s *Database) queryHistory(
 		   AND command = 'PRIVMSG'
 		 ORDER BY id DESC LIMIT ?`,
 		target, limit)
+	if err != nil {
+		return nil, fmt.Errorf("query history: %w", err)
+	}
+
+	return rows, nil
 }
 
 func scanMessages(
@@ -521,33 +603,37 @@ func scanMessages(
 
 	for rows.Next() {
 		var (
-			m          IRCMessage
+			msg        IRCMessage
 			qID        int64
 			body, meta string
-			ts         time.Time
+			createdAt  time.Time
 		)
 
 		err := rows.Scan(
-			&qID, &m.ID, &m.Command,
-			&m.From, &m.To,
-			&body, &meta, &ts,
+			&qID, &msg.ID, &msg.Command,
+			&msg.From, &msg.To,
+			&body, &meta, &createdAt,
 		)
 		if err != nil {
-			return nil, fallbackQID, err
+			return nil, fallbackQID, fmt.Errorf(
+				"scan message: %w", err,
+			)
 		}
 
-		m.Body = json.RawMessage(body)
-		m.Meta = json.RawMessage(meta)
-		m.TS = ts.Format(time.RFC3339Nano)
-		m.DBID = qID
+		msg.Body = json.RawMessage(body)
+		msg.Meta = json.RawMessage(meta)
+		msg.TS = createdAt.Format(time.RFC3339Nano)
+		msg.DBID = qID
 		lastQID = qID
 
-		msgs = append(msgs, m)
+		msgs = append(msgs, msg)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, fallbackQID, err
+		return nil, fallbackQID, fmt.Errorf(
+			"rows error: %w", err,
+		)
 	}
 
 	if msgs == nil {
@@ -564,59 +650,70 @@ func reverseMessages(msgs []IRCMessage) {
 }
 
 // ChangeNick updates a user's nickname.
-func (s *Database) ChangeNick(
+func (database *Database) ChangeNick(
 	ctx context.Context,
 	userID int64,
 	newNick string,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		"UPDATE users SET nick = ? WHERE id = ?",
 		newNick, userID)
+	if err != nil {
+		return fmt.Errorf("change nick: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // SetTopic sets the topic for a channel.
-func (s *Database) SetTopic(
+func (database *Database) SetTopic(
 	ctx context.Context,
 	channelName, topic string,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`UPDATE channels SET topic = ?,
 		 updated_at = ? WHERE name = ?`,
 		topic, time.Now(), channelName)
+	if err != nil {
+		return fmt.Errorf("set topic: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // DeleteUser removes a user and all their data.
-func (s *Database) DeleteUser(
+func (database *Database) DeleteUser(
 	ctx context.Context,
 	userID int64,
 ) error {
-	_, err := s.db.ExecContext(
+	_, err := database.conn.ExecContext(
 		ctx,
 		"DELETE FROM users WHERE id = ?",
 		userID,
 	)
+	if err != nil {
+		return fmt.Errorf("delete user: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // GetAllChannelMembershipsForUser returns channels
 // a user belongs to.
-func (s *Database) GetAllChannelMembershipsForUser(
+func (database *Database) GetAllChannelMembershipsForUser(
 	ctx context.Context,
 	userID int64,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
 		   ON cm.channel_id = c.id
 		 WHERE cm.user_id = ?`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get memberships: %w", err,
+		)
 	}
 
 	return scanChannels(rows)

internal/db/queries_test.go

@@ -12,19 +12,19 @@ import (
 func setupTestDB(t *testing.T) *db.Database {
 	t.Helper()
 
-	d, err := db.NewTestDatabase()
+	database, err := db.NewTestDatabase()
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	t.Cleanup(func() {
-		closeErr := d.Close()
+		closeErr := database.Close()
 		if closeErr != nil {
 			t.Logf("close db: %v", closeErr)
 		}
 	})
 
-	return d
+	return database
 }
 
 func TestCreateUser(t *testing.T) {
@@ -349,12 +349,30 @@ func TestSetTopic(t *testing.T) {
 	}
 }
 
-func insertTestMessage(
-	t *testing.T,
-	database *db.Database,
-) (int64, int64) {
-	t.Helper()
+func TestInsertMessage(t *testing.T) {
+	t.Parallel()
 
+	database := setupTestDB(t)
+	ctx := t.Context()
+
+	body := json.RawMessage(`["hello"]`)
+
+	dbID, msgUUID, err := database.InsertMessage(
+		ctx, "PRIVMSG", "poller", "#test", body, nil,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if dbID == 0 || msgUUID == "" {
+		t.Fatal("expected valid id and uuid")
+	}
+}
+
+func TestPollMessages(t *testing.T) {
+	t.Parallel()
+
+	database := setupTestDB(t)
 	ctx := t.Context()
 
 	uid, _, err := database.CreateUser(ctx, "poller")
@@ -364,11 +382,11 @@ func insertTestMessage(
 
 	body := json.RawMessage(`["hello"]`)
 
-	dbID, msgUUID, err := database.InsertMessage(
+	dbID, _, err := database.InsertMessage(
 		ctx, "PRIVMSG", "poller", "#test", body, nil,
 	)
-	if err != nil || dbID == 0 || msgUUID == "" {
-		t.Fatal("insert failed")
+	if err != nil {
+		t.Fatal(err)
 	}
 
 	err = database.EnqueueMessage(ctx, uid, dbID)
@@ -376,19 +394,10 @@ func insertTestMessage(
 		t.Fatal(err)
 	}
 
-	return uid, dbID
-}
-
-func TestInsertAndPollMessages(t *testing.T) {
-	t.Parallel()
-
-	database := setupTestDB(t)
-	uid, _ := insertTestMessage(t, database)
-
 	const batchSize = 10
 
 	msgs, lastQID, err := database.PollMessages(
-		t.Context(), uid, 0, batchSize,
+		ctx, uid, 0, batchSize,
 	)
 	if err != nil {
 		t.Fatal(err)
@@ -411,7 +420,7 @@ func TestInsertAndPollMessages(t *testing.T) {
 	}
 
 	msgs, _, _ = database.PollMessages(
-		t.Context(), uid, lastQID, batchSize,
+		ctx, uid, lastQID, batchSize,
 	)
 
 	if len(msgs) != 0 {

internal/handlers/handlers.go

@@ -40,40 +40,59 @@ type Handlers struct {
 
 // New creates a new Handlers instance.
 func New(
-	lc fx.Lifecycle,
+	lifecycle fx.Lifecycle,
 	params Params,
 ) (*Handlers, error) {
-	s := new(Handlers)
-	s.params = &params
-	s.log = params.Logger.Get()
-	s.hc = params.Healthcheck
-	s.broker = broker.New()
+	hdlr := &Handlers{
+		params: &params,
+		log:    params.Logger.Get(),
+		hc:     params.Healthcheck,
+		broker: broker.New(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
 			return nil
 		},
+		OnStop: func(_ context.Context) error {
+			return nil
+		},
 	})
 
-	return s, nil
+	return hdlr, nil
 }
 
-func (s *Handlers) respondJSON(
-	w http.ResponseWriter,
+func (hdlr *Handlers) respondJSON(
+	writer http.ResponseWriter,
 	_ *http.Request,
 	data any,
 	status int,
 ) {
-	w.Header().Set(
+	writer.Header().Set(
 		"Content-Type",
 		"application/json; charset=utf-8",
 	)
-	w.WriteHeader(status)
+	writer.WriteHeader(status)
 
 	if data != nil {
-		err := json.NewEncoder(w).Encode(data)
+		err := json.NewEncoder(writer).Encode(data)
 		if err != nil {
-			s.log.Error("json encode error", "error", err)
+			hdlr.log.Error(
+				"json encode error", "error", err,
+			)
 		}
 	}
 }
+
+func (hdlr *Handlers) respondError(
+	writer http.ResponseWriter,
+	request *http.Request,
+	msg string,
+	status int,
+) {
+	hdlr.respondJSON(
+		writer, request,
+		map[string]string{"error": msg},
+		status,
+	)
+}

internal/handlers/healthcheck.go

@@ -7,9 +7,12 @@ import (
 const httpStatusOK = 200
 
 // HandleHealthCheck returns an HTTP handler for the health check endpoint.
-func (s *Handlers) HandleHealthCheck() http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		resp := s.hc.Healthcheck()
-		s.respondJSON(w, req, resp, httpStatusOK)
+func (hdlr *Handlers) HandleHealthCheck() http.HandlerFunc {
+	return func(
+		writer http.ResponseWriter,
+		request *http.Request,
+	) {
+		resp := hdlr.hc.Healthcheck()
+		hdlr.respondJSON(writer, request, resp, httpStatusOK)
 	}
 }

internal/healthcheck/healthcheck.go

@@ -33,14 +33,17 @@ type Healthcheck struct {
 }
 
 // New creates a new Healthcheck instance.
-func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
-	s := new(Healthcheck)
-	s.params = &params
-	s.log = params.Logger.Get()
+func New(
+	lifecycle fx.Lifecycle, params Params,
+) (*Healthcheck, error) {
+	hcheck := &Healthcheck{ //nolint:exhaustruct // StartupTime set in OnStart
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
-			s.StartupTime = time.Now()
+			hcheck.StartupTime = time.Now()
 
 			return nil
 		},
@@ -49,7 +52,7 @@ func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
 		},
 	})
 
-	return s, nil
+	return hcheck, nil
 }
 
 // Response is the JSON response returned by the health endpoint.
@@ -64,19 +67,18 @@ type Response struct {
 }
 
 // Healthcheck returns the current health status of the server.
-func (s *Healthcheck) Healthcheck() *Response {
-	resp := &Response{
+func (hcheck *Healthcheck) Healthcheck() *Response {
+	return &Response{
 		Status:        "ok",
 		Now:           time.Now().UTC().Format(time.RFC3339Nano),
-		UptimeSeconds: int64(s.uptime().Seconds()),
-		UptimeHuman:   s.uptime().String(),
-		Appname:       s.params.Globals.Appname,
-		Version:       s.params.Globals.Version,
+		UptimeSeconds: int64(hcheck.uptime().Seconds()),
+		UptimeHuman:   hcheck.uptime().String(),
+		Appname:       hcheck.params.Globals.Appname,
+		Version:       hcheck.params.Globals.Version,
+		Maintenance:   hcheck.params.Config.MaintenanceMode,
 	}
-
-	return resp
 }
 
-func (s *Healthcheck) uptime() time.Duration {
-	return time.Since(s.StartupTime)
+func (hcheck *Healthcheck) uptime() time.Duration {
+	return time.Since(hcheck.StartupTime)
 }

internal/logger/logger.go

@@ -23,51 +23,56 @@ type Logger struct {
 	params Params
 }
 
-// New creates a new Logger with appropriate handler based on terminal detection.
-func New(_ fx.Lifecycle, params Params) (*Logger, error) {
-	l := new(Logger)
-	l.level = new(slog.LevelVar)
-	l.level.Set(slog.LevelInfo)
+// New creates a new Logger with appropriate handler
+// based on terminal detection.
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Logger, error) {
+	logger := new(Logger)
+	logger.level = new(slog.LevelVar)
+	logger.level.Set(slog.LevelInfo)
 
 	tty := false
+
 	if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
 		tty = true
 	}
 
-	var handler slog.Handler
-	if tty {
-		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level:     l.level,
-			AddSource: true,
-		})
-	} else {
-		handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-			Level:     l.level,
-			AddSource: true,
-		})
+	opts := &slog.HandlerOptions{ //nolint:exhaustruct // ReplaceAttr optional
+		Level:     logger.level,
+		AddSource: true,
 	}
 
-	l.log = slog.New(handler)
-	l.params = params
+	var handler slog.Handler
+	if tty {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	}
 
-	return l, nil
+	logger.log = slog.New(handler)
+	logger.params = params
+
+	return logger, nil
 }
 
 // EnableDebugLogging switches the log level to debug.
-func (l *Logger) EnableDebugLogging() {
-	l.level.Set(slog.LevelDebug)
-	l.log.Debug("debug logging enabled", "debug", true)
+func (logger *Logger) EnableDebugLogging() {
+	logger.level.Set(slog.LevelDebug)
+	logger.log.Debug(
+		"debug logging enabled", "debug", true,
+	)
 }
 
 // Get returns the underlying slog.Logger.
-func (l *Logger) Get() *slog.Logger {
-	return l.log
+func (logger *Logger) Get() *slog.Logger {
+	return logger.log
 }
 
 // Identify logs the application name and version at startup.
-func (l *Logger) Identify() {
-	l.log.Info("starting",
-		"appname", l.params.Globals.Appname,
-		"version", l.params.Globals.Version,
+func (logger *Logger) Identify() {
+	logger.log.Info("starting",
+		"appname", logger.params.Globals.Appname,
+		"version", logger.params.Globals.Version,
 	)
 }

internal/middleware/middleware.go

@@ -11,7 +11,7 @@ import (
 	"git.eeqj.de/sneak/chat/internal/globals"
 	"git.eeqj.de/sneak/chat/internal/logger"
 	basicauth "github.com/99designs/basicauth-go"
-	"github.com/go-chi/chi/middleware"
+	chimw "github.com/go-chi/chi/middleware"
 	"github.com/go-chi/cors"
 	metrics "github.com/slok/go-http-metrics/metrics/prometheus"
 	ghmm "github.com/slok/go-http-metrics/middleware"
@@ -38,25 +38,28 @@ type Middleware struct {
 }
 
 // New creates a new Middleware instance.
-func New(_ fx.Lifecycle, params Params) (*Middleware, error) {
-	s := new(Middleware)
-	s.params = &params
-	s.log = params.Logger.Get()
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Middleware, error) {
+	mware := &Middleware{
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	return s, nil
+	return mware, nil
 }
 
-func ipFromHostPort(hp string) string {
-	h, _, err := net.SplitHostPort(hp)
+func ipFromHostPort(hostPort string) string {
+	host, _, err := net.SplitHostPort(hostPort)
 	if err != nil {
 		return ""
 	}
 
-	if len(h) > 0 && h[0] == '[' {
-		return h[1 : len(h)-1]
+	if len(host) > 0 && host[0] == '[' {
+		return host[1 : len(host)-1]
 	}
 
-	return h
+	return host
 }
 
 type loggingResponseWriter struct {
@@ -65,9 +68,15 @@ type loggingResponseWriter struct {
 	statusCode int
 }
 
-// newLoggingResponseWriter wraps a ResponseWriter to capture the status code.
-func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
-	return &loggingResponseWriter{w, http.StatusOK}
+// newLoggingResponseWriter wraps a ResponseWriter
+// to capture the status code.
+func newLoggingResponseWriter(
+	writer http.ResponseWriter,
+) *loggingResponseWriter {
+	return &loggingResponseWriter{
+		ResponseWriter: writer,
+		statusCode:     http.StatusOK,
+	}
 }
 
 func (lrw *loggingResponseWriter) WriteHeader(code int) {
@@ -76,43 +85,57 @@ func (lrw *loggingResponseWriter) WriteHeader(code int) {
 }
 
 // Logging returns middleware that logs each HTTP request.
-func (s *Middleware) Logging() func(http.Handler) http.Handler {
+func (mware *Middleware) Logging() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			start := time.Now()
-			lrw := newLoggingResponseWriter(w)
-			ctx := r.Context()
+		return http.HandlerFunc(
+			func(
+				writer http.ResponseWriter,
+				request *http.Request,
+			) {
+				start := time.Now()
+				lrw := newLoggingResponseWriter(writer)
+				ctx := request.Context()
 
-			defer func() {
-				latency := time.Since(start)
+				defer func() {
+					latency := time.Since(start)
 
-				reqID, _ := ctx.Value(middleware.RequestIDKey).(string)
+					reqID, _ := ctx.Value(
+						chimw.RequestIDKey,
+					).(string)
 
-				s.log.InfoContext(ctx, "request",
-					"request_start", start,
-					"method", r.Method,
-					"url", r.URL.String(),
-					"useragent", r.UserAgent(),
-					"request_id", reqID,
-					"referer", r.Referer(),
-					"proto", r.Proto,
-					"remoteIP", ipFromHostPort(r.RemoteAddr),
-					"status", lrw.statusCode,
-					"latency_ms", latency.Milliseconds(),
-				)
-			}()
+					mware.log.InfoContext(
+						ctx, "request",
+						"request_start", start,
+						"method", request.Method,
+						"url", request.URL.String(),
+						"useragent", request.UserAgent(),
+						"request_id", reqID,
+						"referer", request.Referer(),
+						"proto", request.Proto,
+						"remoteIP",
+						ipFromHostPort(request.RemoteAddr),
+						"status", lrw.statusCode,
+						"latency_ms",
+						latency.Milliseconds(),
+					)
+				}()
 
-			next.ServeHTTP(lrw, r)
-		})
+				next.ServeHTTP(lrw, request)
+			})
 	}
 }
 
 // CORS returns middleware that handles Cross-Origin Resource Sharing.
-func (s *Middleware) CORS() func(http.Handler) http.Handler {
-	return cors.Handler(cors.Options{
-		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
-		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+func (mware *Middleware) CORS() func(http.Handler) http.Handler {
+	return cors.Handler(cors.Options{ //nolint:exhaustruct // optional fields
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: []string{
+			"GET", "POST", "PUT", "DELETE", "OPTIONS",
+		},
+		AllowedHeaders: []string{
+			"Accept", "Authorization",
+			"Content-Type", "X-CSRF-Token",
+		},
 		ExposedHeaders:   []string{"Link"},
 		AllowCredentials: false,
 		MaxAge:           corsMaxAge,
@@ -120,28 +143,34 @@ func (s *Middleware) CORS() func(http.Handler) http.Handler {
 }
 
 // Auth returns middleware that performs authentication.
-func (s *Middleware) Auth() func(http.Handler) http.Handler {
+func (mware *Middleware) Auth() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			s.log.Info("AUTH: before request")
-			next.ServeHTTP(w, r)
-		})
+		return http.HandlerFunc(
+			func(
+				writer http.ResponseWriter,
+				request *http.Request,
+			) {
+				mware.log.Info("AUTH: before request")
+				next.ServeHTTP(writer, request)
+			})
 	}
 }
 
 // Metrics returns middleware that records HTTP metrics.
-func (s *Middleware) Metrics() func(http.Handler) http.Handler {
-	mdlw := ghmm.New(ghmm.Config{
-		Recorder: metrics.NewRecorder(metrics.Config{}),
+func (mware *Middleware) Metrics() func(http.Handler) http.Handler {
+	metricsMiddleware := ghmm.New(ghmm.Config{ //nolint:exhaustruct // optional fields
+		Recorder: metrics.NewRecorder(
+			metrics.Config{}, //nolint:exhaustruct // defaults
+		),
 	})
 
 	return func(next http.Handler) http.Handler {
-		return std.Handler("", mdlw, next)
+		return std.Handler("", metricsMiddleware, next)
 	}
 }
 
 // MetricsAuth returns middleware that protects metrics with basic auth.
-func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
+func (mware *Middleware) MetricsAuth() func(http.Handler) http.Handler {
 	return basicauth.New(
 		"metrics",
 		map[string][]string{

internal/server/routes.go

@@ -17,67 +17,94 @@ import (
 const routeTimeout = 60 * time.Second
 
 // SetupRoutes configures the HTTP routes and middleware.
-func (s *Server) SetupRoutes() {
-	s.router = chi.NewRouter()
+func (srv *Server) SetupRoutes() {
+	srv.router = chi.NewRouter()
 
-	s.router.Use(middleware.Recoverer)
-	s.router.Use(middleware.RequestID)
-	s.router.Use(s.mw.Logging())
+	srv.router.Use(middleware.Recoverer)
+	srv.router.Use(middleware.RequestID)
+	srv.router.Use(srv.mw.Logging())
 
 	if viper.GetString("METRICS_USERNAME") != "" {
-		s.router.Use(s.mw.Metrics())
+		srv.router.Use(srv.mw.Metrics())
 	}
 
-	s.router.Use(s.mw.CORS())
-	s.router.Use(middleware.Timeout(routeTimeout))
+	srv.router.Use(srv.mw.CORS())
+	srv.router.Use(middleware.Timeout(routeTimeout))
 
-	if s.sentryEnabled {
-		sentryHandler := sentryhttp.New(sentryhttp.Options{
-			Repanic: true,
-		})
-		s.router.Use(sentryHandler.Handle)
+	if srv.sentryEnabled {
+		sentryHandler := sentryhttp.New(
+			sentryhttp.Options{ //nolint:exhaustruct // optional fields
+				Repanic: true,
+			},
+		)
+
+		srv.router.Use(sentryHandler.Handle)
 	}
 
-	// Health check
-	s.router.Get(
+	// Health check.
+	srv.router.Get(
 		"/.well-known/healthcheck.json",
-		s.h.HandleHealthCheck(),
+		srv.handlers.HandleHealthCheck(),
 	)
 
-	// Protected metrics endpoint
+	// Protected metrics endpoint.
 	if viper.GetString("METRICS_USERNAME") != "" {
-		s.router.Group(func(r chi.Router) {
-			r.Use(s.mw.MetricsAuth())
-			r.Get("/metrics",
+		srv.router.Group(func(router chi.Router) {
+			router.Use(srv.mw.MetricsAuth())
+			router.Get("/metrics",
 				http.HandlerFunc(
 					promhttp.Handler().ServeHTTP,
 				))
 		})
 	}
 
-	// API v1
-	s.router.Route("/api/v1", func(r chi.Router) {
-		r.Get("/server", s.h.HandleServerInfo())
-		r.Post("/session", s.h.HandleCreateSession())
-		r.Get("/state", s.h.HandleState())
-		r.Get("/messages", s.h.HandleGetMessages())
-		r.Post("/messages", s.h.HandleSendCommand())
-		r.Get("/history", s.h.HandleGetHistory())
-		r.Get("/channels", s.h.HandleListAllChannels())
-		r.Get(
-			"/channels/{channel}/members",
-			s.h.HandleChannelMembers(),
-		)
-	})
+	// API v1.
+	srv.router.Route(
+		"/api/v1",
+		func(router chi.Router) {
+			router.Get(
+				"/server",
+				srv.handlers.HandleServerInfo(),
+			)
+			router.Post(
+				"/session",
+				srv.handlers.HandleCreateSession(),
+			)
+			router.Get(
+				"/state",
+				srv.handlers.HandleState(),
+			)
+			router.Get(
+				"/messages",
+				srv.handlers.HandleGetMessages(),
+			)
+			router.Post(
+				"/messages",
+				srv.handlers.HandleSendCommand(),
+			)
+			router.Get(
+				"/history",
+				srv.handlers.HandleGetHistory(),
+			)
+			router.Get(
+				"/channels",
+				srv.handlers.HandleListAllChannels(),
+			)
+			router.Get(
+				"/channels/{channel}/members",
+				srv.handlers.HandleChannelMembers(),
+			)
+		},
+	)
 
-	// Serve embedded SPA
-	s.setupSPA()
+	// Serve embedded SPA.
+	srv.setupSPA()
 }
 
-func (s *Server) setupSPA() {
+func (srv *Server) setupSPA() {
 	distFS, err := fs.Sub(web.Dist, "dist")
 	if err != nil {
-		s.log.Error(
+		srv.log.Error(
 			"failed to get web dist filesystem",
 			"error", err,
 		)
@@ -87,38 +114,40 @@ func (s *Server) setupSPA() {
 
 	fileServer := http.FileServer(http.FS(distFS))
 
-	s.router.Get("/*", func(
-		w http.ResponseWriter,
-		r *http.Request,
+	srv.router.Get("/*", func(
+		writer http.ResponseWriter,
+		request *http.Request,
 	) {
 		readFS, ok := distFS.(fs.ReadFileFS)
 		if !ok {
-			fileServer.ServeHTTP(w, r)
+			fileServer.ServeHTTP(writer, request)
 
 			return
 		}
 
-		f, readErr := readFS.ReadFile(r.URL.Path[1:])
-		if readErr != nil || len(f) == 0 {
+		fileData, readErr := readFS.ReadFile(
+			request.URL.Path[1:],
+		)
+		if readErr != nil || len(fileData) == 0 {
 			indexHTML, indexErr := readFS.ReadFile(
 				"index.html",
 			)
 			if indexErr != nil {
-				http.NotFound(w, r)
+				http.NotFound(writer, request)
 
 				return
 			}
 
-			w.Header().Set(
+			writer.Header().Set(
 				"Content-Type",
 				"text/html; charset=utf-8",
 			)
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write(indexHTML)
+			writer.WriteHeader(http.StatusOK)
+			_, _ = writer.Write(indexHTML)
 
 			return
 		}
 
-		fileServer.ServeHTTP(w, r)
+		fileServer.ServeHTTP(writer, request)
 	})
 }

internal/server/server.go

@@ -41,7 +41,8 @@ type Params struct {
 	Handlers   *handlers.Handlers
 }
 
-// Server is the main HTTP server. It manages routing, middleware, and lifecycle.
+// Server is the main HTTP server.
+// It manages routing, middleware, and lifecycle.
 type Server struct {
 	startupTime   time.Time
 	exitCode      int
@@ -53,21 +54,24 @@ type Server struct {
 	router        *chi.Mux
 	params        Params
 	mw            *middleware.Middleware
-	h             *handlers.Handlers
+	handlers      *handlers.Handlers
 }
 
 // New creates a new Server and registers its lifecycle hooks.
-func New(lc fx.Lifecycle, params Params) (*Server, error) {
-	s := new(Server)
-	s.params = params
-	s.mw = params.Middleware
-	s.h = params.Handlers
-	s.log = params.Logger.Get()
+func New(
+	lifecycle fx.Lifecycle, params Params,
+) (*Server, error) {
+	srv := &Server{ //nolint:exhaustruct // fields set during lifecycle
+		params:   params,
+		mw:       params.Middleware,
+		handlers: params.Handlers,
+		log:      params.Logger.Get(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
-			s.startupTime = time.Now()
-			go s.Run() //nolint:contextcheck
+			srv.startupTime = time.Now()
+			go srv.Run() //nolint:contextcheck
 
 			return nil
 		},
@@ -76,122 +80,140 @@ func New(lc fx.Lifecycle, params Params) (*Server, error) {
 		},
 	})
 
-	return s, nil
+	return srv, nil
 }
 
 // Run starts the server configuration, Sentry, and begins serving.
-func (s *Server) Run() {
-	s.configure()
-	s.enableSentry()
-	s.serve()
+func (srv *Server) Run() {
+	srv.configure()
+	srv.enableSentry()
+	srv.serve()
 }
 
 // ServeHTTP delegates to the chi router.
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	s.router.ServeHTTP(w, r)
+func (srv *Server) ServeHTTP(
+	writer http.ResponseWriter,
+	request *http.Request,
+) {
+	srv.router.ServeHTTP(writer, request)
 }
 
 // MaintenanceMode reports whether the server is in maintenance mode.
-func (s *Server) MaintenanceMode() bool {
-	return s.params.Config.MaintenanceMode
+func (srv *Server) MaintenanceMode() bool {
+	return srv.params.Config.MaintenanceMode
 }
 
-func (s *Server) enableSentry() {
-	s.sentryEnabled = false
+func (srv *Server) enableSentry() {
+	srv.sentryEnabled = false
 
-	if s.params.Config.SentryDSN == "" {
+	if srv.params.Config.SentryDSN == "" {
 		return
 	}
 
-	err := sentry.Init(sentry.ClientOptions{
-		Dsn:     s.params.Config.SentryDSN,
-		Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version),
+	err := sentry.Init(sentry.ClientOptions{ //nolint:exhaustruct // only essential fields
+		Dsn: srv.params.Config.SentryDSN,
+		Release: fmt.Sprintf(
+			"%s-%s",
+			srv.params.Globals.Appname,
+			srv.params.Globals.Version,
+		),
 	})
 	if err != nil {
-		s.log.Error("sentry init failure", "error", err)
+		srv.log.Error("sentry init failure", "error", err)
 		os.Exit(1)
 	}
 
-	s.log.Info("sentry error reporting activated")
-	s.sentryEnabled = true
+	srv.log.Info("sentry error reporting activated")
+	srv.sentryEnabled = true
 }
 
-func (s *Server) serve() int {
-	s.ctx, s.cancelFunc = context.WithCancel(context.Background())
+func (srv *Server) serve() int {
+	srv.ctx, srv.cancelFunc = context.WithCancel(
+		context.Background(),
+	)
 
 	go func() {
-		c := make(chan os.Signal, 1)
+		sigCh := make(chan os.Signal, 1)
 
 		signal.Ignore(syscall.SIGPIPE)
-		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-		sig := <-c
-		s.log.Info("signal received", "signal", sig)
+		signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
 
-		if s.cancelFunc != nil {
-			s.cancelFunc()
+		sig := <-sigCh
+
+		srv.log.Info("signal received", "signal", sig)
+
+		if srv.cancelFunc != nil {
+			srv.cancelFunc()
 		}
 	}()
 
-	go s.serveUntilShutdown()
+	go srv.serveUntilShutdown()
 
-	<-s.ctx.Done()
+	<-srv.ctx.Done()
 
-	s.cleanShutdown()
+	srv.cleanShutdown()
 
-	return s.exitCode
+	return srv.exitCode
 }
 
-func (s *Server) cleanupForExit() {
-	s.log.Info("cleaning up")
+func (srv *Server) cleanupForExit() {
+	srv.log.Info("cleaning up")
 }
 
-func (s *Server) cleanShutdown() {
-	s.exitCode = 0
+func (srv *Server) cleanShutdown() {
+	srv.exitCode = 0
 
 	ctxShutdown, shutdownCancel := context.WithTimeout(
 		context.Background(), shutdownTimeout,
 	)
 
-	err := s.httpServer.Shutdown(ctxShutdown)
+	err := srv.httpServer.Shutdown(ctxShutdown)
 	if err != nil {
-		s.log.Error("server clean shutdown failed", "error", err)
+		srv.log.Error(
+			"server clean shutdown failed", "error", err,
+		)
 	}
 
 	if shutdownCancel != nil {
 		shutdownCancel()
 	}
 
-	s.cleanupForExit()
+	srv.cleanupForExit()
 
-	if s.sentryEnabled {
+	if srv.sentryEnabled {
 		sentry.Flush(sentryFlushTime)
 	}
 }
 
-func (s *Server) configure() {
-	// server configuration placeholder
+func (srv *Server) configure() {
+	// Server configuration placeholder.
 }
 
-func (s *Server) serveUntilShutdown() {
-	listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
-	s.httpServer = &http.Server{
+func (srv *Server) serveUntilShutdown() {
+	listenAddr := fmt.Sprintf(
+		":%d", srv.params.Config.Port,
+	)
+
+	srv.httpServer = &http.Server{ //nolint:exhaustruct // optional fields
 		Addr:           listenAddr,
 		ReadTimeout:    httpReadTimeout,
 		WriteTimeout:   httpWriteTimeout,
 		MaxHeaderBytes: maxHeaderBytes,
-		Handler:        s,
+		Handler:        srv,
 	}
 
-	s.SetupRoutes()
+	srv.SetupRoutes()
 
-	s.log.Info("http begin listen", "listenaddr", listenAddr)
+	srv.log.Info(
+		"http begin listen", "listenaddr", listenAddr,
+	)
 
-	err := s.httpServer.ListenAndServe()
+	err := srv.httpServer.ListenAndServe()
 	if err != nil && !errors.Is(err, http.ErrServerClosed) {
-		s.log.Error("listen error", "error", err)
+		srv.log.Error("listen error", "error", err)
 
-		if s.cancelFunc != nil {
-			s.cancelFunc()
+		if srv.cancelFunc != nil {
+			srv.cancelFunc()
 		}
 	}
 }