refactor(grpc): array comparison using json format (#257)

* refactor(grpc): array comparison using json format

* to json value fix

* rm debug prints

Author: Larkooo

crates/sqlite/sqlite/src/lib.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 use dojo_types::primitive::SqlType;
 use dojo_types::schema::Ty;
-use serde_json::json;
 use sqlx::{Pool, Sqlite};
 use starknet::core::types::Felt;
 use tokio::sync::mpsc::UnboundedSender;
@@ -170,24 +169,7 @@ impl Sql {
                         collect_members(&column_name, member, columns, arguments)?;
                     }
                 }
-                Ty::FixedSizeArray((array, size)) => {
-                    columns.push(format!("\"{}\"", prefix));
-                    let elements = array
-                        .iter()
-                        .map(|v| v.to_json_value())
-                        .collect::<Result<Vec<_>, _>>()?;
-
-                    let value = json!({
-                        "elements": elements,
-                        "size": *size
-                    });
-
-                    arguments.push(Argument::String(
-                        serde_json::to_string(&value)
-                            .map_err(|e| Error::Parse(ParseError::FromJsonStr(e)))?,
-                    ));
-                }
-                Ty::Array(array) => {
+                Ty::Array(array) | Ty::FixedSizeArray((array, _)) => {
                     columns.push(format!("\"{}\"", prefix));
                     let values = array
                         .iter()

crates/sqlite/sqlite/src/model.rs

@@ -498,16 +498,19 @@ fn build_composite_clause(
                 fn prepare_comparison(
                     value: &MemberValue,
                     bind_values: &mut Vec<String>,
-                    historical: bool,
+                    json_format: bool,
                 ) -> Result<String, Error> {
                     match value {
                         MemberValue::String(value) => {
                             bind_values.push(value.to_string());
                             Ok("?".to_string())
                         }
                         MemberValue::Primitive(value) => {
-                            let value = if historical {
-                                Ty::Primitive(*value).to_json_value()?.to_string()
+                            let value = if json_format {
+                                Ty::Primitive(*value)
+                                    .to_json_value()?
+                                    .to_string()
+                                    .replace("\"", "")
                             } else {
                                 value.to_sql_value()
                             };
@@ -518,19 +521,33 @@ fn build_composite_clause(
                             "({})",
                             values
                                 .iter()
-                                .map(|v| prepare_comparison(v, bind_values, historical))
+                                .map(|v| prepare_comparison(v, bind_values, json_format))
                                 .collect::<Result<Vec<String>, Error>>()?
                                 .join(", ")
                         )),
                     }
                 }
-                let value = prepare_comparison(&member.value, &mut bind_values, historical)?;
 
                 let model = member.model.clone();
                 let operator = member.operator.clone();
 
+                // Determine if we need JSON formatting for values
+                let array_index = parse_array_index(&member.member);
+                let is_array_operation = matches!(
+                    operator,
+                    ComparisonOperator::Contains
+                        | ComparisonOperator::ContainsAll
+                        | ComparisonOperator::ContainsAny
+                        | ComparisonOperator::ArrayLengthEq
+                        | ComparisonOperator::ArrayLengthGt
+                        | ComparisonOperator::ArrayLengthLt
+                ) || array_index.is_some(); // Array indexing also needs JSON formatting
+
+                let value =
+                    prepare_comparison(&member.value, &mut bind_values, is_array_operation)?;
+
                 // Check if this field has array indexing syntax like "field[0]"
-                if let Some((field_name, index)) = parse_array_index(&member.member) {
+                if let Some((field_name, index)) = array_index {
                     // Handle array element access
                     let column_access = if historical {
                         format!("JSON_EXTRACT({table}.data, '$.{field_name}')")