fix(serialization): use Gson JsonObject for projection field serialization (#676)

Replace manual StringBuilder JSON construction with Gson's JsonObject
in parseDocumentResult() to properly handle string values with spaces
and special characters preventing MalformedJsonException when projected
TEXT fields contained spaces (e.g., "makeup spatula premium").

Changes:
- Use JsonObject.addProperty() which handles quoting and escaping
- Parse numeric values as Double/Long instead of raw strings
- Properly handle already-quoted strings by removing outer quotes

Closes #676

Author: bsbodden

redis-om-spring/src/main/java/com/redis/om/spring/repository/query/RediSearchQuery.java

@@ -36,6 +36,7 @@
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 import com.redis.om.spring.RedisOMProperties;
 import com.redis.om.spring.annotations.*;
 import com.redis.om.spring.indexing.RediSearchIndexer;
@@ -962,35 +963,19 @@ private Object parseDocumentResult(redis.clients.jedis.search.Document doc) {
     } else {
       // Projection case - individual fields returned from Redis search optimization
       // When projection optimization is enabled, Redis returns individual fields instead of full JSON
-      Map<String, Object> fieldMap = new HashMap<>();
+      // Use Gson's JsonObject to properly handle JSON serialization including escaping and quoting
+      JsonObject jsonObject = new JsonObject();
+
       for (Entry<String, Object> entry : doc.getProperties()) {
         String fieldName = entry.getKey();
         Object fieldValue = entry.getValue();
 
+        String valueStr;
         if (fieldValue instanceof byte[]) {
-          // Convert byte array to string - this is the JSON representation from Redis
-          String stringValue = SafeEncoder.encode((byte[]) fieldValue);
-          fieldMap.put(fieldName, stringValue);
+          valueStr = SafeEncoder.encode((byte[]) fieldValue);
         } else {
-          fieldMap.put(fieldName, fieldValue);
-        }
-      }
-
-      // Build JSON manually to handle the different field formats from Redis search
-      StringBuilder jsonBuilder = new StringBuilder();
-      jsonBuilder.append("{");
-      boolean first = true;
-      for (Entry<String, Object> entry : fieldMap.entrySet()) {
-        if (!first) {
-          jsonBuilder.append(",");
+          valueStr = String.valueOf(fieldValue);
         }
-        first = false;
-
-        String fieldName = entry.getKey();
-        Object fieldValue = entry.getValue();
-        String valueStr = (String) fieldValue;
-
-        jsonBuilder.append("\"").append(fieldName).append("\":");
 
         // Check if this field is a Point type in the domain class
         boolean isPointField = false;
@@ -1006,31 +991,34 @@ private Object parseDocumentResult(redis.clients.jedis.search.Document doc) {
         // Handle different types based on the raw value from Redis
         if (isPointField && valueStr.contains(",") && !valueStr.startsWith("\"")) {
           // Point field - stored as "lon,lat" in Redis, needs to be quoted for PointTypeAdapter
-          jsonBuilder.append("\"").append(valueStr).append("\"");
-        } else if (fieldName.equals("name") || (valueStr.startsWith("\"") && valueStr.endsWith("\""))) {
-          // String field - quote if not already quoted
-          if (valueStr.startsWith("\"") && valueStr.endsWith("\"")) {
-            jsonBuilder.append(valueStr);
-          } else {
-            jsonBuilder.append("\"").append(valueStr).append("\"");
-          }
+          jsonObject.addProperty(fieldName, valueStr);
+        } else if (valueStr.startsWith("\"") && valueStr.endsWith("\"")) {
+          // Already quoted string - remove quotes and add as property (Gson will re-quote)
+          jsonObject.addProperty(fieldName, valueStr.substring(1, valueStr.length() - 1));
         } else if (valueStr.equals("true") || valueStr.equals("false")) {
           // Boolean
-          jsonBuilder.append(valueStr);
+          jsonObject.addProperty(fieldName, Boolean.parseBoolean(valueStr));
         } else if (valueStr.equals("1") && fieldName.equals("active")) {
           // Special case for boolean stored as 1/0
-          jsonBuilder.append("true");
+          jsonObject.addProperty(fieldName, true);
         } else if (valueStr.equals("0") && fieldName.equals("active")) {
-          jsonBuilder.append("false");
+          jsonObject.addProperty(fieldName, false);
         } else {
-          // Number or other type - keep as is
-          jsonBuilder.append(valueStr);
+          // Try to parse as number, otherwise treat as string
+          try {
+            if (valueStr.contains(".")) {
+              jsonObject.addProperty(fieldName, Double.parseDouble(valueStr));
+            } else {
+              jsonObject.addProperty(fieldName, Long.parseLong(valueStr));
+            }
+          } catch (NumberFormatException e) {
+            // Not a number - treat as string (Gson will handle proper quoting and escaping)
+            jsonObject.addProperty(fieldName, valueStr);
+          }
         }
       }
-      jsonBuilder.append("}");
 
-      String jsonFromFields = jsonBuilder.toString();
-      entity = gsonInstance.fromJson(jsonFromFields, domainType);
+      entity = gsonInstance.fromJson(jsonObject, domainType);
     }
 
     return ObjectUtils.populateRedisKey(entity, doc.getId());

tests/src/test/java/com/redis/om/spring/annotations/document/QueryProjectionJsonSerializationTest.java

@@ -0,0 +1,74 @@
+package com.redis.om.spring.annotations.document;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.redis.om.spring.AbstractBaseDocumentTest;
+import com.redis.om.spring.fixtures.document.model.ProductDoc;
+import com.redis.om.spring.fixtures.document.repository.ProductDocRepository;
+
+import redis.clients.jedis.search.SearchResult;
+
+/**
+ * Tests for Issue #676: Gson JSON serialization bug with spaces in projected fields.
+ *
+ * When using FT.SEARCH with field projections (returnFields), a JsonSyntaxException
+ * occurs if projected TEXT fields contain values with spaces (e.g., "makeup spatula premium").
+ *
+ * The issue is in RediSearchQuery.parseDocumentResult() which manually constructs JSON
+ * strings via StringBuilder without properly quoting string values.
+ *
+ * @see <a href="https://github.com/redis/redis-om-spring/issues/676">Issue #676</a>
+ */
+class QueryProjectionJsonSerializationTest extends AbstractBaseDocumentTest {
+
+  @Autowired
+  ProductDocRepository productDocRepository;
+
+  @BeforeEach
+  void setup() {
+    productDocRepository.deleteAll();
+
+    // Create products with multi-word keywords (spaces in the value)
+    productDocRepository.save(ProductDoc.of("makeup spatula premium", "beauty", 19.99));
+    productDocRepository.save(ProductDoc.of("kitchen knife set", "kitchen", 49.99));
+    productDocRepository.save(ProductDoc.of("wireless bluetooth headphones", "electronics", 89.99));
+    productDocRepository.save(ProductDoc.of("organic green tea", "food", 12.99));
+    productDocRepository.save(ProductDoc.of("simple", "beauty", 9.99)); // single word for comparison
+  }
+
+  /**
+   * Test that projected fields with spaces are correctly serialized.
+   * This test would fail before the fix with a JsonSyntaxException because
+   * the manual JSON construction didn't quote string values properly.
+   */
+  @Test
+  void testProjectedFieldsWithSpacesDoNotCauseJsonSyntaxException() {
+    // First verify data was saved
+    assertThat(productDocRepository.count()).isEqualTo(5);
+
+    // This query returns projected fields (keyword, category) as domain objects
+    // The keyword field contains spaces which should be properly quoted in JSON
+    List<ProductDoc> products = productDocRepository.findByCategoryWithProjection("beauty");
+
+    assertThat(products).hasSize(2);
+    assertThat(products).extracting("keyword")
+        .containsExactlyInAnyOrder("makeup spatula premium", "simple");
+    assertThat(products).extracting("category")
+        .containsOnly("beauty");
+  }
+
+  /**
+   * Test that the raw SearchResult query works (baseline).
+   */
+  @Test
+  void testSearchResultQueryWorks() {
+    SearchResult result = productDocRepository.findByCategoryReturningSearchResult("beauty");
+    assertThat(result.getTotalResults()).isEqualTo(2);
+  }
+}

tests/src/test/java/com/redis/om/spring/fixtures/document/model/ProductDoc.java

@@ -0,0 +1,34 @@
+package com.redis.om.spring.fixtures.document.model;
+
+import org.springframework.data.annotation.Id;
+
+import com.redis.om.spring.annotations.Document;
+import com.redis.om.spring.annotations.Indexed;
+import com.redis.om.spring.annotations.Searchable;
+
+import lombok.*;
+
+/**
+ * Model for testing Issue #676: Gson JSON serialization bug with spaces in projected fields.
+ */
+@Data
+@RequiredArgsConstructor(staticName = "of")
+@AllArgsConstructor(access = AccessLevel.PROTECTED)
+@NoArgsConstructor(force = true)
+@Document("productdoc")
+public class ProductDoc {
+  @Id
+  private String id;
+
+  @NonNull
+  @Searchable
+  private String keyword;
+
+  @NonNull
+  @Indexed
+  private String category;
+
+  @NonNull
+  @Indexed
+  private Double price;
+}

tests/src/test/java/com/redis/om/spring/fixtures/document/repository/ProductDocRepository.java

@@ -0,0 +1,30 @@
+package com.redis.om.spring.fixtures.document.repository;
+
+import java.util.List;
+
+import org.springframework.data.repository.query.Param;
+
+import com.redis.om.spring.annotations.Query;
+import com.redis.om.spring.fixtures.document.model.ProductDoc;
+import com.redis.om.spring.repository.RedisDocumentRepository;
+
+import redis.clients.jedis.search.SearchResult;
+
+/**
+ * Repository for testing Issue #676: Gson JSON serialization bug with spaces in projected fields.
+ */
+public interface ProductDocRepository extends RedisDocumentRepository<ProductDoc, String> {
+
+  /**
+   * Query that returns projected fields (keyword, category) as domain objects.
+   * This triggers the parseDocumentResult projection logic path.
+   */
+  @Query(value = "@category:{$category}", returnFields = {"keyword", "category"})
+  List<ProductDoc> findByCategoryWithProjection(@Param("category") String category);
+
+  /**
+   * Baseline query returning SearchResult to verify search works.
+   */
+  @Query(value = "@category:{$category}", returnFields = {"keyword", "category"})
+  SearchResult findByCategoryReturningSearchResult(@Param("category") String category);
+}