cleanup some error returns

internal/helpers/helpers.go

···
 	"math/rand"
 	"net/url"
 
+	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/labstack/echo/v4"
 	"github.com/lestrrat-go/jwx/v2/jwk"
 )
···
 		msg += ". " + *suffix
 	}
 	return genericError(e, 400, msg)
+}
+
+func InvalidTokenError(e echo.Context) error {
+	return InputError(e, to.StringPtr("InvalidToken"))
+}
+
+func ExpiredTokenError(e echo.Context) error {
+	// WARN: See https://github.com/bluesky-social/atproto/discussions/3319
+	return e.JSON(400, map[string]string{
+		"error":   "ExpiredToken",
+		"message": "*",
+	})
 }
 
 func genericError(e echo.Context, code int, msg string) error {

server/handle_server_confirm_email.go

···
 	}
 
 	if urepo.EmailVerificationCode == nil || urepo.EmailVerificationCodeExpiresAt == nil {
-		return helpers.InputError(e, to.StringPtr("ExpiredToken"))
+		return helpers.ExpiredTokenError(e)
 	}
 
 	if *urepo.EmailVerificationCode != req.Token {
···
 	}
 
 	if time.Now().UTC().After(*urepo.EmailVerificationCodeExpiresAt) {
-		return helpers.InputError(e, to.StringPtr("ExpiredToken"))
+		return helpers.ExpiredTokenError(e)
 	}
 
 	now := time.Now().UTC()

server/handle_server_reset_password.go

···
 	}
 
 	if *urepo.PasswordResetCode != req.Token {
-		return helpers.InputError(e, to.StringPtr("InvalidToken"))
+		return helpers.InvalidTokenError(e)
 	}
 
 	if time.Now().UTC().After(*urepo.PasswordResetCodeExpiresAt) {
-		return helpers.InputError(e, to.StringPtr("ExpiredToken"))
+		return helpers.ExpiredTokenError(e)
 	}
 
 	hash, err := bcrypt.GenerateFromPassword([]byte(req.Password), 10)

server/handle_server_update_email.go

···
 import (
 	"time"
 
-	"github.com/Azure/go-autorest/autorest/to"
 	"github.com/haileyok/cocoon/internal/helpers"
 	"github.com/haileyok/cocoon/models"
 	"github.com/labstack/echo/v4"
···
 	}
 
 	if urepo.EmailUpdateCode == nil || urepo.EmailUpdateCodeExpiresAt == nil {
-		return helpers.InputError(e, to.StringPtr("InvalidToken"))
+		return helpers.InvalidTokenError(e)
 	}
 
 	if *urepo.EmailUpdateCode != req.Token {
-		return helpers.InputError(e, to.StringPtr("InvalidToken"))
+		return helpers.InvalidTokenError(e)
 	}
 
 	if time.Now().UTC().After(*urepo.EmailUpdateCodeExpiresAt) {
-		return helpers.InputError(e, to.StringPtr("ExpiredToken"))
+		return helpers.ExpiredTokenError(e)
 	}
 
 	if err := s.db.Exec("UPDATE repos SET email_update_code = NULL, email_update_code_expires_at = NULL, email_confirmed_at = NULL,  email = ? WHERE did = ?", nil, req.Email, urepo.Repo.Did).Error; err != nil {

server/middleware.go

···
 		token, _, err := new(jwt.Parser).ParseUnverified(tokenstr, jwt.MapClaims{})
 		claims, ok := token.Claims.(jwt.MapClaims)
 		if !ok {
-			return helpers.InputError(e, to.StringPtr("InvalidToken"))
+			return helpers.InvalidTokenError(e)
 		}
 
 		var did string
···
 			})
 			if err != nil {
 				s.logger.Error("error parsing jwt", "error", err)
-				// NOTE: https://github.com/bluesky-social/atproto/discussions/3319
-				return e.JSON(400, map[string]string{"error": "ExpiredToken", "message": "token has expired"})
+				return helpers.ExpiredTokenError(e)
 			}
 
 			if !token.Valid {
-				return helpers.InputError(e, to.StringPtr("InvalidToken"))
+				return helpers.InvalidTokenError(e)
 			}
 		} else {
 			kpts := strings.Split(tokenstr, ".")
···
 		scope, _ := claims["scope"].(string)
 
 		if isRefresh && scope != "com.atproto.refresh" {
-			return helpers.InputError(e, to.StringPtr("InvalidToken"))
+			return helpers.InvalidTokenError(e)
 		} else if !hasLxm && !isRefresh && scope != "com.atproto.access" {
-			return helpers.InputError(e, to.StringPtr("InvalidToken"))
+			return helpers.InvalidTokenError(e)
 		}
 
 		table := "tokens"
···
 			var result Result
 			if err := s.db.Raw("SELECT EXISTS(SELECT 1 FROM "+table+" WHERE token = ?) AS found", nil, tokenstr).Scan(&result).Error; err != nil {
 				if err == gorm.ErrRecordNotFound {
-					return helpers.InputError(e, to.StringPtr("InvalidToken"))
+					return helpers.InvalidTokenError(e)
 				}
 
 				s.logger.Error("error getting token from db", "error", err)
···
 			}
 
 			if !result.Found {
-				return helpers.InputError(e, to.StringPtr("InvalidToken"))
+				return helpers.InvalidTokenError(e)
 			}
 		}
 
···
 		}
 
 		if exp < float64(time.Now().UTC().Unix()) {
-			return helpers.InputError(e, to.StringPtr("ExpiredToken"))
+			return helpers.ExpiredTokenError(e)
 		}
 
 		if repo == nil {
···
 		e.Set("token", tokenstr)
 
 		if err := next(e); err != nil {
-			e.Error(err)
+			return helpers.InvalidTokenError(e)
 		}
 
 		return nil
···
 		}
 
 		if oauthToken.Token == "" {
-			return helpers.InputError(e, to.StringPtr("InvalidToken"))
+			return helpers.InvalidTokenError(e)
 		}
 
 		if *oauthToken.Parameters.DpopJkt != proof.JKT {
···
 		}
 
 		if time.Now().After(oauthToken.ExpiresAt) {
-			return e.JSON(400, map[string]string{"error": "ExpiredToken", "message": "token has expired"})
+			return helpers.ExpiredTokenError(e)
 		}
 
 		repo, err := s.getRepoActorByDid(oauthToken.Sub)