WIP.

lib/debezium/converters/time.go

@@ -3,6 +3,7 @@ package converters
 import (
 	"fmt"
 	"strings"
+	"time"
 
 	"github.com/artie-labs/transfer/lib/typing/ext"
 )
@@ -33,3 +34,21 @@ func ConvertDateTimeWithTimezone(value any) (*ext.ExtendedTime, error) {
 
 	return nil, fmt.Errorf("failed to parse %q, err: %w", dtString, err)
 }
+
+func ConvertTimeWithTimezone(value any) (*ext.ExtendedTime, error) {
+	valString, isOk := value.(string)
+	if !isOk {
+		return nil, fmt.Errorf("expected string got '%v' with type %T", value, value)
+	}
+
+	var err error
+	var ts time.Time
+	for _, supportedTimeFormat := range ext.SupportedTimeWithTimezoneFormats {
+		ts, err = ext.ParseTimeExactMatch(supportedTimeFormat, valString)
+		if err == nil {
+			return ext.NewExtendedTime(ts, ext.TimeKindType, supportedTimeFormat), nil
+		}
+	}
+
+	return nil, fmt.Errorf("failed to parse %q: %w", valString, err)
+}

lib/debezium/converters/time_test.go

@@ -43,3 +43,34 @@ func TestConvertDateTimeWithTimezone(t *testing.T) {
 		assert.Equal(t, expectedExtTime, val)
 	}
 }
+
+func TestConvertTimeWithTimezone(t *testing.T) {
+	{
+		// What Debezium would produce
+		ts, err := ConvertTimeWithTimezone("23:02:06.745116Z")
+		assert.NoError(t, err)
+		expectedTs := &ext.ExtendedTime{
+			Time: time.Date(0, 1, 1, 23, 2, 6, 745116000, time.UTC),
+			NestedKind: ext.NestedKind{
+				Type:   ext.TimeKindType,
+				Format: "15:04:05.000000Z",
+			},
+		}
+
+		assert.Equal(t, expectedTs, ts)
+	}
+	{
+		// What Reader would produce
+		ts, err := ConvertTimeWithTimezone("23:02:06.745116")
+		assert.NoError(t, err)
+		expectedTs := &ext.ExtendedTime{
+			Time: time.Date(0, 1, 1, 23, 2, 6, 745116000, time.UTC),
+			NestedKind: ext.NestedKind{
+				Type:   ext.TimeKindType,
+				Format: "15:04:05.000000",
+			},
+		}
+
+		assert.Equal(t, expectedTs, ts)
+	}
+}

lib/debezium/types.go

