package httpapi import ( "errors" "net/http" "time" "github.com/gin-gonic/gin" "git.kmalloc.org/squid/sonda/internal/auth" ) type authHandlers struct{ svc authService } type credentials struct { Email string `json:"email"` Password string `json:"password"` } type userJSON struct { ID int64 `json:"id"` Email string `json:"email"` IsAdmin bool `json:"is_admin"` } func toUserJSON(u auth.User) userJSON { return userJSON{ID: u.ID, Email: u.Email, IsAdmin: u.IsAdmin} } func sessionJSON(s auth.Session) gin.H { return gin.H{ "access_token": s.AccessToken, "access_expires_at": s.AccessExpiresAt.UTC().Format(time.RFC3339), "refresh_token": s.RefreshToken, "refresh_expires_at": s.RefreshExpiresAt.UTC().Format(time.RFC3339), "user": toUserJSON(s.User), } } // bindJSON reads the request body, answering 400 itself on failure. func bindJSON(c *gin.Context, dst any) bool { if err := c.ShouldBindJSON(dst); err != nil { writeError(c, http.StatusBadRequest, "invalid_input", "malformed JSON body") return false } return true } // writeAuthError maps service errors to the standard envelope. func writeAuthError(c *gin.Context, err error) { switch { case errors.Is(err, auth.ErrInvalidInput): writeError(c, http.StatusBadRequest, "invalid_input", err.Error()) case errors.Is(err, auth.ErrRegistrationClosed): writeError(c, http.StatusForbidden, "registration_closed", err.Error()) case errors.Is(err, auth.ErrEmailTaken): writeError(c, http.StatusConflict, "email_taken", err.Error()) case errors.Is(err, auth.ErrUserNotFound): writeError(c, http.StatusNotFound, "user_not_found", err.Error()) case errors.Is(err, auth.ErrLastAdmin): writeError(c, http.StatusConflict, "last_admin", err.Error()) case errors.Is(err, auth.ErrInvalidCredentials): writeError(c, http.StatusUnauthorized, "invalid_credentials", err.Error()) case errors.Is(err, auth.ErrInvalidRefreshToken): writeError(c, http.StatusUnauthorized, "invalid_refresh_token", err.Error()) default: _ = c.Error(err) writeError(c, http.StatusInternalServerError, "internal", "internal error") } } // register creates the first user, who becomes the admin. It is closed once any user exists. func (h *authHandlers) register(c *gin.Context) { var req credentials if !bindJSON(c, &req) { return } user, err := h.svc.Register(c.Request.Context(), req.Email, req.Password) if err != nil { writeAuthError(c, err) return } c.JSON(http.StatusCreated, toUserJSON(user)) } func (h *authHandlers) login(c *gin.Context) { var req credentials if !bindJSON(c, &req) { return } sess, err := h.svc.Login(c.Request.Context(), req.Email, req.Password) if err != nil { writeAuthError(c, err) return } c.JSON(http.StatusOK, sessionJSON(sess)) } type refreshRequest struct { RefreshToken string `json:"refresh_token"` } // refresh swaps a refresh token for a new session; the old token is spent. func (h *authHandlers) refresh(c *gin.Context) { var req refreshRequest if !bindJSON(c, &req) { return } sess, err := h.svc.Refresh(c.Request.Context(), req.RefreshToken) if err != nil { writeAuthError(c, err) return } c.JSON(http.StatusOK, sessionJSON(sess)) } // logout revokes a refresh token. It always answers 204, so it never reveals // whether the token was valid. func (h *authHandlers) logout(c *gin.Context) { var req refreshRequest if !bindJSON(c, &req) { return } if err := h.svc.Logout(c.Request.Context(), req.RefreshToken); err != nil { writeAuthError(c, err) return } c.Status(http.StatusNoContent) } func (h *authHandlers) me(c *gin.Context) { user, err := h.svc.User(c.Request.Context(), currentUserID(c)) if errors.Is(err, auth.ErrUserNotFound) { writeError(c, http.StatusUnauthorized, "unauthorized", "account no longer exists") return } if err != nil { writeAuthError(c, err) return } c.JSON(http.StatusOK, toUserJSON(user)) } type passwordChangeRequest struct { CurrentPassword string `json:"current_password"` NewPassword string `json:"new_password"` } // changePassword needs the current password and signs the user out everywhere. func (h *authHandlers) changePassword(c *gin.Context) { var req passwordChangeRequest if !bindJSON(c, &req) { return } err := h.svc.ChangePassword(c.Request.Context(), currentUserID(c), req.CurrentPassword, req.NewPassword) if errors.Is(err, auth.ErrInvalidCredentials) { // 403, not 401: the token is fine, and 401 would tell clients to refresh it. writeError(c, http.StatusForbidden, "invalid_credentials", "current password is wrong") return } if errors.Is(err, auth.ErrUserNotFound) { writeError(c, http.StatusUnauthorized, "unauthorized", "account no longer exists") return } if err != nil { writeAuthError(c, err) return } c.Status(http.StatusNoContent) }