Adds RestJson deserializer and middleware generation support

aws/protocol/json/decoder_util.go

@@ -0,0 +1,128 @@
+package json
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/awslabs/smithy-go"
+	"io"
+	"strings"
+)
+
+// GetErrorInfo util looks for code, __type, and message members in the
+// json body. These members are optionally available, and the function
+// returns the value of member if it is available. This function is useful to
+// identify the error code, msg in a REST JSON error response.
+func GetErrorInfo(decoder *json.Decoder) (errorType string, message string, err error) {
+	startToken, err := decoder.Token()
+	if err == io.EOF {
+		return "", "", nil
+	}
+	if err != nil {
+		return "", "", err
+	}
+
+	if t, ok := startToken.(json.Delim); !ok || t.String() != "{" {
+		return "", "", fmt.Errorf("expected start token to be {")
+	}
+
+	for decoder.More() {
+		var target *string
+		t, err := decoder.Token()
+		if err != nil {
+			return "", "", err
+		}
+
+		switch st := t.(string); {
+		case strings.EqualFold(st, "code"):
+		case strings.EqualFold(st, "__type"):
+			target = &errorType
+		case strings.EqualFold(st, "message"):
+			target = &message
+		default:
+			DiscardUnknownField(decoder)
+			continue
+		}
+
+		v, err := decoder.Token()
+		if err != nil {
+			return errorType, message, err
+		}
+		*target = v.(string)
+	}
+
+	endToken, err := decoder.Token()
+	if err != nil {
+		return "", "", err
+	}
+
+	if t, ok := endToken.(json.Delim); !ok || t.String() != "}" {
+		return "", "", fmt.Errorf("expected end token to be }")
+	}
+	return errorType, message, nil
+}
+
+// SanitizeErrorCode sanitizes the errorCode string .
+// The rule for sanitizing is if a `:` character is present, then take only the
+// contents before the first : character in the value.
+// If a # character is present, then take only the contents after the
+// first # character in the value.
+func SanitizeErrorCode(errorCode string) string {
+	if strings.ContainsAny(errorCode, ":") {
+		errorCode = strings.SplitN(errorCode, ":", 2)[0]
+	}
+
+	if strings.ContainsAny(errorCode, "#") {
+		errorCode = strings.SplitN(errorCode, "#", 2)[1]
+	}
+
+	return errorCode
+}
+
+// DiscardUnknownField discards unknown fields from decoder body.
+// This function is useful while deserializing json body with additional
+// unknown information that should be discarded.
+func DiscardUnknownField(decoder *json.Decoder) error {
+	v, err := decoder.Token()
+	if err == io.EOF {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+
+	if _, ok := v.(json.Delim); ok {
+		for decoder.More() {
+			err = DiscardUnknownField(decoder)
+		}
+		endToken, err := decoder.Token()
+		if err != nil {
+			return err
+		}
+		if _, ok := endToken.(json.Delim); !ok {
+			return fmt.Errorf("invalid JSON : expected json delimiter, found %T %v",
+				endToken, endToken)
+		}
+	}
+
+	return nil
+}
+
+// GetSmithyGenericAPIError returns smithy generic api error and an error interface.
+// Takes in json decoder, and error Code string as args. The function retrieves error message
+// and error code from the decoder body. If errorCode of length greater than 0 is passed in as
+// an argument, it is used instead.
+func GetSmithyGenericAPIError(decoder *json.Decoder, errorCode string) (smithy.GenericAPIError, error) {
+	errorType, message, err := GetErrorInfo(decoder)
+	if err != nil {
+		return smithy.GenericAPIError{}, err
+	}
+
+	if len(errorCode) == 0 {
+		errorCode = SanitizeErrorCode(errorType)
+	}
+
+	return smithy.GenericAPIError{
+		Code:    errorCode,
+		Message: message,
+	}, nil
+}