@elsteelbrain I think this is generally the right approach -- stringifying the request Body -- but I don't know that this is the right place to do it. It would only fix it for http events, rather than all events.

This method might be better. cc @mthenw

Yup, you are right @alexdebrie. We discussed it earlier today.

Two notes:

1. We check properties of the body at the beginning of this block, but then check the properties of event.Data within the default statement, though those should be the same thing since body is assigned to event.Data earlier.

2. The first case statement checks the mimetype, and the default statement also checks the mimetype in an if statement. How about we move that if statement into a second case statement?

Combining these two, we'd have something like:

if len(body) > 0 {
  switch mime {
  case mimeJSON:
      err := json.Unmarshal(body, &event.Data)
      if err != nil {
          return errors.New("malformed JSON body")
      }
  case mimeFormMultipart, mimeFormURLEncoded:
      event.Data = string(body)
  }
}

@alexdebrie About the second note, mimeFormMultipart mime will be a bit different based on what user agent is sending them. The user agent specifies the body boundary, which is mentioned in the mime header, so, we cannot add that into a case statement. The other one we can, but then we'll have to duplicate the code for them.

About the first one, we cannot assign string to a body of type []byte because that is not allowed. The type interface{} of event.Data allows us to do that.

@elsteelbrain Good point on the multipart/form-data boundary. I hadn't thought of that.

About the first one, we cannot assign string to a body of type []byte because that is not allowed. The type interface{} of event.Data allows us to do that.

I don't understand this one. We're not assigning string to body, we're assigning the stringified version of body to event.Data, right? Like this: event.Data = string(body).

I'm gonna second what Alex said, those should be two case statements. I don't understand why is it not possible.

What about this:

if len(body) > 0 {
    switch {
    case mime == mimeJSON:
        err = json.Unmarshal(body, &event.Data)
        if err != nil {
            return nil, "", errors.New("malformed JSON body")
        }
    case strings.HasPrefix(mime, mimeFormMultipart), mime == mimeFormURLEncoded:
        event.Data = string(body)
    }
}

This also gets the complexity down under the limit without needing an additional function.

cc @elsteelbrain @mthenw

Can you add comment explaining what this function does?

I'm gonna second what Alex said, those should be two case statements. I don't understand why is it not possible.

Why you check for prefix here, not the full header?

Because the content type is different based on the user agent. For example, Insomnia send this as content type: multipart/form-data; boundary=X-INSOMNIA-BOUNDARY.

@elsteelbrain break isn't needed in Golang case statements -- https://tour.golang.org/flowcontrol/9

@elsteelbrain Same as above