@@ -135,6 +135,8 @@ func (f Field) ParseValue(value any) (any, error) {
 		return f.DecodeDebeziumVariableDecimal(value)
 	case DateTimeWithTimezone:
 		return converters.ConvertDateTimeWithTimezone(value)
+	case TimeWithTimezone:
+		return converters.ConvertTimeWithTimezone(value)
 	case
 		Timestamp,
 		MicroTimestamp,

lib/typing/ext/parse.go

@@ -24,10 +24,25 @@ func ParseFromInterface(val any, additionalDateFormats []string) (*ExtendedTime,
 	return extendedTime, nil
 }
 
-// ParseTimeExactMatch is a wrapper around time.Parse() and will return an extra boolean to indicate if it was an exact match or not.
+// ParseTimeExactMatch - This function is the same as `ParseTimeExactMatchLegacy` with the only exception that it'll return if it was not an exact match
+func ParseTimeExactMatch(layout, potentialDateTimeString string) (time.Time, error) {
+	ts, err := time.Parse(layout, potentialDateTimeString)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	if ts.Format(layout) != potentialDateTimeString {
+		return time.Time{}, fmt.Errorf("failed to parse %q with layout %q", potentialDateTimeString, layout)
+	}
+
+	return ts, nil
+}
+
+// TODO: Remove callers from this.
+// ParseTimeExactMatchLegacy is a wrapper around time.Parse() and will return an extra boolean to indicate if it was an exact match or not.
 // Parameters: layout, potentialDateTimeString
 // Returns: time.Time object, exactLayout (boolean), error
-func ParseTimeExactMatch(layout, potentialDateTimeString string) (time.Time, bool, error) {
+func ParseTimeExactMatchLegacy(layout, potentialDateTimeString string) (time.Time, bool, error) {
 	ts, err := time.Parse(layout, potentialDateTimeString)
 	if err != nil {
 		return ts, false, err
@@ -51,7 +66,7 @@ func ParseExtendedDateTime(dtString string, additionalDateFormats []string) (*Ex
 	var potentialFormat string
 	var potentialTime time.Time
 	for _, supportedDateTimeLayout := range supportedDateTimeLayouts {
-		ts, exactMatch, err := ParseTimeExactMatch(supportedDateTimeLayout, dtString)
+		ts, exactMatch, err := ParseTimeExactMatchLegacy(supportedDateTimeLayout, dtString)
 		if err == nil {
 			potentialFormat = supportedDateTimeLayout
 			potentialTime = ts
@@ -63,18 +78,17 @@ func ParseExtendedDateTime(dtString string, additionalDateFormats []string) (*Ex
 
 	// Now check DATE formats, btw you can append nil arrays
 	for _, supportedDateFormat := range append(supportedDateFormats, additionalDateFormats...) {
-		ts, exactMatch, err := ParseTimeExactMatch(supportedDateFormat, dtString)
+		ts, exactMatch, err := ParseTimeExactMatchLegacy(supportedDateFormat, dtString)
 		if err == nil && exactMatch {
 			return NewExtendedTime(ts, DateKindType, supportedDateFormat), nil
 		}
 	}
 
 	// Now check TIME formats
-	for _, supportedTimeFormat := range supportedTimeFormats {
-		ts, exactMatch, err := ParseTimeExactMatch(supportedTimeFormat, dtString)
+	for _, supportedTimeFormat := range SupportedTimeFormatsLegacy {
+		ts, exactMatch, err := ParseTimeExactMatchLegacy(supportedTimeFormat, dtString)
 		if err == nil && exactMatch {
 			return NewExtendedTime(ts, TimeKindType, supportedTimeFormat), nil
-
 		}
 	}
 

lib/typing/ext/parse_test.go

@@ -64,7 +64,7 @@ func TestParseFromInterfaceDateTime(t *testing.T) {
 
 func TestParseFromInterfaceTime(t *testing.T) {
 	now := time.Now()
-	for _, supportedTimeFormat := range supportedTimeFormats {
+	for _, supportedTimeFormat := range SupportedTimeFormatsLegacy {
 		et, err := ParseFromInterface(now.Format(supportedTimeFormat), nil)
 		assert.NoError(t, err)
 		assert.Equal(t, et.NestedKind.Type, TimeKindType)
@@ -110,7 +110,7 @@ func TestParseExtendedDateTime(t *testing.T) {
 func TestTimeLayout(t *testing.T) {
 	ts := time.Now()
 
-	for _, supportedFormat := range supportedTimeFormats {
+	for _, supportedFormat := range SupportedTimeFormatsLegacy {
 		parsedTsString := ts.Format(supportedFormat)
 		extTime, err := ParseExtendedDateTime(parsedTsString, nil)
 		assert.NoError(t, err)

lib/typing/ext/time.go

@@ -82,11 +82,3 @@ func (e *ExtendedTime) String(overrideFormat string) string {
 
 	return e.Time.Format(e.NestedKind.Format)
 }
-
-func (e *ExtendedTime) StringUTC(overrideFormat string) string {
-	if overrideFormat != "" {
-		return e.Time.In(time.UTC).Format(overrideFormat)
-	}
-
-	return e.Time.In(time.UTC).Format(e.NestedKind.Format)
-}

lib/typing/ext/variables.go

@@ -29,12 +29,26 @@ var supportedDateFormats = []string{
 	PostgresDateFormat,
 }
 
-var supportedTimeFormats = []string{
+// TODO: Remove
+var SupportedTimeFormatsLegacy = []string{
 	PostgresTimeFormat,
 	PostgresTimeFormatNoTZ,
 	AdditionalTimeFormat,
 }
 
+var SupportedTimeWithTimezoneFormats = []string{
+	// Debezium will emit `Z` for UTC time
+	"15:04:05Z",        // w/o fractional seconds
+	"15:04:05.000Z",    // ms
+	"15:04:05.000000Z", // microseconds
+
+	// TODO: Get Reader to be consistent with Debezium
+	// Reader will omit ts locale
+	"15:04:05",        // w/o fractional seconds
+	"15:04:05.000",    // ms
+	"15:04:05.000000", // microseconds
+}
+
 func NewUTCTime(layout string) string {
 	return time.Now().UTC().Format(layout)
 }