fix macros for COUNT(*), update ElasticResponse adding optional SQL and updating results as rows

Author: fupelaqu

core/src/main/scala/app/softnetwork/elastic/client/AggregateApi.scala

@@ -130,59 +130,41 @@ trait SingleValueAggregateApi
       // Execute the search
       search(sqlQuery)
         .flatMap { response =>
-          // Parse the response
-          val parseResult = ElasticResult.fromTry(parseResponse(response))
-
-          parseResult match {
-            // Case 1: Parse successful - process the results
-            case ElasticSuccess(results) =>
-              val aggregationResults = results.flatMap { result =>
-                response.aggregations.map { case (name, aggregation) =>
-                  // Attempt to process each aggregation
-                  val aggregationResult = ElasticResult.attempt {
-                    val value = findAggregation(name, result).orNull match {
-                      case b: Boolean     => BooleanValue(b)
-                      case n: Number      => NumericValue(n)
-                      case s: String      => StringValue(s)
-                      case t: Temporal    => TemporalValue(t)
-                      case m: Map[_, Any] => ObjectValue(m.map(kv => kv._1.toString -> kv._2))
-                      case s: Seq[_] if aggregation.multivalued =>
-                        getAggregateValue(s, aggregation.distinct)
-                      case _ => EmptyValue
-                    }
-
-                    SingleValueAggregateResult(name, aggregation.aggType, value)
-                  }
-
-                  // Convert failures to results with errors
-                  aggregationResult match {
-                    case ElasticSuccess(result) => result
-                    case ElasticFailure(error) =>
-                      SingleValueAggregateResult(
-                        name,
-                        aggregation.aggType,
-                        EmptyValue,
-                        error = Some(s"Failed to process aggregation: ${error.message}")
-                      )
-                  }
-                }.toSeq
+          val results = response.results
+          val aggregationResults = results.flatMap { result =>
+            response.aggregations.map { case (name, aggregation) =>
+              // Attempt to process each aggregation
+              val aggregationResult = ElasticResult.attempt {
+                val value = findAggregation(name, result).orNull match {
+                  case b: Boolean     => BooleanValue(b)
+                  case n: Number      => NumericValue(n)
+                  case s: String      => StringValue(s)
+                  case t: Temporal    => TemporalValue(t)
+                  case m: Map[_, Any] => ObjectValue(m.map(kv => kv._1.toString -> kv._2))
+                  case s: Seq[_] if aggregation.multivalued =>
+                    getAggregateValue(s, aggregation.distinct)
+                  case _ => EmptyValue
+                }
+
+                SingleValueAggregateResult(name, aggregation.aggType, value)
               }
 
-              ElasticResult.success(aggregationResults)
+              // Convert failures to results with errors
+              aggregationResult match {
+                case ElasticSuccess(result) => result
+                case ElasticFailure(error) =>
+                  SingleValueAggregateResult(
+                    name,
+                    aggregation.aggType,
+                    EmptyValue,
+                    error = Some(s"Failed to process aggregation: ${error.message}")
+                  )
+              }
+            }.toSeq
+          }
 
-            // Case 2: Parse failed - returning empty results with errors
-            case ElasticFailure(error) =>
-              val errorResults = response.aggregations.map { case (name, aggregation) =>
-                SingleValueAggregateResult(
-                  name,
-                  aggregation.aggType,
-                  EmptyValue,
-                  error = Some(s"Parse error: ${error.message}")
-                )
-              }.toSeq
+          ElasticResult.success(aggregationResults)
 
-              ElasticResult.success(errorResults)
-          }
         }
         .fold(
           // If search() fails, throw an exception

core/src/main/scala/app/softnetwork/elastic/client/ElasticConversion.scala

@@ -44,11 +44,11 @@ trait ElasticConversion {
     m: Manifest[T],
     formats: Formats
   ): Try[Seq[T]] = {
-    parseResponse(response).map { rows =>
-      rows.map { row =>
+    Try(
+      response.results.map { row =>
         convertTo[T](row)(m, formats)
       }
-    }
+    )
   }
 
   // Formatters for elasticsearch ISO 8601 date/time strings
@@ -60,15 +60,17 @@ trait ElasticConversion {
     * multi-search (msearch/UNION ALL) responses
     */
   def parseResponse(
-    response: ElasticResponse
+    results: String,
+    fieldAliases: Map[String, String],
+    aggregations: Map[String, ClientAggregation]
   ): Try[Seq[Map[String, Any]]] = {
-    val json = mapper.readTree(response.results)
+    val json = mapper.readTree(results)
     // Check if it's a multi-search response (array of responses)
     if (json.isArray) {
-      parseMultiSearchResponse(json, response.fieldAliases, response.aggregations)
+      parseMultiSearchResponse(json, fieldAliases, aggregations)
     } else {
       // Single search response
-      parseSingleSearchResponse(json, response.fieldAliases, response.aggregations)
+      parseSingleSearchResponse(json, fieldAliases, aggregations)
     }
   }