fix: resolve typecheck errors by removing duplicate db methods and updating handlers to use models-based API

internal/handlers/api.go

@@ -1,7 +1,9 @@
 package handlers
 
 import (
+	"crypto/rand"
 	"database/sql"
+	"encoding/hex"
 	"encoding/json"
 	"net/http"
 	"strconv"
@@ -12,77 +14,114 @@ import (
 )
 
 // authUser extracts the user from the Authorization header (Bearer token).
-func (s *Handlers) authUser(r *http.Request) (int64, string, error) {
+func (s *Handlers) authUser(r *http.Request) (string, string, error) {
 	auth := r.Header.Get("Authorization")
 	if !strings.HasPrefix(auth, "Bearer ") {
-		return 0, "", sql.ErrNoRows
+		return "", "", sql.ErrNoRows
 	}
+
 	token := strings.TrimPrefix(auth, "Bearer ")
-	return s.params.Database.GetUserByToken(r.Context(), token)
+
+	u, err := s.params.Database.GetUserByToken(r.Context(), token)
+	if err != nil {
+		return "", "", err
+	}
+
+	return u.ID, u.Nick, nil
 }
 
-func (s *Handlers) requireAuth(w http.ResponseWriter, r *http.Request) (int64, string, bool) {
+func (s *Handlers) requireAuth(w http.ResponseWriter, r *http.Request) (string, string, bool) {
 	uid, nick, err := s.authUser(r)
 	if err != nil {
 		s.respondJSON(w, r, map[string]string{"error": "unauthorized"}, http.StatusUnauthorized)
-		return 0, "", false
+		return "", "", false
 	}
+
 	return uid, nick, true
 }
 
+func generateID() string {
+	b := make([]byte, 16)
+	_, _ = rand.Read(b)
+
+	return hex.EncodeToString(b)
+}
+
 // HandleCreateSession creates a new user session and returns the auth token.
 func (s *Handlers) HandleCreateSession() http.HandlerFunc {
 	type request struct {
 		Nick string `json:"nick"`
 	}
 	type response struct {
-		ID    int64  `json:"id"`
+		ID    string `json:"id"`
 		Nick  string `json:"nick"`
 		Token string `json:"token"`
 	}
+
 	return func(w http.ResponseWriter, r *http.Request) {
 		var req request
 		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 			s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
 			return
 		}
+
 		req.Nick = strings.TrimSpace(req.Nick)
 		if req.Nick == "" || len(req.Nick) > 32 {
 			s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
 			return
 		}
-		id, token, err := s.params.Database.CreateUser(r.Context(), req.Nick)
+
+		id := generateID()
+
+		u, err := s.params.Database.CreateUser(r.Context(), id, req.Nick, "")
 		if err != nil {
 			if strings.Contains(err.Error(), "UNIQUE") {
 				s.respondJSON(w, r, map[string]string{"error": "nick already taken"}, http.StatusConflict)
 				return
 			}
+
 			s.log.Error("create user failed", "error", err)
 			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 			return
 		}
-		s.respondJSON(w, r, &response{ID: id, Nick: req.Nick, Token: token}, http.StatusCreated)
+
+		tokenStr := generateID()
+
+		_, err = s.params.Database.CreateAuthToken(r.Context(), tokenStr, u.ID)
+		if err != nil {
+			s.log.Error("create auth token failed", "error", err)
+			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+			return
+		}
+
+		s.respondJSON(w, r, &response{ID: u.ID, Nick: req.Nick, Token: tokenStr}, http.StatusCreated)
 	}
 }
 
 // HandleState returns the current user's info and joined channels.
 func (s *Handlers) HandleState() http.HandlerFunc {
 	type response struct {
-		ID       int64            `json:"id"`
+		ID       string           `json:"id"`
 		Nick     string           `json:"nick"`
 		Channels []db.ChannelInfo `json:"channels"`
 	}
+
 	return func(w http.ResponseWriter, r *http.Request) {
 		uid, nick, ok := s.requireAuth(w, r)
 		if !ok {
 			return
 		}
+
 		channels, err := s.params.Database.ListChannels(r.Context(), uid)
 		if err != nil {
 			s.log.Error("list channels failed", "error", err)
 			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 			return
 		}
+
 		s.respondJSON(w, r, &response{ID: uid, Nick: nick, Channels: channels}, http.StatusOK)
 	}
 }
@@ -94,12 +133,15 @@ func (s *Handlers) HandleListAllChannels() http.HandlerFunc {
 		if !ok {
 			return
 		}
+
 		channels, err := s.params.Database.ListAllChannels(r.Context())
 		if err != nil {
 			s.log.Error("list all channels failed", "error", err)
 			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 			return
 		}
+
 		s.respondJSON(w, r, channels, http.StatusOK)
 	}
 }
@@ -111,20 +153,26 @@ func (s *Handlers) HandleChannelMembers() http.HandlerFunc {
 		if !ok {
 			return
 		}
+
 		name := "#" + chi.URLParam(r, "channel")
-		var chID int64
+
+		var chID string
+
 		err := s.params.Database.GetDB().QueryRowContext(r.Context(),
 			"SELECT id FROM channels WHERE name = ?", name).Scan(&chID)
 		if err != nil {
 			s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
 			return
 		}
+
 		members, err := s.params.Database.ChannelMembers(r.Context(), chID)
 		if err != nil {
 			s.log.Error("channel members failed", "error", err)
 			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 			return
 		}
+
 		s.respondJSON(w, r, members, http.StatusOK)
 	}
 }
