Parse req.body in POST request

I am using fetch API to send two values to my POST request handler...

fetch('http://localhost:8080/validation', {
		method:'POST',
		headers: {
			'Accept': 'application/json',
			'Content-Type': 'application/json'
		},
		body: JSON.stringify({
			email:this.state.email,
			password:this.state.password
		})

I want to save both email and password as strings on the server side. Here is my attempt...

type credentials struct {
    Test string
}

func Validate(rw http.ResponseWriter, req *http.Request, _ httprouter.Params) {
   
    decoder := json.NewDecoder(req.Body)

    var creds credentials

    err := decoder.Decode(&creds)

    if err != nil {
	    panic(err)
    }

    fmt.Println(creds.Test)
}

The problem is I do not know how exactly the format of the structure being sent to the POST. I am attempting to save req.Body as a string but this yields nothing.

When I print fmt.Println I get a blank space. What is the proper way of parsing it?

Try with

type credentials struct {
    Email string `json:"email"`
    Password string `json:"password"`
}

You are receiving a JSON with two values. Receiving struct should have a structure matching your request. Otherwise, there are no placeholders to decode the JSON into, as in your case - email and password do not have matching struct fields. Btw. if you send "Test" in your JSON, this would work, as you have a Test field in your struct!

Regarding field names. If fields in JSON do not start with a capital letter or even have different names, then you should use so called tags.
More on tags: https://golang.org/pkg/encoding/json/#Marshal

In my example I used them to match struct field names to your json fields, i.e. to make email from json match Email field of the credentials struct.

req.Body is an io.Reader, and you can get use ioutil.ReadAll to drain it:

data, err := ioutil.ReadAll(req.Body)
asString := string(data) // you can convert to a string with a typecast

But I'm not sure if that's what you meant by trying to save req.Body as a string.

To parse the response into a data structure, you can unmarshal it into a variable of type *interface{}:

var creds interface{}
decoder.Decode(&creds)

And then examine the value:

fmt.Printf("%#v\n", creds)

Or perhaps using pp.Println(creds) which I find easier to read.

The creds variable will represent the JSON object found in the body, for your example input this will be a map[string]interface{} with two entries, presumably both of them strings. Something like:

map[string]interface{}{
    "email": email_value,
    "password": password_value,
}

and you check the values with:

email, ok := creds["email"].(string)
if ok {
    // email will contain the value because creds["email"] passed the type check
    fmt.Printf("submitted email is %#v\n", email)
} else {
    // "email" property was a string (may be missing, may be something else)
}

The documentation of json.Unmarshal explains the semantics of how arbitrary JSON strings can be parsed without knowing their structure in advance in the discussion about unmarshalling to interface values.