init

internal/httpx/json.go

@@ -0,0 +1,127 @@
+// Package httpx holds the HTTP plumbing shared by both listeners: the JSON
+// error envelope, the middleware chain, and server lifecycle management.
+package httpx
+
+import (
+	"encoding/json"
+	"errors"
+	"log/slog"
+	"net/http"
+
+	"github.com/iceBear67/simplepages/api"
+)
+
+// StatusFor maps a machine-readable code to its HTTP status.
+func StatusFor(code api.Code) int {
+	switch code {
+	case api.CodeBadRequest, api.CodeInvalidProjectName, api.CodeInvalidPath,
+		api.CodeDigestMismatch, api.CodeSizeMismatch:
+		return http.StatusBadRequest
+	case api.CodeUnauthorized:
+		return http.StatusUnauthorized
+	case api.CodeForbidden:
+		return http.StatusForbidden
+	case api.CodeNotFound:
+		return http.StatusNotFound
+	case api.CodeMethodNotAllowed:
+		return http.StatusMethodNotAllowed
+	case api.CodeConflict, api.CodeProjectExists, api.CodeDeploymentNotReady,
+		api.CodeDeploymentActive, api.CodeBlobsMissing:
+		return http.StatusConflict
+	case api.CodePayloadTooLarge, api.CodeLimitExceeded:
+		return http.StatusRequestEntityTooLarge
+	case api.CodeRateLimited:
+		return http.StatusTooManyRequests
+	case api.CodeUnavailable:
+		return http.StatusServiceUnavailable
+	default:
+		return http.StatusInternalServerError
+	}
+}
+
+// WriteJSON writes v as JSON with the given status.
+func WriteJSON(w http.ResponseWriter, status int, v any) {
+	buf, err := json.Marshal(v)
+	if err != nil {
+		// Marshalling our own response types should never fail; if it does the
+		// handler already wrote nothing, so a bare 500 is the honest answer.
+		http.Error(w, `{"error":{"code":"internal","message":"response encoding failed"}}`,
+			http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(status)
+	_, _ = w.Write(buf)
+	_, _ = w.Write([]byte("\n"))
+}
+
+// WriteError renders err as the standard error envelope. Non-api errors become
+// an opaque 500: internal failure text may name paths or SQL and must not reach
+// the client. The full error is logged instead.
+func WriteError(w http.ResponseWriter, r *http.Request, log *slog.Logger, err error) {
+	var apiErr *api.Error
+	if !errors.As(err, &apiErr) {
+		var maxErr *http.MaxBytesError
+		if errors.As(err, &maxErr) {
+			apiErr = api.Errorf(api.CodePayloadTooLarge, "request body exceeds %d bytes", maxErr.Limit)
+		} else {
+			if log != nil {
+				log.ErrorContext(r.Context(), "unhandled error", "err", err,
+					"method", r.Method, "path", r.URL.Path)
+			}
+			apiErr = api.Errorf(api.CodeInternal, "internal error")
+		}
+	}
+	status := StatusFor(apiErr.Code)
+	if status >= 500 && log != nil {
+		log.ErrorContext(r.Context(), "request failed", "err", err,
+			"code", string(apiErr.Code), "method", r.Method, "path", r.URL.Path)
+	}
+	WriteJSON(w, status, api.ErrorEnvelope{Error: *apiErr})
+}
+
+// DecodeJSON reads a JSON body into v, capped at maxBytes. It rejects unknown
+// fields (a misspelled key in a deploy script should fail, not be ignored) and
+// trailing content after the top-level value.
+func DecodeJSON(w http.ResponseWriter, r *http.Request, maxBytes int64, v any) error {
+	r.Body = http.MaxBytesReader(w, r.Body, maxBytes)
+	dec := json.NewDecoder(r.Body)
+	dec.DisallowUnknownFields()
+	if err := dec.Decode(v); err != nil {
+		var maxErr *http.MaxBytesError
+		if errors.As(err, &maxErr) {
+			return api.Errorf(api.CodePayloadTooLarge, "request body exceeds %d bytes", maxErr.Limit)
+		}
+		var syn *json.SyntaxError
+		if errors.As(err, &syn) {
+			return api.Errorf(api.CodeBadRequest, "malformed JSON at byte %d", syn.Offset)
+		}
+		var typeErr *json.UnmarshalTypeError
+		if errors.As(err, &typeErr) {
+			return api.Errorf(api.CodeBadRequest, "field %q: want %s", typeErr.Field, typeErr.Type)
+		}
+		return api.Errorf(api.CodeBadRequest, "%s", err)
+	}
+	if dec.More() {
+		return api.Errorf(api.CodeBadRequest, "unexpected content after JSON value")
+	}
+	return nil
+}
+
+// newInternalEnvelope builds the opaque 500 body. The request id is included so
+// an operator can find the corresponding log line, which holds the real cause.
+func newInternalEnvelope(reqID string) api.ErrorEnvelope {
+	e := api.Errorf(api.CodeInternal, "internal error")
+	if reqID != "" {
+		e = e.WithDetail("request_id", reqID)
+	}
+	return api.ErrorEnvelope{Error: *e}
+}
+
+// NoBody rejects requests that carry a body where none is expected.
+func NoBody(r *http.Request) error {
+	if r.ContentLength > 0 {
+		return api.Errorf(api.CodeBadRequest, "unexpected request body")
+	}
+	return nil
+}