Optimize EntityColumnId

Author: tyt2y3

src/builder_context/entity_column_id.rs

@@ -1,11 +1,12 @@
 use sea_orm::{EntityName, EntityTrait, IdenStatic};
+use std::borrow::Cow;
 
 use crate::BuilderContext;
 
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct EntityColumnId {
-    entity_name: String,
-    column_name: String,
+    entity_name: Cow<'static, str>,
+    column_name: Cow<'static, str>,
 }
 
 impl EntityColumnId {
@@ -14,15 +15,15 @@ impl EntityColumnId {
         T: EntityTrait,
     {
         EntityColumnId {
-            entity_name: <T as EntityName>::table_name(&T::default()).into(),
-            column_name: column.as_str().into(),
+            entity_name: Cow::Borrowed(<T as EntityName>::table_name(&T::default())),
+            column_name: Cow::Borrowed(column.as_str()),
         }
     }
 
     pub fn with_array(&self) -> Self {
         Self {
             entity_name: self.entity_name.clone(),
-            column_name: format!("{}.array", self.column_name),
+            column_name: Cow::Owned(format!("{}.array", self.column_name)),
         }
     }
 
@@ -35,3 +36,9 @@ impl EntityColumnId {
         context.entity_object.column_name.as_ref()(&entity_name, &self.column_name)
     }
 }
+
+impl std::fmt::Display for EntityColumnId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(f, "{}.{}", self.entity_name, self.column_name)
+    }
+}

src/builder_context/filter_types_map.rs

@@ -4,8 +4,8 @@ use async_graphql::dynamic::{InputObject, InputValue, ObjectAccessor, TypeRef};
 use sea_orm::{ColumnTrait, ColumnType, Condition, EntityTrait, ExprTrait};
 
 use crate::{
-    prepare_enumeration_condition, ActiveEnumFilterInputBuilder, BuilderContext,
-    EntityObjectBuilder, SeaResult, TypesMapConfig, TypesMapHelper,
+    prepare_enumeration_condition, ActiveEnumFilterInputBuilder, BuilderContext, EntityColumnId,
+    EntityObjectBuilder, SeaResult, SeaographyError, TypesMapConfig, TypesMapHelper,
 };
 
 type FnFilterCondition =
@@ -14,9 +14,9 @@ type FnFilterCondition =
 /// The configuration for FilterTypesMapHelper
 pub struct FilterTypesMapConfig {
     /// used to map entity_name.column_name to a custom filter type
-    pub overwrites: BTreeMap<String, Option<FilterType>>,
+    pub overwrites: BTreeMap<EntityColumnId, Option<FilterType>>,
     /// used to map entity_name.column_name to a custom condition function
-    pub condition_functions: BTreeMap<String, FnFilterCondition>,
+    pub condition_functions: BTreeMap<EntityColumnId, FnFilterCondition>,
 
     // basic filters
     pub string_filter_info: FilterInfo,
@@ -235,20 +235,9 @@ impl FilterTypesMapHelper {
     where
         T: EntityTrait,
     {
-        let entity_object_builder = EntityObjectBuilder {
-            context: self.context,
-        };
-
-        let entity_name = entity_object_builder.type_name::<T>();
-        let column_name = entity_object_builder.column_name::<T>(column);
+        let entity_column_id = EntityColumnId::of::<T>(column);
 
-        // used to honor overwrites
-        if let Some(ty) = self
-            .context
-            .filter_types
-            .overwrites
-            .get(&format!("{entity_name}.{column_name}"))
-        {
+        if let Some(ty) = self.context.filter_types.overwrites.get(&entity_column_id) {
             return ty.clone();
         }
 
@@ -572,23 +561,19 @@ impl FilterTypesMapHelper {
                     return prepare_enumeration_condition::<T>(filter, column, condition)
                 }
                 FilterType::Custom(_) => {
-                    let entity_object_builder = EntityObjectBuilder {
-                        context: self.context,
-                    };
-
-                    let entity_name = entity_object_builder.type_name::<T>();
-                    let column_name = entity_object_builder.column_name::<T>(column);
+                    let entity_column_id = EntityColumnId::of::<T>(column);
 
                     if let Some(filter_condition_fn) = self
                         .context
                         .filter_types
                         .condition_functions
-                        .get(&format!("{entity_name}.{column_name}"))
+                        .get(&entity_column_id)
                     {
                         return filter_condition_fn(condition, filter);
                     } else {
-                        // FIXME: add log warning to console
-                        return Ok(condition);
+                        return Err(SeaographyError::CustomFilterError(
+                            entity_column_id.to_string(),
+                        ));
                     }
                 }
                 FilterType::Array(Some(filter_type)) => match *filter_type {

src/error.rs

@@ -12,6 +12,8 @@ pub enum SeaographyError {
     TypeConversionError(String, String),
     #[error("[array conversion] postgres array can not be nested type of array")]
     NestedArrayConversionError,
+    #[error("[custom filter] {0}")]
+    CustomFilterError(String),
     #[error("[async_graphql] {0:?}")]
     UploadError(async_graphql::InputValueError<async_graphql::Upload>),
 }