Fix structaccess.Get to handle embedded structs and empty slices/maps (#3657)

## Why
Fixing bugs, this is used in direct deployment for resolving resource
references.

Tests are adapted from #3650 it's
the same issue in different libraries.

## Tests
New unit tests.

Author: denik

libs/structs/structaccess/get.go

@@ -90,25 +90,32 @@ func Get(v any, path *structpath.PathNode) (any, error) {
 func accessKey(v reflect.Value, key string, path *structpath.PathNode) (reflect.Value, error) {
 	switch v.Kind() {
 	case reflect.Struct:
-		fv, sf, owner, ok := findStructFieldByKey(v, key)
+		// Precalculate ForceSendFields mappings for this struct hierarchy
+		forceSendFieldsMap := getForceSendFieldsForFromTyped(v)
+
+		fv, sf, embeddedIndex, ok := findStructFieldByKey(v, key)
 		if !ok {
 			return reflect.Value{}, fmt.Errorf("%s: field %q not found in %s", path.String(), key, v.Type())
 		}
-		// Evaluate ForceSendFields on both the current struct and the declaring owner
-		force := containsForceSendField(v, sf.Name) || containsForceSendField(owner, sf.Name)
 
-		// Honor omitempty: if present and value is zero and not forced, treat as omitted (nil).
+		// Check ForceSendFields using precalculated map
+		var force bool
+		if fields, exists := forceSendFieldsMap[embeddedIndex]; exists {
+			force = containsString(fields, sf.Name)
+		}
+
+		// Honor omitempty: if present and value is empty and not forced, treat as omitted (nil).
 		jsonTag := structtag.JSONTag(sf.Tag.Get("json"))
 		if jsonTag.OmitEmpty() && !force {
 			if fv.Kind() == reflect.Pointer {
 				if fv.IsNil() {
 					return reflect.Value{}, nil
 				}
-				// Non-nil pointer: check the element zero-ness for pointers to scalars/structs.
-				if fv.Elem().IsZero() {
+				// Non-nil pointer: check if the pointed-to value is empty for omitempty
+				if isEmptyForOmitEmpty(fv.Elem()) {
 					return reflect.Value{}, nil
 				}
-			} else if fv.IsZero() {
+			} else if isEmptyForOmitEmpty(fv) {
 				return reflect.Value{}, nil
 			}
 		}
@@ -132,18 +139,18 @@ func accessKey(v reflect.Value, key string, path *structpath.PathNode) (reflect.
 	}
 }
 
-// findStructFieldByKey searches exported fields of struct v for a field matching key.
-// It matches json tag name (when present and not "-") only.
-// It also searches embedded anonymous structs (pointer or value) recursively.
-func findStructFieldByKey(v reflect.Value, key string) (reflect.Value, reflect.StructField, reflect.Value, bool) {
+// findFieldInStruct searches for a field by JSON key in a single struct (no embedding).
+// Returns: fieldValue, structField, found
+func findFieldInStruct(v reflect.Value, key string) (reflect.Value, reflect.StructField, bool) {
 	t := v.Type()
-
-	// First pass: direct fields
 	for i := range t.NumField() {
 		sf := t.Field(i)
 		if sf.PkgPath != "" { // unexported
 			continue
 		}
+		if sf.Anonymous { // skip embedded fields
+			continue
+		}
 
 		// Read JSON tag using structtag helper
 		name := structtag.JSONTag(sf.Tag.Get("json")).Name()
@@ -157,11 +164,26 @@ func findStructFieldByKey(v reflect.Value, key string) (reflect.Value, reflect.S
 			if btag.Internal() || btag.ReadOnly() {
 				continue
 			}
-			return v.Field(i), sf, v, true
+			return v.Field(i), sf, true
 		}
 	}
+	return reflect.Value{}, reflect.StructField{}, false
+}
+
+// findStructFieldByKey searches exported fields of struct v for a field matching key.
+// It matches json tag name (when present and not "-") only.
+// It also searches embedded anonymous structs (flattening semantics).
+// Returns: fieldValue, structField, embeddedIndex, found
+// embeddedIndex is -1 for direct fields, or the index of the embedded struct containing the field.
+func findStructFieldByKey(v reflect.Value, key string) (reflect.Value, reflect.StructField, int, bool) {
+	t := v.Type()
+
+	// First pass: direct fields
+	if fv, sf, found := findFieldInStruct(v, key); found {
+		return fv, sf, -1, true
+	}
 
-	// Second pass: search embedded anonymous structs recursively (flattening semantics)
+	// Second pass: search embedded anonymous structs (flattening semantics)
 	for i := range t.NumField() {
 		sf := t.Field(i)
 		if !sf.Anonymous {
@@ -179,38 +201,88 @@ func findStructFieldByKey(v reflect.Value, key string) (reflect.Value, reflect.S
 		if fv.Kind() != reflect.Struct {
 			continue
 		}
-		if out, osf, owner, ok := findStructFieldByKey(fv, key); ok {
-			// Skip fields marked as internal or readonly via bundle tag
-			btag := structtag.BundleTag(osf.Tag.Get("bundle"))
-			if btag.Internal() || btag.ReadOnly() {
-				// Treat as not found and continue searching other anonymous fields
-				continue
+		if out, osf, found := findFieldInStruct(fv, key); found {
+			return out, osf, i, true
+		}
+	}
+
+	return reflect.Value{}, reflect.StructField{}, -1, false
+}
+
+// getForceSendFieldsForFromTyped collects ForceSendFields values for FromTyped operations
+// Returns map[structKey][]fieldName where structKey is -1 for direct fields, embedded index for embedded fields
+func getForceSendFieldsForFromTyped(v reflect.Value) map[int][]string {
+	if !v.IsValid() || v.Type().Kind() != reflect.Struct {
+		return make(map[int][]string)
+	}
+
+	result := make(map[int][]string)
+
+	for i := range v.Type().NumField() {
+		field := v.Type().Field(i)
+		fieldValue := v.Field(i)
+
+		if field.Name == "ForceSendFields" && !field.Anonymous {
+			// Direct ForceSendFields (structKey = -1)
+			if fields, ok := fieldValue.Interface().([]string); ok {
+				result[-1] = fields
+			}
+		} else if field.Anonymous {
+			// Embedded struct - check for ForceSendFields inside it
+			if embeddedStruct := getEmbeddedStructForReading(fieldValue); embeddedStruct.IsValid() {
+				if forceSendField := embeddedStruct.FieldByName("ForceSendFields"); forceSendField.IsValid() {
+					if fields, ok := forceSendField.Interface().([]string); ok {
+						result[i] = fields
+					}
+				}
 			}
-			return out, osf, owner, true
 		}
 	}
 
-	return reflect.Value{}, reflect.StructField{}, reflect.Value{}, false
+	return result
 }
 
-// containsForceSendField reports whether struct v has a ForceSendFields slice containing goFieldName.
-func containsForceSendField(v reflect.Value, goFieldName string) bool {
-	if !v.IsValid() || v.Kind() != reflect.Struct {
-		return false
+// Helper function for reading - doesn't create nil pointers
+func getEmbeddedStructForReading(fieldValue reflect.Value) reflect.Value {
+	if fieldValue.Kind() == reflect.Pointer {
+		if fieldValue.IsNil() {
+			return reflect.Value{} // Don't create, just return invalid
+		}
+		fieldValue = fieldValue.Elem()
 	}
-	fsField := v.FieldByName("ForceSendFields")
-	if !fsField.IsValid() || fsField.Kind() != reflect.Slice {
-		return false
+	if fieldValue.Kind() == reflect.Struct {
+		return fieldValue
 	}
-	for i := range fsField.Len() {
-		el := fsField.Index(i)
-		if el.Kind() == reflect.String && el.String() == goFieldName {
+	return reflect.Value{}
+}
+
+// containsString checks if a slice contains a specific string
+func containsString(slice []string, str string) bool {
+	for _, s := range slice {
+		if s == str {
 			return true
 		}
 	}
 	return false
 }
 
+// isEmptyForOmitEmpty returns true if the value should be omitted by JSON omitempty.
+// This matches JSON encoder behavior, which is different from reflect.IsZero() for slices/maps.
+func isEmptyForOmitEmpty(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Slice, reflect.Map, reflect.Array:
+		return v.Len() == 0
+	case reflect.Interface, reflect.Pointer:
+		return v.IsNil()
+	case reflect.Struct:
+		// Pointers to structs are not considered empty if pointer != nil
+		// Structs as values are never empty and omitempty on them has no effect.
+		return false
+	default:
+		return v.IsZero()
+	}
+}
+
 // deref dereferences pointers and interfaces until it reaches a non-pointer, non-interface value.
 // Returns ok=false if it encounters a nil pointer/interface.
 func deref(v reflect.Value) (reflect.Value, bool) {