rigging/field_walk.go at main · Azhovan/rigging · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package rigging

import "reflect"

type walkedField struct {
	fieldPath  string
	keyPath    string
	value      reflect.Value
	provenance *FieldProvenance
	secret     bool
	optional   bool
	set        bool
}

func getStructRootValue(v any) (reflect.Value, bool) {
	rv := reflect.ValueOf(v)
	if !rv.IsValid() {
		return reflect.Value{}, false
	}

	if rv.Kind() == reflect.Ptr {
		if rv.IsNil() {
			return reflect.Value{}, false
		}
		rv = rv.Elem()
	}

	if rv.Kind() != reflect.Struct {
		return reflect.Value{}, false
	}

	return rv, true
}

func buildProvenanceMap[T any](cfg *T) map[string]*FieldProvenance {
	provenanceMap := make(map[string]*FieldProvenance)

	prov, _ := GetProvenance(cfg)
	if prov == nil {
		return provenanceMap
	}

	for i := range prov.Fields {
		provenanceMap[prov.Fields[i].FieldPath] = &prov.Fields[i]
	}

	return provenanceMap
}

func resolveKeyPath(fieldName string, tagCfg tagConfig, keyPathPrefix string, prov *FieldProvenance) string {
	if prov != nil && prov.KeyPath != "" {
		return prov.KeyPath
	}

	if tagCfg.name != "" {
		return tagCfg.name
	}

	keyPath := deriveFieldKey(fieldName)
	if keyPathPrefix != "" {
		keyPath = keyPathPrefix + "." + keyPath
	}
	return keyPath
}

func walkFlatFields(v reflect.Value, fieldPathPrefix, keyPathPrefix string, provenanceMap map[string]*FieldProvenance, inheritedSecret bool, visit func(w walkedField)) {
	t := v.Type()
	for _, meta := range getStructFieldMeta(t) {
		field := meta.field
		fieldValue := v.Field(meta.index)
		tagCfg := meta.tagCfg

		fieldPath := field.Name
		if fieldPathPrefix != "" {
			fieldPath = fieldPathPrefix + "." + field.Name
		}

		var prov *FieldProvenance
		if p, ok := provenanceMap[fieldPath]; ok {
			prov = p
		}

		isSecret := shouldRedactField(tagCfg, prov, inheritedSecret)
		keyPath := resolveKeyPath(field.Name, tagCfg, keyPathPrefix, prov)

		if fieldValue.Kind() == reflect.Struct && field.Type != timeType {
			if isOptionalType(field.Type) {
				setField := fieldValue.FieldByName("Set")
				valueField := fieldValue.FieldByName("Value")
				isSet := setField.IsValid() && setField.Bool() && valueField.IsValid()

				w := walkedField{
					fieldPath:  fieldPath,
					keyPath:    keyPath,
					provenance: prov,
					secret:     isSecret,
					optional:   true,
					set:        isSet,
				}
				if isSet {
					w.value = valueField
				}

				visit(w)
				continue
			}

			nestedKeyPrefix := keyPath
			if tagCfg.prefix != "" {
				nestedKeyPrefix = tagCfg.prefix
			}

			walkFlatFields(fieldValue, fieldPath, nestedKeyPrefix, provenanceMap, isSecret, visit)
			continue
		}

		visit(walkedField{
			fieldPath:  fieldPath,
			keyPath:    keyPath,
			value:      fieldValue,
			provenance: prov,
			secret:     isSecret,
			set:        true,
		})
	}
}