Files
mtusi2026lab2/service/internal/pkg/rest/framework/framework.go
T
2026-11-06 13:58:50 +03:00

249 lines
7.3 KiB
Go

package framework
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"mime"
"net/http"
"strconv"
"strings"
"github.com/go-chi/chi/v5"
v10 "github.com/go-playground/validator/v10"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/dto"
"gitea.privcloud.tech/mtusi2026/internal/gen/contracts"
"gitea.privcloud.tech/mtusi2026/internal/pkg/apperr"
"gitea.privcloud.tech/mtusi2026/internal/pkg/auth/jwtprovider"
"gitea.privcloud.tech/mtusi2026/internal/pkg/rest/headers"
"gitea.privcloud.tech/mtusi2026/internal/pkg/validator"
)
func validate(ctx context.Context, v *validator.ValidatorImpl, value any) error {
err := v.ValidateCtx(ctx, value)
if err == nil {
return nil
}
var fieldErrors v10.ValidationErrors
if errors.As(err, &fieldErrors) {
return apperr.Wrap(err, apperr.CodeValidation, "invalid request fields")
}
return apperr.Wrap(err, apperr.CodeInternal, "validation failed")
}
func Validate(w http.ResponseWriter, r *http.Request, v *validator.ValidatorImpl, value any) bool {
if err := validate(r.Context(), v, value); err != nil {
JSONError(r.Context(), w, err)
return false
}
return true
}
func JSONResponse(w http.ResponseWriter, status int, body any) {
w.Header().Set(headers.HeaderContentType, "application/json")
w.WriteHeader(status)
if status == http.StatusNoContent {
return
}
if err := json.NewEncoder(w).Encode(body); err != nil {
wrapped := apperr.Wrap(err, apperr.CodeInternal, "failed json encode")
slog.Error("response", "error", wrapped)
}
}
func JSONError(ctx context.Context, w http.ResponseWriter, err error) {
if err == nil {
return
}
requestId, ok := ctx.Value(headers.HeaderRequestID).(uuid.UUID)
if !ok {
requestId = uuid.New()
}
w.Header().Set(headers.HeaderRequestID, requestId.String())
if errors.Is(err, context.DeadlineExceeded) {
err = apperr.Wrap(err, apperr.CodeServiceUnavailable, "request deadline exceeded")
}
appErr := apperr.As(err)
if appErr == nil {
appErr = apperr.As(apperr.New(apperr.CodeInternal, "internal server error"))
}
if appErr.Code().HTTPStatus() == http.StatusUnauthorized && w.Header().Get("WWW-Authenticate") == "" {
w.Header().Set("WWW-Authenticate", `Bearer realm="messenger"`)
}
slog.Error("response", "error", err, "status", appErr.Code().HTTPStatus(), "requestId", requestId.String())
var code contracts.ErrorErrorCode
switch appErr.Code() {
case apperr.CodeBadRequest, apperr.CodeValidation:
code = contracts.InvalidRequest
case apperr.CodeUnauthorized:
code = contracts.Unauthorized
case apperr.CodeNotFound:
code = contracts.NotFound
case apperr.CodeAlreadyExists, apperr.CodeConflict:
code = contracts.Conflict
case apperr.CodePayloadTooLarge:
code = contracts.PayloadTooLarge
case apperr.CodeTooManyRequests:
code = contracts.RateLimited
case apperr.CodeServiceUnavailable, apperr.CodeUnavailable:
code = contracts.Unavailable
case apperr.CodeUnsupportedMediaType:
code = contracts.UnsupportedMediaType
default:
code = contracts.InternalError
}
JSONResponse(w, appErr.Code().HTTPStatus(), contracts.Error{
Error: struct {
Code contracts.ErrorErrorCode `json:"code"`
Message string `json:"message"`
RequestId string `json:"request_id"`
}{
Code: code,
Message: appErr.Message(),
RequestId: requestId.String(),
},
})
}
func Decode(w http.ResponseWriter, r *http.Request, object any) bool {
mediaType, params, err := mime.ParseMediaType(r.Header.Get(headers.HeaderContentType))
if err != nil || mediaType != "application/json" ||
(params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) {
JSONError(r.Context(), w, apperr.New(apperr.CodeUnsupportedMediaType, "expected application/json"))
return false
}
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(object); err != nil {
JSONError(r.Context(), w, apperr.Wrap(err, apperr.CodeBadRequest, "failed decode"))
return false
}
var trailing any
if err := decoder.Decode(&trailing); err != io.EOF {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "expected one JSON object"))
return false
}
return true
}
func PathParam(r *http.Request, key string) string {
return chi.URLParam(r, key)
}
func QueryParam(r *http.Request, key string) string {
return r.URL.Query().Get(key)
}
func HeaderParam(r *http.Request, key string) string {
return r.Header.Get(key)
}
func ParseIDFromPathParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := PathParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromQueryParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := QueryParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeValidation, fmt.Sprintf("provided invalid %s", key)))
return uuid.Nil, err
}
return id, nil
}
func ParseIDFromHeaderParam(ctx context.Context, w http.ResponseWriter, r *http.Request, key string) (uuid.UUID, error) {
rawID := HeaderParam(r, key)
id, err := uuid.Parse(rawID)
if err != nil {
JSONError(ctx, w, apperr.New(apperr.CodeUnauthorized, "missing or invalid user ID"))
return uuid.Nil, err
}
return id, nil
}
func Header(r *http.Request, header string) (string, bool) {
return r.Header.Get(header), r.Header.Get(header) != ""
}
func Token(r *http.Request) (string, bool) {
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return "", false
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return "", false
}
return token, true
}
func ParseToken(r *http.Request, provider jwtprovider.Provider) (*dto.UserDataInToken, error) {
foundHeader := r.Header.Get(headers.HeaderAuthorization)
if foundHeader == "" {
return nil, apperr.New(apperr.CodeUnauthorized, "missing authorization header")
}
token, found := strings.CutPrefix(foundHeader, "Bearer ")
if !found {
return nil, apperr.New(apperr.CodeUnauthorized, "invalid authorization header")
}
userData, err := provider.ParseVerified(&dto.Token{Payload: token})
if err != nil {
return nil, apperr.Wrap(err, apperr.CodeUnauthorized, "invalid token")
}
return userData, nil
}
func PageParams(w http.ResponseWriter, r *http.Request) (*int, *uuid.UUID, bool) {
query := r.URL.Query()
var limit *int
if values, exists := query["limit"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
value, err := strconv.Atoi(values[0])
if err != nil || value < 1 || value > 100 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid limit"))
return nil, nil, false
}
limit = &value
}
var afterID *uuid.UUID
if values, exists := query["cursor"]; exists {
if len(values) != 1 {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
id, err := uuid.Parse(values[0])
if err != nil || id == uuid.Nil {
JSONError(r.Context(), w, apperr.New(apperr.CodeBadRequest, "invalid cursor"))
return nil, nil, false
}
afterID = &id
}
return limit, afterID, true
}