Add JSON structure validation to DynamicUnmarshal

Introduced a new function, `validateJsonStructure`, to ensure the JSON data matches the schema before dynamic unmarshalling. This addition checks for the presence, type, and structure of fields, and provides detailed error messages for better debugging.

Author: ComputerKeeda

x/trackgate/keeper/utils.go

@@ -46,7 +46,80 @@ func ContainsOperator(operators []string, operator string) bool {
 	return false
 }
 
+func validateJsonStructure(schemaFields map[string]interface{}, jsonData map[string]interface{}) bool {
+	// Ensure every field in schema is present in the JSON
+	for key, fieldType := range schemaFields {
+		if jsonValue, exists := jsonData[key]; exists {
+			switch ft := fieldType.(type) {
+			case string:
+				if !validateFieldType(ft, jsonValue) {
+					fmt.Printf("Field '%s' has mismatched type or invalid value.\n", key)
+					return false
+				}
+			case map[string]interface{}:
+				if nestedJsonData, ok := jsonValue.(map[string]interface{}); ok {
+					if !validateJsonStructure(ft, nestedJsonData) {
+						fmt.Printf("Field '%s' has mismatched structure.\n", key)
+						return false
+					}
+				} else {
+					fmt.Printf("Expected nested structure for '%s', got something else.\n", key)
+					return false
+				}
+			default:
+				fmt.Printf("Unsupported type for '%s'.\n", key)
+				return false
+			}
+		} else {
+			// Error when a required field is missing from JSON data
+			fmt.Printf("Field '%s' is missing from the JSON data.\n", key)
+			return false
+		}
+	}
+
+	// Check for extra fields in the JSON that aren't in the schema
+	for key := range jsonData {
+		if _, exists := schemaFields[key]; !exists {
+			fmt.Printf("Extra field '%s' found in the JSON data but not in the schema.\n", key)
+			return false
+		}
+	}
+
+	return true
+}
+
+// Validate individual field types
+func validateFieldType(fieldType string, value interface{}) bool {
+	switch fieldType {
+	case "string":
+		_, ok := value.(string)
+		return ok
+	case "int":
+		_, ok := value.(float64) // JSON unmarshalling in Go converts numbers to float64
+		return ok
+	case "uint":
+		val, ok := value.(float64)
+		return ok && val >= 0
+	case "bytes":
+		_, ok := value.(string) // Assuming bytes are encoded as base64 strings
+		return ok
+	default:
+		return false
+	}
+}
+
 func DynamicUnmarshal(schemaDef types.SchemaDef, jsonData string) (string, error) {
+	// Temporarily unmarshal JSON into a map to validate structure
+	var tempData map[string]interface{}
+	if err := json.Unmarshal([]byte(jsonData), &tempData); err != nil {
+		return "error", fmt.Errorf("failed to unmarshal JSON for validation: %w", err)
+	}
+
+	// Validate JSON against struct definition
+	if !validateJsonStructure(schemaDef.Fields, tempData) {
+		return "error", fmt.Errorf("JSON data does not match the expected schema")
+	}
+
 	// Function to recursively create fields
 	var createFields func(fields map[string]interface{}) ([]reflect.StructField, error)
 	createFields = func(fields map[string]interface{}) ([]reflect.StructField, error) {
@@ -93,14 +166,15 @@ func DynamicUnmarshal(schemaDef types.SchemaDef, jsonData string) (string, error
 	// Create struct type from fields
 	fields, err := createFields(schemaDef.Fields)
 	if err != nil {
-		return "", err
+		return "error", err
 	}
+
 	structType := reflect.StructOf(fields)
 	structInstance := reflect.New(structType).Elem()
 
 	// Unmarshal JSON into the dynamically created struct
 	if err := json.Unmarshal([]byte(jsonData), structInstance.Addr().Interface()); err != nil {
-		return "", fmt.Errorf("failed to unmarshal JSON: %w", err)
+		return "error", fmt.Errorf("failed to unmarshal JSON: %w", err)
 	}
 
 	// Marshal the struct back to JSON with indentation