struct2

package main

import (
	"fmt"
	"sort"
	"time"

	"github.com/worldline-go/struct2"
)

func sortPrint(m map[string]any) {
	keys := make([]string, 0, len(m))
	for k := range m {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for _, k := range keys {
		fmt.Printf("Type: %T, Value: %v\n", m[k], m[k])
	}
}

func main() {
	type ColorGroup struct {
		ID     int        `json:"id"`
		Name   string     `json:"name"`
		Colors []string   `json:"colors"`
		Date   timeCustom `json:"time"`
	}

	d, _ := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")

	group := ColorGroup{
		ID:     1,
		Name:   "Reds",
		Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
		Date:   timeCustom{Time: d},
	}

	result := new(struct2.Decoder).SetTagName("json").Map(group) // default tag name is "struct"

	// fmt.Printf("%#v", result)
	sortPrint(result)
}

Output:

Type: []string, Value: [Crimson Red Ruby Maroon]
Type: int, Value: 1
Type: string, Value: Reds
Type: time.Time, Value: 2006-01-02 15:04:05 +0000 UTC

package main

import (
	"fmt"
	"reflect"

	"github.com/worldline-go/struct2"
)

func main() {
	type ColorGroup struct {
		Name  string `db:"name"`
		Count int    `db:"count"`
	}

	group := ColorGroup{
		Name: "DeepCore",
	}

	decoder := struct2.Decoder{
		TagName: "db",
		Hooks: []struct2.HookFunc{func(v reflect.Value) (any, error) {
			if v.Kind() == reflect.String {
				return "str_" + v.Interface().(string), nil
			}

			return nil, struct2.ErrContinueHook
		}},
	}

	result := decoder.Map(group)

	fmt.Printf("%v", result["name"])
}

Output:

str_DeepCore

package main

import (
	"fmt"
	"reflect"
	"time"

	"github.com/worldline-go/struct2"
)

func main() {
	type SubCfg struct {
		Enabled bool `cfg:"enabled"`
	}

	type Config struct {
		Name  string        `cfg:"name"`
		Count int           `cfg:"count"`
		Sub   SubCfg        `cfg:"sub"`
		Time  time.Duration `cfg:"time"`
	}

	decoder := struct2.Decoder{
		TagName: "cfg",
		HooksDecode: []struct2.HookDecodeFunc{func(in reflect.Type, out reflect.Type, data any) (any, error) {
			if out == reflect.TypeFor[time.Duration]() {
				switch in.Kind() {
				case reflect.String:
					return time.ParseDuration(data.(string))
				}
			}

			return data, nil
		}},
		WeaklyTypedInput:      true,
		WeaklyIgnoreSeperator: true,
		WeaklyDashUnderscore:  true,
	}

	cfgMap := map[string]any{
		"name":  "Altay",
		"count": "42",
		"sub": map[string]any{
			"enabled": "true",
		},
		"time": "1h30m",
	}

	var cfg Config

	if err := decoder.Decode(cfgMap, &cfg); err != nil {
		fmt.Printf("decode error: %v", err)
		return
	}

	fmt.Printf("%v %v %v %v", cfg.Name, cfg.Count, cfg.Sub.Enabled, cfg.Time)
}

Output:

Altay 42 true 1h30m0s