Function toHandleFunc

cmd/server/main.go:900–945

(fn func(context.Context, *Q) (*S, error))

}

func toHandleFunc[Q any, S any](fn func(context.Context, *Q) (*S, error)) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		log.Println(r.URL.Path)
		if r.Method != http.MethodPost {
			handleError(w, httperr.MethodNotAllowed("request to %q had invalid method", r.URL.Path))
			return
		}

		ctx := context.WithValue(r.Context(), authContextKey{}, r.Header.Get("Authorization"))

		var req Q
		var reqA any = req
		reqI, ok := reqA.(requester)
		if ok {
			// Implements custom request parsing, do that.
			if err := reqI.parseRequest(r); err != nil {
				handleError(w, httperr.BadRequest("failed to parse custom request: %w", err))
				return
			}
		} else {
			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
				handleError(w, httperr.BadRequest("failed to decode request as JSON: %w", err))
				return
			}
		}

		resp, err := fn(ctx, &req)
		if err != nil {
			handleError(w, err)
			return
		}
		log.Println(r.URL.Path, "success")

		// If the type implements a custom responder, we should use that.
		var respA any = resp
		respI, ok := respA.(responder)
		if ok {
			respI.respond(w, r)
			return
		}

		if err := json.NewEncoder(w).Encode(resp); err != nil {
			log.Printf("failed to encode response: %v", err)
		}
	}
}

type requester interface {
	parseRequest(r *http.Request) error