Fix GetStructDiff to dereference non-nil pointers when the other side is omitted (#4766)

## Changes
Fix GetStructDiff to dereference non-nil pointers when the other side is
omitted

## Why
When comparing a non-nil pointer field against a nil/omitted side (due
to json omitempty), diffValues was storing the pointer value directly.
But when both sides are non-nil, it recursively dereferences via the
Pointer case. This inconsistency caused type mismatches (e.g., bool vs
*bool) when comparing changes from two different diff calls.

`localDiff` compares saved state vs current config. Both sides have
`Started = *bool(false) (non-nil)`, so `diffValues` hits the case
`reflect.Pointer` path and dereferences both:
`diffValues(*bool(false), *bool(true)) → diffValues(bool(false),
bool(true)) → Change{New: bool(true)}`

`remoteDiff` compares remote state vs current config. The remote has no
started field — in diffStruct, a nil *bool with omitempty gets replaced
with `reflect.Value{}` (invalid). But the current config side is
`*bool(true) (non-nil, non-zero)`, so it
stays as a pointer. Then diffValues stores the pointer without
dereferencing: `diffValues(invalid, *bool(true)) → Change{New:
*bool(true)}`

So localDiff produces `Change{New: bool(true)}` and remoteDiff produces
`Change{New: *bool(true)}` for the same path.

## Tests
<!-- How have you tested the changes? -->

<!-- If your PR needs to be included in the release notes for next
release,
add a separate entry in NEXT_CHANGELOG.md as part of your PR. -->

Author: andrewnester

libs/structs/structaccess/get.go

@@ -141,10 +141,11 @@ func accessKey(v reflect.Value, key string, path *structpath.PathNode) (reflect.
 				if fv.IsNil() {
 					return reflect.Value{}, nil
 				}
-				// Non-nil pointer: check if the pointed-to value is empty for omitempty
-				if isEmptyForOmitEmpty(fv.Elem()) {
-					return reflect.Value{}, nil
-				}
+				// Non-nil pointer: return the dereferenced value.
+				// JSON omitempty only omits nil pointers, not pointers to zero values.
+				// Returning the dereferenced value is consistent with GetStructDiff,
+				// which recursively dereferences non-nil pointers.
+				return fv.Elem(), nil
 			} else if isEmptyForOmitEmpty(fv) {
 				return reflect.Value{}, nil
 			}

libs/structs/structaccess/get_test.go

@@ -690,8 +690,9 @@ func TestGet_PointerToStructWithZeroValues(t *testing.T) {
 		NestedNoOmit: &NestedStruct{ID: 0, Name: "", Count: 0},
 	}
 
-	// The pointer was explicitly set, so it should return the struct even with zero values
-	testGet(t, obj, "nested_omit", &NestedStruct{ID: 0, Name: "", Count: 0})
+	// The pointer was explicitly set; it should return the dereferenced struct (not nil).
+	// JSON omitempty only omits nil pointers, not pointers to zero values.
+	testGet(t, obj, "nested_omit", NestedStruct{ID: 0, Name: "", Count: 0})
 	testGet(t, obj, "nested_omit.id", int64(0))
 	testGet(t, obj, "nested_omit.name", "")
 	testGet(t, obj, "nested_omit.count", 0)
@@ -725,7 +726,7 @@ func TestGetJobSettings(t *testing.T) {
 		},
 	}
 
-	testGet(t, &jobSettings, "tasks[0].run_job_task", &jobs.RunJobTask{})
+	testGet(t, &jobSettings, "tasks[0].run_job_task", jobs.RunJobTask{})
 	testGet(t, &jobSettings, "tasks[0].run_job_task.job_id", int64(0))
 }
 

libs/structs/structaccess/set_test.go

@@ -177,8 +177,8 @@ func TestSet(t *testing.T) {
 			expectedChanges: []structdiff.Change{
 				{
 					Path: structpath.MustParsePath("count"),
-					Old:  nil, // structdiff reports this as interface{}(nil)
-					New:  intPtr(42),
+					Old:  nil,
+					New:  42, // diffValues dereferences non-nil pointers when the other side is nil/omitted
 				},
 			},
 		},
@@ -494,10 +494,6 @@ func TestSet(t *testing.T) {
 	}
 }
 
-func intPtr(i int) *int {
-	return &i
-}
-
 // testSet sets a value and gets it back, asserting they're equal (roundtrip)
 func testSet(t *testing.T, obj any, path string, value any) {
 	t.Helper()

libs/structs/structdiff/diff.go

@@ -107,11 +107,18 @@ func diffValues(ctx *diffContext, path *structpath.PathNode, v1, v2 reflect.Valu
 		if !v2.IsValid() {
 			return nil
 		}
-
+		// Dereference non-nil pointers for consistency with the both-non-nil case,
+		// where pointers are recursively dereferenced via "case reflect.Pointer".
+		for v2.Kind() == reflect.Pointer && !v2.IsNil() {
+			v2 = v2.Elem()
+		}
 		*changes = append(*changes, Change{Path: path, Old: nil, New: v2.Interface()})
 		return nil
 	} else if !v2.IsValid() {
 		// v1 is valid
+		for v1.Kind() == reflect.Pointer && !v1.IsNil() {
+			v1 = v1.Elem()
+		}
 		*changes = append(*changes, Change{Path: path, Old: v1.Interface(), New: nil})
 		return nil
 	}

libs/structs/structdiff/diff_test.go

@@ -136,7 +136,7 @@ func TestGetStructDiff(t *testing.T) {
 			name: "pointer nil vs value",
 			a:    A{P: b1},
 			b:    A{},
-			want: []ResolvedChange{{Field: "p", Old: b1, New: nil}},
+			want: []ResolvedChange{{Field: "p", Old: B{S: "one"}, New: nil}},
 		},
 		{
 			name: "pointer nested value diff",

libs/structs/structdiff/jobsettings_test.go

@@ -497,7 +497,7 @@ func TestJobDiff(t *testing.T) {
 
 	// continous is completely deleted from jobExampleResponseNils
 	assert.Equal(t, "continuous", changes[1].Path.String())
-	assert.Equal(t, &jobs.Continuous{PauseStatus: "UNPAUSED"}, changes[1].Old)
+	assert.Equal(t, jobs.Continuous{PauseStatus: "UNPAUSED"}, changes[1].Old)
 	assert.Nil(t, changes[1].New)
 
 	// deployment.kind is not omitempty field, so it does not show up as nil here
@@ -516,7 +516,7 @@ func TestJobDiff(t *testing.T) {
 	assert.Equal(t, "", changes[0].Old)
 	assert.Nil(t, changes[0].New)
 	assert.Equal(t, "continuous", changes[1].Path.String())
-	assert.Equal(t, &jobs.Continuous{}, changes[1].Old)
+	assert.Equal(t, jobs.Continuous{}, changes[1].Old)
 	assert.Nil(t, changes[1].New)
 
 	// deployment.kind is "" in both