forked from mtusi2026/mtusi2026lab5
128 lines
3.4 KiB
Go
128 lines
3.4 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"mime"
|
|
"net/http"
|
|
"net/url"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
const maxRequestBytes = 1 << 20
|
|
|
|
var idempotencyKeyPattern = regexp.MustCompile(`^[A-Za-z0-9._:-]{1,128}$`)
|
|
|
|
func readJSON(w http.ResponseWriter, r *http.Request, target any) *apiError {
|
|
mediaType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
|
|
if err != nil || mediaType != "application/json" || (params["charset"] != "" && !strings.EqualFold(params["charset"], "utf-8")) {
|
|
return &apiError{http.StatusUnsupportedMediaType, errorCodeUnsupportedMediaType, "expected application/json"}
|
|
}
|
|
r.Body = http.MaxBytesReader(w, r.Body, maxRequestBytes)
|
|
data, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
var tooLarge *http.MaxBytesError
|
|
if errors.As(err, &tooLarge) {
|
|
return &apiError{http.StatusRequestEntityTooLarge, errorCodePayloadTooLarge, "request body too large"}
|
|
}
|
|
return invalidRequest()
|
|
}
|
|
if !utf8.Valid(data) {
|
|
return invalidRequest()
|
|
}
|
|
var object map[string]json.RawMessage
|
|
if err := json.Unmarshal(data, &object); err != nil || object == nil {
|
|
return invalidRequest()
|
|
}
|
|
normalized, err := json.Marshal(object)
|
|
if err != nil {
|
|
return invalidRequest()
|
|
}
|
|
decoder := json.NewDecoder(bytes.NewReader(normalized))
|
|
decoder.DisallowUnknownFields()
|
|
if err := decoder.Decode(target); err != nil {
|
|
return invalidRequest()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validText(value string, maxRunes int) bool {
|
|
return utf8.ValidString(value) && strings.TrimSpace(value) != "" && utf8.RuneCountInString(value) <= maxRunes
|
|
}
|
|
|
|
func idempotencyKey(r *http.Request) (string, bool) {
|
|
values := r.Header.Values("Idempotency-Key")
|
|
if len(values) != 1 || !idempotencyKeyPattern.MatchString(values[0]) {
|
|
return "", false
|
|
}
|
|
return values[0], true
|
|
}
|
|
|
|
type pageCursor struct {
|
|
Kind string `json:"kind"`
|
|
Resource string `json:"resource"`
|
|
Time time.Time `json:"time"`
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
func pageParams(r *http.Request, kind, resource string) (int, *pageCursor, *apiError) {
|
|
query, err := url.ParseQuery(r.URL.RawQuery)
|
|
if err != nil {
|
|
return 0, nil, invalidRequest()
|
|
}
|
|
for key := range query {
|
|
if key != "limit" && key != "cursor" {
|
|
return 0, nil, invalidRequest()
|
|
}
|
|
if len(query[key]) != 1 {
|
|
return 0, nil, invalidRequest()
|
|
}
|
|
}
|
|
limit := 50
|
|
if value, present := query["limit"]; present {
|
|
parsed, err := strconv.Atoi(value[0])
|
|
if err != nil || parsed < 1 || parsed > 100 {
|
|
return 0, nil, invalidRequest()
|
|
}
|
|
limit = parsed
|
|
}
|
|
if value, present := query["cursor"]; present {
|
|
cursor, valid := decodeCursor(value[0], kind, resource)
|
|
if !valid {
|
|
return 0, nil, invalidRequest()
|
|
}
|
|
return limit, cursor, nil
|
|
}
|
|
return limit, nil, nil
|
|
}
|
|
|
|
func encodeCursor(kind, resource string, createdAt time.Time, id string) string {
|
|
data, _ := json.Marshal(pageCursor{kind, resource, createdAt, id})
|
|
return base64.RawURLEncoding.EncodeToString(data)
|
|
}
|
|
|
|
func decodeCursor(value, kind, resource string) (*pageCursor, bool) {
|
|
data, err := base64.RawURLEncoding.DecodeString(value)
|
|
if err != nil {
|
|
return nil, false
|
|
}
|
|
var cursor pageCursor
|
|
if err := json.Unmarshal(data, &cursor); err != nil || cursor.Kind != kind || cursor.Resource != resource {
|
|
return nil, false
|
|
}
|
|
if cursor.Time.IsZero() {
|
|
return nil, false
|
|
}
|
|
if _, valid := canonicalID(cursor.ID); !valid {
|
|
return nil, false
|
|
}
|
|
return &cursor, true
|
|
}
|