fix: reference type check

Author: harshdoesdev

rayql-engine/src/error.rs

@@ -74,73 +74,12 @@ fn pretty_tokenization_error_message(
 
 pub fn pretty_to_sql_error_message(error: ToSQLError, code: &str) -> String {
     match error {
-        ToSQLError::UnknownReference {
-            entity_name,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Unknown reference: {} at line {}, column {}",
-                entity_name, line_number, column
-            )
-        }
-        ToSQLError::EnumNotFound {
-            enum_name,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Enum not found: {} at line {}, column {}",
-                enum_name, line_number, column
-            )
-        }
-        ToSQLError::ModelNotFound {
-            model_name,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Model not found: {} at line {}, column {}",
-                model_name, line_number, column
-            )
-        }
-        ToSQLError::FieldNotFound {
-            model_name,
-            field_name,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Field '{}' does not exists on model '{}': at line {}, column {}",
-                field_name, model_name, line_number, column
-            )
-        }
-        ToSQLError::VariantNotFound {
-            enum_name,
-            variant,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Variant '{}' does not exists on enum '{}': at line {}, column {}",
-                variant, enum_name, line_number, column
-            )
-        }
-        ToSQLError::ConversionError {
-            reason,
-            line_number,
-            column,
-        } => {
-            format!(
-                "Conversion error: {} at line {}, column {}",
-                reason, line_number, column
-            )
-        }
         ToSQLError::FunctionError {
             source,
             line_number,
             column,
         } => pretty_function_error_message(source, code, line_number, column),
+        e => e.to_string(),
     }
 }
 

rayql-engine/src/sql/error.rs

@@ -7,6 +7,13 @@ pub enum ToSQLError {
         line_number: usize,
         column: usize,
     },
+    IncorrectReference {
+        entity_name: String,
+        variant_name: String,
+        given_entity_name: String,
+        line_number: usize,
+        column: usize,
+    },
     EnumNotFound {
         enum_name: String,
         line_number: usize,
@@ -55,6 +62,19 @@ impl fmt::Display for ToSQLError {
                     entity_name
                 )
             }
+            ToSQLError::IncorrectReference {
+                entity_name,
+                variant_name,
+                given_entity_name,
+                line_number,
+                column,
+            } => {
+                write!(
+                    f,
+                    "Variant '{}' of enum '{}' passed to a function expecting enum '{}' at line {}, column {}",
+                    variant_name, entity_name, given_entity_name, line_number, column
+                )
+            }
             ToSQLError::EnumNotFound {
                 enum_name,
                 line_number,

rayql-engine/src/sql/function.rs

@@ -1,6 +1,7 @@
 use rayql::{
     schema::{ArgumentValue, Arguments, FunctionCallContext, Schema},
     sql::error::{FunctionError, ToSQLError},
+    types::DataType,
 };
 
 use rayql::sql::fn_helpers::{check_value, get_single_argument};
@@ -37,7 +38,15 @@ single_arg_fn!(default(schema, argument, context) {
             Ok(value.to_sql())
         },
         ArgumentValue::FunctionCall(func) => func.to_sql(schema),
-        ArgumentValue::Reference(reference) => reference.variant_reference_to_sql(schema),
+        ArgumentValue::Reference(reference) => {
+            if let DataType::Enum(ref enum_name) = context.property_data_type.data_type {
+                if reference.entity.ne(enum_name) {
+                    return Err(ToSQLError::IncorrectReference { entity_name: reference.entity, variant_name: reference.property, given_entity_name: enum_name.clone(), line_number: reference.line_number, column: reference.column, });
+                }
+            }
+
+            reference.variant_reference_to_sql(schema)
+        },
     )?;
 
     Ok(format!("DEFAULT {}", value))