httpm

package main

import (
	"log"
	"net/http"

	"github.com/moxar/middleman/httpm"
)

func main() {

	var encode httpm.Encoder // json.Marshal

	NewRequest := func(path, url string, input interface{}) (*http.Request, error) {
		return httpm.ComposeRequest(
			httpm.NewRequest(path, url),
			httpm.WriteRequestBody(encode)(input),
		)(nil)
	}

	type Hero struct {
		Name     string
		Universe string
	}

	// Compose request.
	batman := Hero{Name: "Batman", Universe: "DC"}
	r, err := NewRequest("POST", "https://api.superheroes.com/heroes", batman)
	if err != nil {
		log.Println(err)
	}

	// use r
	_ = r
}

Output:

package main

import (
	"net/http"

	"github.com/moxar/middleman/httpm"
)

func main() {

	var parseParams httpm.ParamParser // gorilla/schema.NewDecoder().Decode
	var check httpm.Checker           // asaskevich/govalidator.ValidateStruct
	var decode httpm.Decoder          // json.Unmarshal

	// parseRequest parses the request params (?foo=bar) and body.
	parseRequest := func(r *http.Request, body, params interface{}) error {
		_, err := httpm.ComposeRequest(
			httpm.ReadRequestBody(httpm.DecodeAndCheck(decode, check))(body),
			httpm.ReadRequestParams(parseParams)(params),
		)(r)
		return err
	}

	type Hero struct {
		Name     string
		Universe string
	}

	type Params struct {
		FastInsert bool
	}

	// HTTP Handler...
	handle := func(w http.ResponseWriter, r *http.Request) {
		var hero Hero
		var params Params
		if err := parseRequest(r, &hero, &params); err != nil {
			// ...
		}

		// use hero and params values
	}

	_ = handle
}

Output:

package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"strings"

	"github.com/moxar/middleman/httpm"
)

func main() {

	FailOver400 := func(s int) error {
		if s <= 400 {
			return nil
		}
		return errors.New(http.StatusText(s))
	}

	// Compose response.
	ParseResponse := func(r *http.Response, status *int, payload *string) error {

		_, err := httpm.ComposeResponse(
			httpm.ReadResponseStatus(status),
			httpm.ReturnErrorFromResponseStatus(FailOver400),
			httpm.ReadResponseBody(httpm.DecodeText)(payload),
		)(r)
		return err
	}

	r := &http.Response{
		Body:       ioutil.NopCloser(strings.NewReader(`some payload`)),
		StatusCode: 305,
	}

	var out string
	var status int
	err := ParseResponse(r, &status, &out)
	if err != nil {
		log.Println(err)
	}

	fmt.Println(out)
	fmt.Println(status)

	// use r
	_ = r

}

Output:

some payload
305

package main

import (
	"net/http"

	"github.com/moxar/middleman/httpm"
)

func main() {
	writeResponse := func(w http.ResponseWriter, payload interface{}, status int) {
		httpm.ComposeResponseWriter(
			httpm.WriteResponseWriterStatus(status),
			httpm.WriteResponseWriterBody(httpm.EncodeText)(payload),
		)(w)
	}

	var w http.ResponseWriter
	writeResponse(w, "some payload", http.StatusNoContent)

}

Output: