From 71868e633984bf4bac512fd97cd4669976b1a5d4 Mon Sep 17 00:00:00 2001
From: Shubhranshu Sanjeev <shubhranshu.sanjeev@juspay.in>
Date: Wed, 4 Dec 2024 13:12:39 +0530
Subject: [PATCH] feat: JsonLogic algebraic representation

---
 crates/frontend/src/components/input.rs |  94 +++++++-
 crates/frontend/src/lib.rs              |   1 +
 crates/frontend/src/logic.rs            | 278 ++++++++++++++++++++++++
 crates/frontend/src/schema.rs           |  19 +-
 4 files changed, 373 insertions(+), 19 deletions(-)
 create mode 100644 crates/frontend/src/logic.rs

diff --git a/crates/frontend/src/components/input.rs b/crates/frontend/src/components/input.rs
index 49a805c9..69edb8ec 100644
--- a/crates/frontend/src/components/input.rs
+++ b/crates/frontend/src/components/input.rs
@@ -12,16 +12,16 @@ use crate::{
     schema::{EnumVariants, HtmlDisplay, JsonSchemaType, SchemaType},
 };
 
+use crate::logic::Operator;
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum InputType {
     Text,
     Number,
     Integer,
-
     Toggle,
     Monaco,
     Select(EnumVariants),
-
     Disabled,
 }
 
@@ -64,7 +64,30 @@ impl From<(SchemaType, EnumVariants)> for InputType {
     }
 }
 
-fn str_to_value(s: &str, type_: &JsonSchemaType) -> Result<Value, String> {
+impl From<(SchemaType, EnumVariants, Operator)> for InputType {
+    fn from(
+        (schema_type, enum_variants, operator): (SchemaType, EnumVariants, Operator),
+    ) -> Self {
+        if operator == Operator::In {
+            return InputType::Text;
+        }
+
+        if !enum_variants.is_empty() {
+            return InputType::Select(enum_variants);
+        }
+
+        match schema_type {
+            SchemaType::Single(JsonSchemaType::Number) => InputType::Number,
+            SchemaType::Single(JsonSchemaType::Integer) => InputType::Integer,
+            SchemaType::Single(JsonSchemaType::Boolean) => InputType::Toggle,
+            SchemaType::Single(JsonSchemaType::Null) => InputType::Disabled,
+            _ => InputType::Text,
+        }
+    }
+}
+
+// TODO: Also add schema validation in frontend :::::
+fn parse(s: &str, type_: &JsonSchemaType) -> Result<Value, String> {
     match type_ {
         JsonSchemaType::String => Ok(Value::String(s.to_string())),
         JsonSchemaType::Number => s
@@ -90,14 +113,55 @@ fn str_to_value(s: &str, type_: &JsonSchemaType) -> Result<Value, String> {
     }
 }
 
-fn parse_input_value(value: String, schema_type: SchemaType) -> Result<Value, String> {
+fn parse_with_operator(
+    s: &str,
+    type_: &JsonSchemaType,
+    op: &Operator,
+) -> Result<Value, String> {
+    match op {
+        Operator::In => match type_ {
+            JsonSchemaType::String => serde_json::from_str::<Vec<String>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of strings".to_string()),
+            JsonSchemaType::Number => serde_json::from_str::<Vec<f64>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of numbers".to_string()),
+            JsonSchemaType::Integer => serde_json::from_str::<Vec<i64>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of integers".to_string()),
+            JsonSchemaType::Boolean => serde_json::from_str::<Vec<bool>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of booleans".to_string()),
+            JsonSchemaType::Array => serde_json::from_str::<Vec<Value>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of arrays".to_string()),
+            JsonSchemaType::Object => serde_json::from_str::<Vec<Map<String, Value>>>(s)
+                .map(|v| json!(v))
+                .map_err(|_| "not a valid array of objects".to_string()),
+            JsonSchemaType::Null if s == "null" => Ok(Value::Null),
+            JsonSchemaType::Null => Err("not a null value".to_string()),
+        },
+        _ => parse(s, type_),
+    }
+}
+
+fn parse_input(
+    value: String,
+    schema_type: SchemaType,
+    op: &Option<Operator>,
+) -> Result<Value, String> {
+    let parse_single = |r#type: &JsonSchemaType| match op {
+        Some(op) => parse_with_operator(&value, r#type, op),
+        None => parse(&value, r#type),
+    };
+
     match schema_type {
-        SchemaType::Single(ref type_) => str_to_value(&value, type_),
+        SchemaType::Single(ref r#type) => parse_single(r#type),
         SchemaType::Multiple(mut types) => {
             types.sort_by(|a, b| a.precedence().cmp(&b.precedence()));
 
-            for type_ in types.iter() {
-                let v = str_to_value(&value, type_);
+            for r#type in types.iter() {
+                let v = parse_single(r#type);
                 if v.is_ok() {
                     return v;
                 }
@@ -183,6 +247,7 @@ fn basic_input(
     value: Value,
     schema_type: SchemaType,
     on_change: Callback<Value, ()>,
+    #[prop(default = None)] operator: Option<Operator>,
 ) -> impl IntoView {
     let schema_type = store_value(schema_type);
     let (error_rs, error_ws) = create_signal::<Option<String>>(None);
@@ -208,7 +273,7 @@ fn basic_input(
                 value=value.html_display()
                 on:change=move |e| {
                     let v = event_target_value(&e);
-                    match parse_input_value(v, schema_type.get_value()) {
+                    match parse_input(v, schema_type.get_value(), &operator) {
                         Ok(v) => {
                             on_change.call(v);
                             error_ws.set(None);
@@ -244,6 +309,7 @@ pub fn monaco_input(
     value: Value,
     on_change: Callback<Value, ()>,
     schema_type: SchemaType,
+    #[prop(default = None)] operator: Option<Operator>,
 ) -> impl IntoView {
     let id = store_value(id);
     let schema_type = store_value(schema_type);
@@ -273,7 +339,7 @@ pub fn monaco_input(
         logging::log!("Saving editor value: {}", editor_value);
 
         let parsed_value =
-            parse_input_value(editor_value.clone(), schema_type.get_value());
+            parse_input(editor_value.clone(), schema_type.get_value(), &operator);
         match parsed_value {
             Ok(v) => {
                 logging::log!("Saving parsed value: {}", editor_value);
@@ -421,24 +487,25 @@ pub fn monaco_input(
 pub fn input(
     value: Value,
     schema_type: SchemaType,
-    on_change: Callback<Value, ()>,
+    #[prop(into)] on_change: Callback<Value, ()>,
     #[prop(into)] r#type: InputType,
     #[prop(default = false)] disabled: bool,
     #[prop(into, default = String::new())] id: String,
     #[prop(into, default = String::new())] class: String,
     #[prop(into, default = String::new())] name: String,
+    #[prop(default = None)] operator: Option<Operator>,
 ) -> impl IntoView {
     match r#type {
         InputType::Toggle => match value.as_bool() {
             Some(ref v) => {
                 view! { <Toggle value=v.clone() on_change class name/> }.into_view()
             }
-            None => view! { <span>An error occured</span> }.into_view(),
+            None => view! { <Toggle value=false on_change class name/> }.into_view(),
         },
         InputType::Select(ref options) => view! { <Select id name class value on_change disabled options=options.0.clone()/> }
         .into_view(),
         InputType::Monaco => {
-            view! { <MonacoInput id class value on_change schema_type/> }.into_view()
+            view! { <MonacoInput id class value on_change schema_type operator/> }.into_view()
         }
         _ => {
             view! {
@@ -452,8 +519,11 @@ pub fn input(
                     value=value
                     schema_type=schema_type
                     on_change=on_change
+                    operator=operator
                 />
             }
         }
     }
 }
+
+
diff --git a/crates/frontend/src/lib.rs b/crates/frontend/src/lib.rs
index 2ee0ca92..66bf2c42 100644
--- a/crates/frontend/src/lib.rs
+++ b/crates/frontend/src/lib.rs
@@ -5,6 +5,7 @@ mod api;
 pub mod app;
 pub mod components;
 pub mod hoc;
+pub mod logic;
 pub mod pages;
 pub mod providers;
 pub mod schema;
diff --git a/crates/frontend/src/logic.rs b/crates/frontend/src/logic.rs
new file mode 100644
index 00000000..10b04a76
--- /dev/null
+++ b/crates/frontend/src/logic.rs
@@ -0,0 +1,278 @@
+use std::fmt::Display;
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Map, Value};
+
+use crate::schema::{HtmlDisplay, SchemaType};
+use derive_more::{Deref, DerefMut};
+use superposition_types::Context;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Operand {
+    Value(serde_json::Value),
+    Dimension(serde_json::Value),
+}
+
+impl Operand {
+    pub fn from_operand_json(value: Value) -> Self {
+        match value {
+            Value::Object(ref o) if o.contains_key("var") => Operand::Dimension(value),
+            v => Operand::Value(v),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deref, DerefMut, Serialize, Deserialize)]
+pub struct Operands(pub Vec<Operand>);
+
+impl FromIterator<Value> for Operands {
+    fn from_iter<T: IntoIterator<Item = Value>>(iter: T) -> Self {
+        Operands(
+            iter.into_iter()
+                .map(Operand::from_operand_json)
+                .collect::<Vec<Operand>>(),
+        )
+    }
+}
+
+impl TryFrom<(&Operator, &str, &SchemaType)> for Operands {
+    type Error = String;
+    fn try_from(
+        (operator, d_name, r#type): (&Operator, &str, &SchemaType),
+    ) -> Result<Self, Self::Error> {
+        match operator {
+            Operator::Is => Ok(Operands(vec![
+                Operand::Dimension(json!({ "var": d_name })),
+                Operand::Value(r#type.default_value()),
+            ])),
+            Operator::In => Ok(Operands(vec![
+                Operand::Dimension(json!({ "var": d_name })),
+                Operand::Value(r#type.default_value()),
+            ])),
+            Operator::Has => Ok(Operands(vec![
+                Operand::Value(r#type.default_value()),
+                Operand::Dimension(json!({ "var": d_name })),
+            ])),
+            Operator::Between => Ok(Operands(vec![
+                Operand::Value(r#type.default_value()),
+                Operand::Dimension(json!({ "var": d_name })),
+                Operand::Value(r#type.default_value()),
+            ])),
+            // TODO fix this as there will be cases of unsupported operators
+            _ => Err(String::from("unsupported operator")),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Operator {
+    Is,
+    In,
+    Has,
+    Between,
+    Other(String),
+}
+
+impl Operator {
+    pub fn from_operator_input(source: String) -> Self {
+        match source.as_str() {
+            "==" => Operator::Is,
+            "<=" => Operator::Between,
+            "in" => Operator::In,
+            "has" => Operator::Has,
+            other => Operator::Other(other.to_string()),
+        }
+    }
+
+    pub fn to_condition_json_operator(self) -> String {
+        match self {
+            Self::Has => "in".to_owned(),
+            Self::Is => "==".to_owned(),
+            Self::In => "in".to_owned(),
+            Self::Between => "<=".to_owned(),
+            Self::Other(o) => o,
+        }
+    }
+}
+
+impl Display for Operator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Has => f.write_str("has"),
+            Self::Is => f.write_str("is"),
+            Self::In => f.write_str("in"),
+            Self::Between => f.write_str("between"),
+            Self::Other(o) => f.write_str(o),
+        }
+    }
+}
+
+impl From<(String, &Operands)> for Operator {
+    fn from((operator, operands): (String, &Operands)) -> Self {
+        let operand_0 = operands.first();
+        let operand_1 = operands.get(1);
+        let operand_2 = operands.get(2);
+        match (operator.as_str(), operand_0, operand_1, operand_2) {
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("==", _, _, None) => Operator::Is,
+            ("<=", Some(_), Some(Operand::Dimension(_)), Some(_)) => Operator::Between,
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("in", Some(Operand::Dimension(_)), Some(_), None) => Operator::In,
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("in", Some(_), Some(Operand::Dimension(_)), None) => Operator::Has,
+            _ => Operator::Other(operator),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Condition {
+    pub dimension: String,
+    pub operator: Operator,
+    pub operands: Operands,
+}
+
+impl Condition {
+    fn try_dimension_name_from_operands(
+        operands: &Operands,
+    ) -> Result<String, &'static str> {
+        for operand in operands.iter() {
+            if let Operand::Dimension(Value::Object(var)) = operand {
+                if let Some(d_val) = var.get("var") {
+                    return d_val
+                        .as_str()
+                        .map(|v| v.to_owned())
+                        .ok_or("Not a valid dimension name string");
+                }
+            }
+        }
+        Err("Dimension doesn't exist in operands list")
+    }
+    fn try_from_condition_map(source: &Map<String, Value>) -> Result<Self, &'static str> {
+        if let Some(operator) = source.keys().next() {
+            let operands = Operands::from_iter(
+                source[operator]
+                    .as_array()
+                    .cloned()
+                    .ok_or("Invalid operands list for context")?,
+            );
+
+            let operator = Operator::from((operator.to_owned(), &operands));
+
+            let dimension_name = Self::try_dimension_name_from_operands(&operands)?;
+
+            return Ok(Condition {
+                operator,
+                dimension: dimension_name,
+                operands: operands.to_owned(),
+            });
+        }
+
+        Err("not a valid condition map")
+    }
+
+    pub fn try_from_condition_json(source: &Value) -> Result<Self, &'static str> {
+        let obj = source
+            .as_object()
+            .ok_or("not a valid condition value, should be an object")?;
+        Condition::try_from_condition_map(obj)
+    }
+
+    pub fn to_condition_json(self) -> Value {
+        let operator = self.operator.to_condition_json_operator();
+
+        let operands = self
+            .operands
+            .iter()
+            .map(|v| match v {
+                Operand::Dimension(d) => d.clone(),
+                Operand::Value(v) => v.clone(),
+            })
+            .collect::<Vec<Value>>();
+
+        json!({ operator: operands })
+    }
+
+    pub fn to_condition_query_str(self) -> String {
+        let operator = self.operator.to_condition_json_operator();
+        let dimension = self.dimension;
+
+        let value = self
+            .operands
+            .iter()
+            .filter_map(|operand| {
+                if let Operand::Value(v) = operand {
+                    return Some(v.to_owned().html_display());
+                }
+                None
+            })
+            .collect::<Vec<String>>()
+            .join(",");
+
+        format!("{}{}{}", dimension, operator, value)
+    }
+}
+
+impl TryFrom<(Operator, String, SchemaType)> for Condition {
+    type Error = String;
+    fn try_from(
+        (operator, d_name, r#type): (Operator, String, SchemaType),
+    ) -> Result<Self, Self::Error> {
+        Ok(Condition {
+            dimension: d_name.clone(),
+            operator: operator.clone(),
+            operands: Operands::try_from((&operator, d_name.as_str(), &r#type))?,
+        })
+    }
+}
+
+#[derive(
+    Clone,
+    Debug,
+    derive_more::Deref,
+    derive_more::DerefMut,
+    Serialize,
+    Deserialize,
+    Default,
+)]
+pub struct Conditions(pub Vec<Condition>);
+
+impl Conditions {
+    pub fn from_context_json(context: &Map<String, Value>) -> Result<Self, &'static str> {
+        Ok(Conditions(match context.get("and") {
+            Some(v) => v
+                .as_array()
+                .ok_or("failed to parse value of and as array")
+                .and_then(|arr| {
+                    arr.iter()
+                        .map(Condition::try_from_condition_json)
+                        .collect::<Result<Vec<Condition>, &'static str>>()
+                })?,
+            None => Condition::try_from_condition_map(&context).map(|v| vec![v])?,
+        }))
+    }
+    pub fn to_context_json(self) -> Value {
+        json!({
+            "and": self.iter().map(|v| Condition::to_condition_json(v.clone())).collect::<Vec<Value>>()
+        })
+    }
+    pub fn to_query_string(self) -> String {
+        self.iter()
+            .map(|condition| condition.clone().to_condition_query_str())
+            .collect::<Vec<String>>()
+            .join("&")
+    }
+}
+
+impl FromIterator<Condition> for Conditions {
+    fn from_iter<T: IntoIterator<Item = Condition>>(iter: T) -> Self {
+        Conditions(iter.into_iter().collect::<Vec<Condition>>())
+    }
+}
+
+impl TryFrom<&Context> for Conditions {
+    type Error = &'static str;
+    fn try_from(context: &Context) -> Result<Self, Self::Error> {
+        Self::from_context_json(&context.condition.as_ref())
+    }
+}
diff --git a/crates/frontend/src/schema.rs b/crates/frontend/src/schema.rs
index 4f29b8ca..2413147e 100644
--- a/crates/frontend/src/schema.rs
+++ b/crates/frontend/src/schema.rs
@@ -1,7 +1,7 @@
 use std::str::FromStr;
 
 use derive_more::{Deref, DerefMut};
-use serde_json::{json, Value};
+use serde_json::{json, Map, Value};
 
 pub trait HtmlDisplay: ToString {
     fn html_display(&self) -> String;
@@ -81,14 +81,18 @@ pub enum SchemaType {
 impl SchemaType {
     pub fn default_value(&self) -> Value {
         match self {
-            SchemaType::Multiple(_) => json!(""),
-            SchemaType::Single(JsonSchemaType::String) => json!(""),
+            SchemaType::Multiple(_) => Value::String(String::default()),
+            SchemaType::Single(JsonSchemaType::String) => {
+                Value::String(String::default())
+            }
             SchemaType::Single(JsonSchemaType::Number) => json!(0),
             SchemaType::Single(JsonSchemaType::Integer) => json!(0),
-            SchemaType::Single(JsonSchemaType::Boolean) => json!(false),
-            SchemaType::Single(JsonSchemaType::Object) => json!({}),
-            SchemaType::Single(JsonSchemaType::Array) => json!([]),
-            SchemaType::Single(JsonSchemaType::Null) => json!("null"),
+            SchemaType::Single(JsonSchemaType::Boolean) => Value::Bool(bool::default()),
+            SchemaType::Single(JsonSchemaType::Object) => Value::Object(Map::new()),
+            SchemaType::Single(JsonSchemaType::Array) => Value::Array(Vec::new()),
+            SchemaType::Single(JsonSchemaType::Null) => {
+                Value::String(String::from("null"))
+            }
         }
     }
     fn parse_from_array(arr: &[Value]) -> Result<Self, String> {
@@ -149,3 +153,4 @@ impl TryFrom<Value> for EnumVariants {
             })
     }
 }
+