Upgrade AWS SDK to the latest version

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/decode.go

@@ -16,7 +16,7 @@ import (
 // 			Value int
 // 		}
 //
-// 		type (u *exampleUnmarshaler) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
+// 		func (u *exampleUnmarshaler) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
 // 			if av.N == nil {
 // 				return nil
 // 			}
@@ -153,6 +153,7 @@ var stringInterfaceMapType = reflect.TypeOf(map[string]interface{}(nil))
 var byteSliceType = reflect.TypeOf([]byte(nil))
 var byteSliceSlicetype = reflect.TypeOf([][]byte(nil))
 var numberType = reflect.TypeOf(Number(""))
+var timeType = reflect.TypeOf(time.Time{})
 
 func (d *Decoder) decode(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
 	var u Unmarshaler
@@ -338,12 +339,12 @@ func (d *Decoder) decodeNumber(n *string, v reflect.Value, fieldTag tag) error {
 		}
 		v.SetFloat(i)
 	default:
-		if _, ok := v.Interface().(time.Time); ok && fieldTag.AsUnixTime {
+		if v.Type().ConvertibleTo(timeType) && fieldTag.AsUnixTime {
 			t, err := decodeUnixTime(*n)
 			if err != nil {
 				return err
 			}
-			v.Set(reflect.ValueOf(t))
+			v.Set(reflect.ValueOf(t).Convert(v.Type()))
 			return nil
 		}
 		return &UnmarshalTypeError{Value: "number", Type: v.Type()}
@@ -502,12 +503,12 @@ func (d *Decoder) decodeString(s *string, v reflect.Value, fieldTag tag) error {
 
 	// To maintain backwards compatibility with ConvertFrom family of methods which
 	// converted strings to time.Time structs
-	if _, ok := v.Interface().(time.Time); ok {
+	if v.Type().ConvertibleTo(timeType) {
 		t, err := time.Parse(time.RFC3339, *s)
 		if err != nil {
 			return err
 		}
-		v.Set(reflect.ValueOf(t))
+		v.Set(reflect.ValueOf(t).Convert(v.Type()))
 		return nil
 	}
 
@@ -564,7 +565,7 @@ func decodeUnixTime(n string) (time.Time, error) {
 	v, err := strconv.ParseInt(n, 10, 64)
 	if err != nil {
 		return time.Time{}, &UnmarshalError{
-			Err: err, Value: n, Type: reflect.TypeOf(time.Time{}),
+			Err: err, Value: n, Type: timeType,
 		}
 	}
 

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/decode_test.go

@@ -527,3 +527,31 @@ func TestDecodeUnixTime(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, expect, actual)
 }
+
+func TestDecodeAliasedUnixTime(t *testing.T) {
+	type A struct {
+		Normal AliasedTime
+		Tagged AliasedTime `dynamodbav:",unixtime"`
+	}
+
+	expect := A{
+		Normal: AliasedTime(time.Unix(123, 0).UTC()),
+		Tagged: AliasedTime(time.Unix(456, 0)),
+	}
+
+	input := &dynamodb.AttributeValue{
+		M: map[string]*dynamodb.AttributeValue{
+			"Normal": {
+				S: aws.String("1970-01-01T00:02:03Z"),
+			},
+			"Tagged": {
+				N: aws.String("456"),
+			},
+		},
+	}
+	actual := A{}
+
+	err := Unmarshal(input, &actual)
+	assert.NoError(t, err)
+	assert.Equal(t, expect, actual)
+}

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/doc.go

@@ -1,50 +1,82 @@
-// Package dynamodbattribute provides marshaling utilities for marshaling to
-// dynamodb.AttributeValue types and unmarshaling to Go value types. These
-// utilities allow you to marshal slices, maps, structs, and scalar values
+// Package dynamodbattribute provides marshaling and unmarshaling utilities to
+// convert between Go types and dynamodb.AttributeValues.
+//
+// These utilities allow you to marshal slices, maps, structs, and scalar values
 // to and from dynamodb.AttributeValue. These are useful when marshaling
 // Go value tyes to dynamodb.AttributeValue for DynamoDB requests, or
 // unmarshaling the dynamodb.AttributeValue back into a Go value type.
 //
-// Marshal Go value types to dynamodb.AttributeValue: See (ExampleMarshal)
+// AttributeValue Marshaling
+//
+// To marshal a Go type to a dynamodbAttributeValue you can use the Marshal
+// functions in the dynamodbattribute package. There are specialized versions
+// of these functions for collections of Attributevalue, such as maps and lists.
+//
+// The following example uses MarshalMap to convert the Record Go type to a
+// dynamodb.AttributeValue type and use the value to make a PutItem API request.
 //
 //     type Record struct {
-//         MyField string
-//         Letters []string
-//         A2Num   map[string]int
+//         ID     string
+//         URLs   []string
 //     }
 //
-//     ...
+//     //...
 //
 //     r := Record{
-//         MyField: "dynamodbattribute.Marshal example",
-//         Letters: []string{"a", "b", "c", "d"},
-//         A2Num:   map[string]int{"a": 1, "b": 2, "c": 3},
+//         ID:   "ABC123",
+//         URLs: []string{
+//             "https://example.com/first/link",
+//             "https://example.com/second/url",
+//         },
 //     }
-//     av, err := dynamodbattribute.Marshal(r)
-//     fmt.Println(av, err)
-//
-// Unmarshal dynamodb.AttributeValue to Go value type: See (ExampleUnmarshal)
-//
-//     r2 := Record{}
-//     err = dynamodbattribute.Unmarshal(av, &r2)
-//     fmt.Println(err, reflect.DeepEqual(r, r2))
-//
-// Marshal Go value type for DynamoDB.PutItem:
-//
-//     sess := session.Must(session.NewSession())
-//
-//     svc := dynamodb.New(sess)
-//     item, err := dynamodbattribute.MarshalMap(r)
+//     av, err := dynamodbattribute.MarshalMap(r)
 //     if err != nil {
-//         fmt.Println("Failed to convert", err)
-//         return
+//         panic(fmt.Sprintf("failed to DynamoDB marshal Record, %v", err))
 //     }
-//     result, err := svc.PutItem(&dynamodb.PutItemInput{
-//         Item:      item,
-//         TableName: aws.String("exampleTable"),
+//
+//     _, err = svc.PutItem(&dynamodb.PutItemInput{
+//         TableName: aws.String(myTableName),
+//         Item:      av,
 //     })
+//     if err != nil {
+//         panic(fmt.Sprintf("failed to put Record to DynamoDB, %v", err))
+//     }
 //
+// AttributeValue Unmarshaling
 //
+// To unmarshal a dynamodb.AttributeValue to a Go type you can use the Unmarshal
+// functions in the dynamodbattribute package. There are specialized versions
+// of these functions for collections of Attributevalue, such as maps and lists.
+//
+// The following example will unmarshal the DynamoDB's Scan API operation. The
+// Items returned by the operation will be unmarshaled into the slice of Records
+// Go type.
+//
+//     type Record struct {
+//         ID     string
+//         URLs   []string
+//     }
+//
+//     //...
+//
+//     var records []Record
+//
+//     // Use the ScanPages method to perform the scan with pagination. Use
+//     // just Scan method to make the API call without pagination.
+//     err := svc.ScanPages(&dynamodb.ScanInput{
+//         TableName: aws.String(myTableName),
+//     }, func(page *dynamodb.ScanOutput, last bool) bool {
+//         recs := []Record{}
+//
+//         err := dynamodbattribute.UnmarshalListOfMaps(page.Items, &recs)
+//         if err != nil {
+//              panic(fmt.Sprintf("failed to unmarshal Dynamodb Scan Items, %v", err))
+//         }
+//
+//         records = append(records, recs...)
+//
+//         return true // keep paging
+//     })
 //
 // The ConvertTo, ConvertToList, ConvertToMap, ConvertFrom, ConvertFromMap
 // and ConvertFromList methods have been deprecated. The Marshal and Unmarshal

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/encode.go

@@ -14,7 +14,7 @@ import (
 // and unmarshaled with DynamoDB AttributeValues it will be done so as number
 // instead of string in seconds since January 1, 1970 UTC.
 //
-// This type is useful as an alterntitive to the struct tag `unixtime` when you
+// This type is useful as an alternative to the struct tag `unixtime` when you
 // want to have your time value marshaled as Unix time in seconds intead of
 // the default time.RFC3339.
 //
@@ -57,10 +57,9 @@ func (e *UnixTime) UnmarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue)
 //		type ExampleMarshaler struct {
 //			Value int
 //		}
-//		type (m *ExampleMarshaler) 	MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
+//		func (m *ExampleMarshaler) 	MarshalDynamoDBAttributeValue(av *dynamodb.AttributeValue) error {
 //			n := fmt.Sprintf("%v", m.Value)
 //			av.N = &n
-//
 //			return nil
 //		}
 //
@@ -159,6 +158,8 @@ func Marshal(in interface{}) (*dynamodb.AttributeValue, error) {
 
 // MarshalMap is an alias for Marshal func which marshals Go value
 // type to a map of AttributeValues.
+//
+// This is useful for DynamoDB APIs such as PutItem.
 func MarshalMap(in interface{}) (map[string]*dynamodb.AttributeValue, error) {
 	av, err := NewEncoder().Encode(in)
 	if err != nil || av == nil || av.M == nil {
@@ -284,7 +285,9 @@ func (e *Encoder) encode(av *dynamodb.AttributeValue, v reflect.Value, fieldTag
 func (e *Encoder) encodeStruct(av *dynamodb.AttributeValue, v reflect.Value, fieldTag tag) error {
 	// To maintain backwards compatibility with ConvertTo family of methods which
 	// converted time.Time structs to strings
-	if t, ok := v.Interface().(time.Time); ok {
+	if v.Type().ConvertibleTo(timeType) {
+		var t time.Time
+		t = v.Convert(timeType).Interface().(time.Time)
 		if fieldTag.AsUnixTime {
 			return UnixTime(t).MarshalDynamoDBAttributeValue(av)
 		}

vendor/github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute/encode_test.go

@@ -207,3 +207,31 @@ func TestEncodeUnixTime(t *testing.T) {
 	}
 	assert.Equal(t, expect, actual)
 }
+
+type AliasedTime time.Time
+
+func TestEncodeAliasedUnixTime(t *testing.T) {
+	type A struct {
+		Normal AliasedTime
+		Tagged AliasedTime `dynamodbav:",unixtime"`
+	}
+
+	a := A{
+		Normal: AliasedTime(time.Unix(123, 0).UTC()),
+		Tagged: AliasedTime(time.Unix(456, 0)),
+	}
+
+	actual, err := Marshal(a)
+	assert.NoError(t, err)
+	expect := &dynamodb.AttributeValue{
+		M: map[string]*dynamodb.AttributeValue{
+			"Normal": {
+				S: aws.String("1970-01-01T00:02:03Z"),
+			},
+			"Tagged": {
+				N: aws.String("456"),
+			},
+		},
+	}
+	assert.Equal(t, expect, actual)
+}