@@ -137,14 +185,18 @@ func (s *Handlers) HandleGetMessages() http.HandlerFunc {
 		if !ok {
 			return
 		}
-		afterID, _ := strconv.ParseInt(r.URL.Query().Get("after"), 10, 64)
+
+		afterTS := r.URL.Query().Get("after")
 		limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
-		msgs, err := s.params.Database.PollMessages(r.Context(), uid, afterID, limit)
+
+		msgs, err := s.params.Database.PollMessages(r.Context(), uid, afterTS, limit)
 		if err != nil {
 			s.log.Error("get messages failed", "error", err)
 			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 			return
 		}
+
 		s.respondJSON(w, r, msgs, http.StatusOK)
 	}
 }
@@ -158,16 +210,19 @@ func (s *Handlers) HandleSendCommand() http.HandlerFunc {
 		Params  []string    `json:"params,omitempty"`
 		Body    interface{} `json:"body,omitempty"`
 	}
+
 	return func(w http.ResponseWriter, r *http.Request) {
 		uid, nick, ok := s.requireAuth(w, r)
 		if !ok {
 			return
 		}
+
 		var req request
 		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 			s.respondJSON(w, r, map[string]string{"error": "invalid request"}, http.StatusBadRequest)
 			return
 		}
+
 		req.Command = strings.ToUpper(strings.TrimSpace(req.Command))
 		req.To = strings.TrimSpace(req.To)
 
