fix: handle null values properly in trigger payload construction

- Fix getValueByKey to return raw 'null' for null JSON values
- Prevent invalid JSON generation when null values are present
- Add comprehensive tests for null value handling

Fixes #3719

Signed-off-by: puretension <[email protected]>

Author: puretension

pkg/reconciler/sensor/validate.go

@@ -256,7 +256,7 @@ func validateHTTPTrigger(trigger *v1alpha1.HTTPTrigger) error {
 	}
 	if trigger.Payload != nil {
 		for i, p := range trigger.Payload {
-			if err := validateTriggerParameter(&p); err != nil {
+			if err := validateTriggerParameterForHTTP(&p); err != nil {
 				return fmt.Errorf("payload index: %d. err: %w", i, err)
 			}
 		}
@@ -480,6 +480,28 @@ func validateTriggerParameter(parameter *v1alpha1.TriggerParameter) error {
 	return nil
 }
 
+// validateTriggerParameterForHTTP validates a trigger parameter specifically for HTTP triggers
+func validateTriggerParameterForHTTP(parameter *v1alpha1.TriggerParameter) error {
+	if parameter.Src == nil {
+		return fmt.Errorf("parameter source can't be empty")
+	}
+	if parameter.Src.DependencyName == "" {
+		return fmt.Errorf("parameter dependency name can't be empty")
+	}
+	// For HTTP triggers, allow empty dest to pass the entire payload
+
+	switch op := parameter.Operation; op {
+	case v1alpha1.TriggerParameterOpAppend:
+	case v1alpha1.TriggerParameterOpOverwrite:
+	case v1alpha1.TriggerParameterOpPrepend:
+	case v1alpha1.TriggerParameterOpNone:
+	default:
+		return fmt.Errorf("parameter operation %+v is invalid", op)
+	}
+
+	return nil
+}
+
 // perform a check to see that each event dependency is in correct format and has valid filters set if any
 func validateDependencies(eventDependencies []v1alpha1.EventDependency, b *v1alpha1.EventBus) error {
 	if len(eventDependencies) < 1 {

pkg/reconciler/sensor/validate_empty_dest_test.go

@@ -0,0 +1,65 @@
+package sensor
+
+import (
+	"testing"
+
+	"github.com/argoproj/argo-events/pkg/apis/events/v1alpha1"
+	"github.com/argoproj/argo-events/pkg/sensors/triggers"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestHTTPTriggerWithEmptyDest(t *testing.T) {
+	// Test HTTP trigger validation with empty dest
+	httpTrigger := &v1alpha1.HTTPTrigger{
+		URL:    "http://example.com",
+		Method: "POST",
+		Payload: []v1alpha1.TriggerParameter{
+			{
+				Src: &v1alpha1.TriggerParameterSource{
+					DependencyName: "test-dep",
+					UseRawData:     true,
+				},
+				Dest: "", // Empty dest - this should now be allowed for HTTP triggers
+			},
+		},
+	}
+
+	// Test validation - should pass
+	err := validateHTTPTrigger(httpTrigger)
+	assert.NoError(t, err, "HTTP trigger validation should pass with empty dest")
+
+	// Test ConstructPayload with empty dest
+	events := map[string]*v1alpha1.Event{
+		"test-dep": {
+			Context: &v1alpha1.EventContext{
+				Type:            "test",
+				Source:          "test",
+				DataContentType: "application/json",
+			},
+			Data: []byte(`{"message": "hello world"}`),
+		},
+	}
+
+	payload, err := triggers.ConstructPayload(events, httpTrigger.Payload)
+	assert.NoError(t, err, "ConstructPayload should succeed with empty dest")
+
+	// For empty dest with UseRawData, we expect the entire event object as JSON
+	assert.NotEmpty(t, payload, "Payload should not be empty")
+	assert.Contains(t, string(payload), "context", "Payload should contain event context")
+	assert.Contains(t, string(payload), "data", "Payload should contain event data")
+}
+
+func TestNonHTTPTriggerWithEmptyDestShouldFail(t *testing.T) {
+	// Test that non-HTTP triggers still require dest
+	parameter := &v1alpha1.TriggerParameter{
+		Src: &v1alpha1.TriggerParameterSource{
+			DependencyName: "test-dep",
+			DataKey:        "body",
+		},
+		Dest: "", // Empty dest - this should fail for non-HTTP triggers
+	}
+
+	err := validateTriggerParameter(parameter)
+	assert.Error(t, err, "Non-HTTP trigger parameter validation should fail with empty dest")
+	assert.Contains(t, err.Error(), "parameter destination can't be empty")
+}

pkg/sensors/triggers/params.go

@@ -45,6 +45,15 @@ func ConstructPayload(events map[string]*v1alpha1.Event, parameters []v1alpha1.T
 		if err != nil {
 			return nil, err
 		}
+		
+		// If dest is empty, return the raw value as the entire payload
+		if parameter.Dest == "" {
+			if value != nil {
+				return []byte(*value), nil
+			}
+			continue
+		}
+		
 		if typ != stringType && parameter.Src.UseRawData {
 			tmp, err := sjson.SetRawBytes(payload, parameter.Dest, []byte(*value))
 			if err != nil {
@@ -300,6 +309,10 @@ func getValueByKey(value []byte, key string) (string, string, error) {
 		if res.Type.String() == jsonType {
 			return res.Raw, res.Type.String(), nil
 		}
+		// Handle null values properly by returning raw JSON "null"
+		if res.Type == gjson.Null {
+			return res.Raw, res.Type.String(), nil
+		}
 		return res.String(), res.Type.String(), nil
 	}
 	return "", "", fmt.Errorf("key %s does not exist to in the event payload", key)

pkg/sensors/triggers/params_test.go

@@ -617,3 +617,62 @@ func TestApplyTemplateParameters(t *testing.T) {
 	err := ApplyTemplateParameters(testEvents, &obj.Spec.Triggers[0])
 	assert.Nil(t, err)
 }
+func TestGetValueByKey_NullValue(t *testing.T) {
+	jsonData := []byte(`{"nullable_key": null, "string_key": "value"}`)
+	
+	// Test null value
+	result, typ, err := getValueByKey(jsonData, "nullable_key")
+	assert.NoError(t, err)
+	assert.Equal(t, "null", result)
+	assert.Equal(t, "Null", typ)
+	
+	// Test string value for comparison
+	result, typ, err = getValueByKey(jsonData, "string_key")
+	assert.NoError(t, err)
+	assert.Equal(t, "value", result)
+	assert.Equal(t, "String", typ)
+}
+
+func TestConstructPayload_NullValue(t *testing.T) {
+	events := map[string]*v1alpha1.Event{
+		"test-dep": {
+			Data: []byte(`{"nullable_key": null, "other_key": "value"}`),
+			Context: &v1alpha1.EventContext{
+				DataContentType: v1alpha1.MediaTypeJSON,
+			},
+		},
+	}
+	
+	parameters := []v1alpha1.TriggerParameter{
+		{
+			Src: &v1alpha1.TriggerParameterSource{
+				DependencyName: "test-dep",
+				DataKey:        "nullable_key",
+				UseRawData:     true,
+			},
+			Dest: "nullable_key",
+		},
+		{
+			Src: &v1alpha1.TriggerParameterSource{
+				DependencyName: "test-dep",
+				DataKey:        "other_key",
+			},
+			Dest: "other_key",
+		},
+	}
+	
+	payload, err := ConstructPayload(events, parameters)
+	assert.NoError(t, err)
+	
+	// Verify the payload is valid JSON
+	var result map[string]interface{}
+	err = json.Unmarshal(payload, &result)
+	assert.NoError(t, err)
+	
+	// Verify null value is preserved
+	assert.Nil(t, result["nullable_key"])
+	assert.Equal(t, "value", result["other_key"])
+	
+	// Verify the raw JSON contains "null" not empty
+	assert.Contains(t, string(payload), `"nullable_key":null`)
+}