Can StringToTimeHookFunc be enhanced?

[kaysonwu]

I defined an alias type DateTime for time.Time, It mainly implements the time.DateTime format string and time.Time interchange

type DateTime time.Time

func (d DateTime) MarshalJSON() ([]byte, error) {
	t := time.Time(d)

	if t.Equal(time.Time{}) {
		return []byte("null"), nil
	}

	return []byte(`"` + t.Format(time.DateTime) + `"`), nil
}

func (d *DateTime) UnmarshalJSON(data []byte) error {
	str := string(data)

	if str == "null" {
		*d = DateTime(time.Time{})
	} else if date, err := time.Parse(time.DateTime, str); err == nil {
		*d = DateTime(date)
	} else {
		return err
	}

	return nil
}

func (d DateTime) Value() (driver.Value, error) {
	t := time.Time(d)

	if t.Equal(time.Time{}) {
		return nil, nil
	}

	return t.Format(time.DateTime), nil
}

func (d *DateTime) Scan(value any) error {
	if val, ok := value.(time.Time); ok {
		*d = DateTime(val)

		return nil
	}

	return fmt.Errorf("Failed to scan type %T into DateTime", value)
}

Next, I will apply DateTime to the user model and provide a NewModel factory function

type User struct {
    Name  string `json:"name" gorm:"size:255"`
   CreatedAt DateTime `json:"created_at"`
   UpdatedAt DateTime `json:"created_at"`
}

func NewModel[T any](attributes map[string]any, tagName string) (T, error) {
	var model T

	decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
		DecodeHook:       mapstructure.StringToTimeHookFunc(time.DateTime),
		WeaklyTypedInput: true,
		TagName:          tagName,
		Result:           &model,
	})

	if err != nil {
		return model, err
	}

	return model, decoder.Decode(attributes)
}

When I run, I receive 'created_at' expected a map, got 'string' error message.

 attributes := map[string]any {
  "name": "foo",
  "created_at": "2006-01-02 15:04:05",
    "updated_at": "2006-01-02 15:04:05",
}

user, err := NewModel[User](attributes)

if err != nil {
   fmt.Println(err)
} else {
   fmt.Println("ok")
}

Tracking the code, I found that it can enhance StringToTimeHookFunc to make it more adaptable, e.g.

func StringToTimeHookFunc(layout string) mapstructure.DecodeHookFunc {
	return func(
		f reflect.Type,
		t reflect.Type,
		data interface{}) (interface{}, error) {
		if f.Kind() != reflect.String {
			return data, nil
		}

                //  Rewrite t  != reflect.TypeOf(time.Time{})  to  ConvertibleTo
		if !t.ConvertibleTo(reflect.TypeOf(time.Time{})) {
			return data, nil
		}
         
		// Convert it by parsing
		value, err := time.Parse(layout, data.(string))

		if err != nil {
			return data, err
		}

		return reflect.ValueOf(value).Convert(t).Interface(), nil
	}
}