@@ -176,11 +231,13 @@ func (s *Handlers) HandleSendCommand() http.HandlerFunc {
 			switch v := req.Body.(type) {
 			case []interface{}:
 				lines := make([]string, 0, len(v))
+
 				for _, item := range v {
-					if s, ok := item.(string); ok {
-						lines = append(lines, s)
+					if str, ok := item.(string); ok {
+						lines = append(lines, str)
 					}
 				}
+
 				return lines
 			case []string:
 				return v
@@ -191,137 +248,19 @@ func (s *Handlers) HandleSendCommand() http.HandlerFunc {
 
 		switch req.Command {
 		case "PRIVMSG", "NOTICE":
-			if req.To == "" {
-				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
-				return
-			}
-			lines := bodyLines()
-			if len(lines) == 0 {
-				s.respondJSON(w, r, map[string]string{"error": "body required"}, http.StatusBadRequest)
-				return
-			}
-			content := strings.Join(lines, "\n")
-
-			if strings.HasPrefix(req.To, "#") {
-				// Channel message
-				var chID int64
-				err := s.params.Database.GetDB().QueryRowContext(r.Context(),
-					"SELECT id FROM channels WHERE name = ?", req.To).Scan(&chID)
-				if err != nil {
-					s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
-					return
-				}
-				msgID, err := s.params.Database.SendMessage(r.Context(), chID, uid, content)
-				if err != nil {
-					s.log.Error("send message failed", "error", err)
-					s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-					return
-				}
-				s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
-			} else {
-				// DM
-				targetID, err := s.params.Database.GetUserByNick(r.Context(), req.To)
-				if err != nil {
-					s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
-					return
-				}
-				msgID, err := s.params.Database.SendDM(r.Context(), uid, targetID, content)
-				if err != nil {
-					s.log.Error("send dm failed", "error", err)
-					s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-					return
-				}
-				s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
-			}
+			s.handlePrivmsg(w, r, uid, nick, req.To, bodyLines())
 
 		case "JOIN":
-			if req.To == "" {
-				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
-				return
-			}
-			channel := req.To
-			if !strings.HasPrefix(channel, "#") {
-				channel = "#" + channel
-			}
-			chID, err := s.params.Database.GetOrCreateChannel(r.Context(), channel)
-			if err != nil {
-				s.log.Error("get/create channel failed", "error", err)
-				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-				return
-			}
-			if err := s.params.Database.JoinChannel(r.Context(), chID, uid); err != nil {
-				s.log.Error("join channel failed", "error", err)
-				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-				return
-			}
-			s.respondJSON(w, r, map[string]string{"status": "joined", "channel": channel}, http.StatusOK)
+			s.handleJoin(w, r, uid, req.To)
 
 		case "PART":
-			if req.To == "" {
-				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
-				return
-			}
-			channel := req.To
-			if !strings.HasPrefix(channel, "#") {
-				channel = "#" + channel
-			}
-			var chID int64
-			err := s.params.Database.GetDB().QueryRowContext(r.Context(),
-				"SELECT id FROM channels WHERE name = ?", channel).Scan(&chID)
-			if err != nil {
-				s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
-				return
-			}
-			if err := s.params.Database.PartChannel(r.Context(), chID, uid); err != nil {
-				s.log.Error("part channel failed", "error", err)
-				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-				return
-			}
-			s.respondJSON(w, r, map[string]string{"status": "parted", "channel": channel}, http.StatusOK)
+			s.handlePart(w, r, uid, req.To)
 
 		case "NICK":
-			lines := bodyLines()
-			if len(lines) == 0 {
-				s.respondJSON(w, r, map[string]string{"error": "body required (new nick)"}, http.StatusBadRequest)
-				return
-			}
-			newNick := strings.TrimSpace(lines[0])
-			if newNick == "" || len(newNick) > 32 {
-				s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
-				return
-			}
-			if err := s.params.Database.ChangeNick(r.Context(), uid, newNick); err != nil {
-				if strings.Contains(err.Error(), "UNIQUE") {
-					s.respondJSON(w, r, map[string]string{"error": "nick already in use"}, http.StatusConflict)
-					return
-				}
-				s.log.Error("change nick failed", "error", err)
-				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-				return
-			}
-			s.respondJSON(w, r, map[string]string{"status": "ok", "nick": newNick}, http.StatusOK)
+			s.handleNick(w, r, uid, bodyLines())
 
 		case "TOPIC":
-			if req.To == "" {
-				s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
-				return
-			}
-			lines := bodyLines()
-			if len(lines) == 0 {
-				s.respondJSON(w, r, map[string]string{"error": "body required (topic text)"}, http.StatusBadRequest)
-				return
-			}
-			topic := strings.Join(lines, " ")
-			channel := req.To
-			if !strings.HasPrefix(channel, "#") {
-				channel = "#" + channel
-			}
-			if err := s.params.Database.SetTopic(r.Context(), channel, uid, topic); err != nil {
-				s.log.Error("set topic failed", "error", err)
-				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
-				return
-			}
-			s.respondJSON(w, r, map[string]string{"status": "ok", "topic": topic}, http.StatusOK)
+			s.handleTopic(w, r, uid, req.To, bodyLines())
 
 		case "PING":
 			s.respondJSON(w, r, map[string]string{"command": "PONG", "from": s.params.Config.ServerName}, http.StatusOK)
@@ -333,6 +272,173 @@ func (s *Handlers) HandleSendCommand() http.HandlerFunc {
 	}
 }
 
+func (s *Handlers) handlePrivmsg(w http.ResponseWriter, r *http.Request, uid, nick, to string, lines []string) {
+	if to == "" {
+		s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
+		return
+	}
+
+	if len(lines) == 0 {
+		s.respondJSON(w, r, map[string]string{"error": "body required"}, http.StatusBadRequest)
+		return
+	}
+
+	content := strings.Join(lines, "\n")
+
+	if strings.HasPrefix(to, "#") {
+		// Channel message.
+		var chID string
+
+		err := s.params.Database.GetDB().QueryRowContext(r.Context(),
+			"SELECT id FROM channels WHERE name = ?", to).Scan(&chID)
+		if err != nil {
+			s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
+			return
+		}
+
+		msgID, err := s.params.Database.SendMessage(r.Context(), chID, uid, nick, content)
+		if err != nil {
+			s.log.Error("send message failed", "error", err)
+			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+			return
+		}
+
+		s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
+	} else {
+		// DM.
+		targetUser, err := s.params.Database.GetUserByNick(r.Context(), to)
+		if err != nil {
+			s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
+			return
+		}
+
+		msgID, err := s.params.Database.SendDM(r.Context(), uid, nick, targetUser.ID, content)
+		if err != nil {
+			s.log.Error("send dm failed", "error", err)
+			s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+			return
+		}
+
+		s.respondJSON(w, r, map[string]any{"id": msgID, "status": "sent"}, http.StatusCreated)
+	}
+}
+
+func (s *Handlers) handleJoin(w http.ResponseWriter, r *http.Request, uid, to string) {
+	if to == "" {
+		s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
+		return
+	}
+
+	channel := to
+	if !strings.HasPrefix(channel, "#") {
+		channel = "#" + channel
+	}
+
+	chID, err := s.params.Database.GetOrCreateChannel(r.Context(), channel)
+	if err != nil {
+		s.log.Error("get/create channel failed", "error", err)
+		s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+		return
+	}
+
+	if err := s.params.Database.JoinChannel(r.Context(), chID, uid); err != nil {
+		s.log.Error("join channel failed", "error", err)
+		s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+		return
+	}
+
+	s.respondJSON(w, r, map[string]string{"status": "joined", "channel": channel}, http.StatusOK)
+}
+
+func (s *Handlers) handlePart(w http.ResponseWriter, r *http.Request, uid, to string) {
+	if to == "" {
+		s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
+		return
+	}
+
+	channel := to
+	if !strings.HasPrefix(channel, "#") {
+		channel = "#" + channel
+	}
+
+	var chID string
+
+	err := s.params.Database.GetDB().QueryRowContext(r.Context(),
+		"SELECT id FROM channels WHERE name = ?", channel).Scan(&chID)
+	if err != nil {
+		s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
+		return
+	}
+
+	if err := s.params.Database.PartChannel(r.Context(), chID, uid); err != nil {
+		s.log.Error("part channel failed", "error", err)
+		s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+		return
+	}
+
+	s.respondJSON(w, r, map[string]string{"status": "parted", "channel": channel}, http.StatusOK)
+}
+
+func (s *Handlers) handleNick(w http.ResponseWriter, r *http.Request, uid string, lines []string) {
+	if len(lines) == 0 {
+		s.respondJSON(w, r, map[string]string{"error": "body required (new nick)"}, http.StatusBadRequest)
+		return
+	}
+
+	newNick := strings.TrimSpace(lines[0])
+	if newNick == "" || len(newNick) > 32 {
+		s.respondJSON(w, r, map[string]string{"error": "nick must be 1-32 characters"}, http.StatusBadRequest)
+		return
+	}
+
+	if err := s.params.Database.ChangeNick(r.Context(), uid, newNick); err != nil {
+		if strings.Contains(err.Error(), "UNIQUE") {
+			s.respondJSON(w, r, map[string]string{"error": "nick already in use"}, http.StatusConflict)
+			return
+		}
+
+		s.log.Error("change nick failed", "error", err)
+		s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+		return
+	}
+
+	s.respondJSON(w, r, map[string]string{"status": "ok", "nick": newNick}, http.StatusOK)
+}
+
+func (s *Handlers) handleTopic(w http.ResponseWriter, r *http.Request, uid, to string, lines []string) {
+	if to == "" {
+		s.respondJSON(w, r, map[string]string{"error": "to field required"}, http.StatusBadRequest)
+		return
+	}
+
+	if len(lines) == 0 {
+		s.respondJSON(w, r, map[string]string{"error": "body required (topic text)"}, http.StatusBadRequest)
+		return
+	}
+
+	topic := strings.Join(lines, " ")
+
+	channel := to
+	if !strings.HasPrefix(channel, "#") {
+		channel = "#" + channel
+	}
+
+	if err := s.params.Database.SetTopic(r.Context(), channel, uid, topic); err != nil {
+		s.log.Error("set topic failed", "error", err)
+		s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
+		return
+	}
+
+	s.respondJSON(w, r, map[string]string{"status": "ok", "topic": topic}, http.StatusOK)
+}
+
 // HandleGetHistory returns message history for a specific target (channel or DM).
 func (s *Handlers) HandleGetHistory() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
@@ -340,46 +446,56 @@ func (s *Handlers) HandleGetHistory() http.HandlerFunc {
 		if !ok {
 			return
 		}
+
 		target := r.URL.Query().Get("target")
 		if target == "" {
 			s.respondJSON(w, r, map[string]string{"error": "target required"}, http.StatusBadRequest)
 			return
 		}
-		beforeID, _ := strconv.ParseInt(r.URL.Query().Get("before"), 10, 64)
+
+		beforeTS := r.URL.Query().Get("before")
 		limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
+
 		if limit <= 0 {
 			limit = 50
 		}
 
 		if strings.HasPrefix(target, "#") {
-			// Channel history
-			var chID int64
+			// Channel history — look up channel by name to get its ID for target matching.
+			var chID string
+
 			err := s.params.Database.GetDB().QueryRowContext(r.Context(),
 				"SELECT id FROM channels WHERE name = ?", target).Scan(&chID)
 			if err != nil {
 				s.respondJSON(w, r, map[string]string{"error": "channel not found"}, http.StatusNotFound)
 				return
 			}
-			msgs, err := s.params.Database.GetMessagesBefore(r.Context(), chID, beforeID, limit)
+
+			msgs, err := s.params.Database.GetMessagesBefore(r.Context(), chID, beforeTS, limit)
 			if err != nil {
 				s.log.Error("get history failed", "error", err)
 				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 				return
 			}
+
 			s.respondJSON(w, r, msgs, http.StatusOK)
 		} else {
-			// DM history
-			targetID, err := s.params.Database.GetUserByNick(r.Context(), target)
+			// DM history.
+			targetUser, err := s.params.Database.GetUserByNick(r.Context(), target)
 			if err != nil {
 				s.respondJSON(w, r, map[string]string{"error": "user not found"}, http.StatusNotFound)
 				return
 			}
-			msgs, err := s.params.Database.GetDMsBefore(r.Context(), uid, targetID, beforeID, limit)
+
+			msgs, err := s.params.Database.GetDMsBefore(r.Context(), uid, targetUser.ID, beforeTS, limit)
 			if err != nil {
 				s.log.Error("get dm history failed", "error", err)
 				s.respondJSON(w, r, map[string]string{"error": "internal error"}, http.StatusInternalServerError)
+
 				return
 			}
+
 			s.respondJSON(w, r, msgs, http.StatusOK)
 		}
 	}
@@ -391,6 +507,7 @@ func (s *Handlers) HandleServerInfo() http.HandlerFunc {
 		Name string `json:"name"`
 		MOTD string `json:"motd"`
 	}
+
 	return func(w http.ResponseWriter, r *http.Request) {
 		s.respondJSON(w, r, &response{
 			Name: s.params.Config.ServerName,