refactor: refactor graphql

apps/recorder/src/graphql/domains/credential_3rd.rs

@@ -63,7 +63,9 @@ impl Credential3rdCheckAvailableInfo {
     }
 }
 
-pub fn register_credential3rd_to_schema(mut builder: SeaographyBuilder) -> SeaographyBuilder {
+pub fn register_credential3rd_to_schema_builder(
+    mut builder: SeaographyBuilder,
+) -> SeaographyBuilder {
     builder.schema = builder
         .schema
         .register(Credential3rdCheckAvailableInput::generate_input_object());

apps/recorder/src/graphql/domains/crypto.rs

@@ -0,0 +1,102 @@
+use std::sync::Arc;
+
+use async_graphql::dynamic::ValueAccessor;
+use sea_orm::{EntityTrait, Value as SeaValue};
+use seaography::{BuilderContext, SeaResult};
+
+use crate::{
+    app::AppContextTrait,
+    graphql::infra::util::{get_column_key, get_entity_key},
+    models::credential_3rd,
+};
+
+fn register_crypto_column_input_conversion_to_schema_context<T>(
+    context: &mut BuilderContext,
+    ctx: Arc<dyn AppContextTrait>,
+    column: &T::Column,
+) where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let entity_key = get_entity_key::<T>(context);
+    let column_name = get_column_key::<T>(context, column);
+    let entity_name = context.entity_object.type_name.as_ref()(&entity_key);
+    let column_name = context.entity_object.column_name.as_ref()(&entity_key, &column_name);
+
+    context.types.input_conversions.insert(
+        format!("{entity_name}.{column_name}"),
+        Box::new(move |value: &ValueAccessor| -> SeaResult<sea_orm::Value> {
+            let source = value.string()?;
+            let encrypted = ctx.crypto().encrypt_string(source.into())?;
+            Ok(encrypted.into())
+        }),
+    );
+}
+
+fn register_crypto_column_output_conversion_to_schema_context<T>(
+    context: &mut BuilderContext,
+    ctx: Arc<dyn AppContextTrait>,
+    column: &T::Column,
+) where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let entity_key = get_entity_key::<T>(context);
+    let column_name = get_column_key::<T>(context, column);
+    let entity_name = context.entity_object.type_name.as_ref()(&entity_key);
+    let column_name = context.entity_object.column_name.as_ref()(&entity_key, &column_name);
+
+    context.types.output_conversions.insert(
+        format!("{entity_name}.{column_name}"),
+        Box::new(
+            move |value: &sea_orm::Value| -> SeaResult<async_graphql::Value> {
+                if let SeaValue::String(s) = value {
+                    if let Some(s) = s {
+                        let decrypted = ctx.crypto().decrypt_string(s)?;
+                        Ok(async_graphql::Value::String(decrypted))
+                    } else {
+                        Ok(async_graphql::Value::Null)
+                    }
+                } else {
+                    Err(async_graphql::Error::new("crypto column must be string column").into())
+                }
+            },
+        ),
+    );
+}
+
+pub fn register_crypto_to_schema_context(
+    context: &mut BuilderContext,
+    ctx: Arc<dyn AppContextTrait>,
+) {
+    register_crypto_column_input_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx.clone(),
+        &credential_3rd::Column::Cookies,
+    );
+    register_crypto_column_input_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx.clone(),
+        &credential_3rd::Column::Username,
+    );
+    register_crypto_column_input_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx.clone(),
+        &credential_3rd::Column::Password,
+    );
+    register_crypto_column_output_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx.clone(),
+        &credential_3rd::Column::Cookies,
+    );
+    register_crypto_column_output_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx.clone(),
+        &credential_3rd::Column::Username,
+    );
+    register_crypto_column_output_conversion_to_schema_context::<credential_3rd::Entity>(
+        context,
+        ctx,
+        &credential_3rd::Column::Password,
+    );
+}

apps/recorder/src/graphql/domains/mod.rs

@@ -0,0 +1,5 @@
+pub mod credential_3rd;
+pub mod crypto;
+pub mod subscriber_tasks;
+pub mod subscribers;
+pub mod subscriptions;

apps/recorder/src/graphql/domains/subscriber_tasks.rs

@@ -0,0 +1,42 @@
+use async_graphql::dynamic::Scalar;
+use seaography::{Builder as SeaographyBuilder, BuilderContext, ConvertedType};
+
+use crate::{
+    graphql::infra::{
+        json::restrict_jsonb_filter_input_for_entity,
+        util::{get_column_key, get_entity_key},
+    },
+    models::subscriber_tasks::{self, SubscriberTask},
+};
+
+pub fn register_subscriber_tasks_to_schema_context(context: &mut BuilderContext) {
+    let entity_key = get_entity_key::<subscriber_tasks::Entity>(context);
+    let column_name =
+        get_column_key::<subscriber_tasks::Entity>(context, &subscriber_tasks::Column::Job);
+    let column_name = context.entity_object.column_name.as_ref()(&entity_key, &column_name);
+    context.types.overwrites.insert(
+        column_name,
+        ConvertedType::Custom(String::from("SubscriberTask")),
+    );
+    restrict_jsonb_filter_input_for_entity::<subscriber_tasks::Entity>(
+        context,
+        &subscriber_tasks::Column::Job,
+    );
+}
+
+pub fn register_subscriber_tasks_to_schema_builder(
+    mut builder: SeaographyBuilder,
+) -> SeaographyBuilder {
+    let subscriber_tasks_scalar = Scalar::new("SubscriberTasks")
+        .description("The subscriber tasks")
+        .validator(|value| -> bool {
+            if let Ok(json) = value.clone().into_json() {
+                serde_json::from_value::<SubscriberTask>(json).is_ok()
+            } else {
+                false
+            }
+        });
+
+    builder.schema = builder.schema.register(subscriber_tasks_scalar);
+    builder
+}

apps/recorder/src/graphql/domains/subscribers/filter.rs

@@ -1,16 +1,20 @@
-use async_graphql::dynamic::ObjectAccessor;
-use once_cell::sync::OnceCell;
-use sea_orm::{ColumnTrait, Condition, EntityTrait};
-use seaography::{
-    BuilderContext, FilterInfo, FilterOperation as SeaographqlFilterOperation, SeaResult,
-};
+use async_graphql::dynamic::TypeRef;
+use lazy_static::lazy_static;
+use maplit::btreeset;
+use sea_orm::{ColumnTrait, EntityTrait};
+use seaography::{BuilderContext, FilterInfo, FilterOperation as SeaographqlFilterOperation};
 
-pub static SUBSCRIBER_ID_FILTER_INFO: OnceCell<FilterInfo> = OnceCell::new();
+use crate::graphql::infra::filter::FnFilterCondition;
 
-pub type FnFilterCondition =
-    Box<dyn Fn(Condition, &ObjectAccessor) -> SeaResult<Condition> + Send + Sync>;
+lazy_static! {
+    pub static ref SUBSCRIBER_ID_FILTER_INFO: FilterInfo = FilterInfo {
+        type_name: String::from("SubscriberIdFilterInput"),
+        base_type: TypeRef::INT.into(),
+        supported_operations: btreeset! { SeaographqlFilterOperation::Equals },
+    };
+}
 
-pub fn subscriber_id_condition_function<T>(
+pub fn generate_subscriber_id_condition_function<T>(
     _context: &BuilderContext,
     column: &T::Column,
 ) -> FnFilterCondition
@@ -20,9 +24,7 @@ where
 {
     let column = *column;
     Box::new(move |mut condition, filter| {
-        let subscriber_id_filter_info = SUBSCRIBER_ID_FILTER_INFO.get().unwrap();
-        let operations = &subscriber_id_filter_info.supported_operations;
-        for operation in operations {
+        for operation in &SUBSCRIBER_ID_FILTER_INFO.supported_operations {
             match operation {
                 SeaographqlFilterOperation::Equals => {
                     if let Some(value) = filter.get("eq") {

apps/recorder/src/graphql/domains/subscribers/mod.rs

@@ -0,0 +1,94 @@
+use sea_orm::{EntityTrait, Iterable};
+use seaography::{Builder as SeaographyBuilder, BuilderContext, FilterType, FilterTypesMapHelper};
+
+mod filter;
+mod guard;
+mod transformer;
+
+use filter::{SUBSCRIBER_ID_FILTER_INFO, generate_subscriber_id_condition_function};
+use guard::{guard_entity_with_subscriber_id, guard_field_with_subscriber_id};
+use transformer::{
+    generate_subscriber_id_filter_condition_transformer,
+    generate_subscriber_id_mutation_input_object_transformer,
+};
+
+use crate::{
+    graphql::infra::util::{get_entity_column_key, get_entity_key},
+    models::subscribers,
+};
+
+pub fn restrict_subscriber_for_entity<T>(context: &mut BuilderContext, column: &T::Column)
+where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let entity_key = get_entity_key::<T>(context);
+    let entity_column_key = get_entity_column_key::<T>(context, column);
+    context.guards.entity_guards.insert(
+        entity_key.clone(),
+        guard_entity_with_subscriber_id::<T>(context, column),
+    );
+    context.guards.field_guards.insert(
+        entity_column_key.clone(),
+        guard_field_with_subscriber_id::<T>(context, column),
+    );
+    context.filter_types.overwrites.insert(
+        entity_column_key.clone(),
+        Some(FilterType::Custom(
+            SUBSCRIBER_ID_FILTER_INFO.type_name.clone(),
+        )),
+    );
+    context.filter_types.condition_functions.insert(
+        entity_column_key.clone(),
+        generate_subscriber_id_condition_function::<T>(context, column),
+    );
+    context.transformers.filter_conditions_transformers.insert(
+        entity_key.clone(),
+        generate_subscriber_id_filter_condition_transformer::<T>(context, column),
+    );
+    context
+        .transformers
+        .mutation_input_object_transformers
+        .insert(
+            entity_key,
+            generate_subscriber_id_mutation_input_object_transformer::<T>(context, column),
+        );
+    context
+        .entity_input
+        .insert_skips
+        .push(entity_column_key.clone());
+    context.entity_input.update_skips.push(entity_column_key);
+}
+
+pub fn register_subscribers_to_schema_context(context: &mut BuilderContext) {
+    for column in subscribers::Column::iter() {
+        if !matches!(column, subscribers::Column::Id) {
+            let key = get_entity_column_key::<subscribers::Entity>(context, &column);
+            context.filter_types.overwrites.insert(key, None);
+        }
+    }
+}
+
+pub fn register_subscribers_to_schema_builder(mut builder: SeaographyBuilder) -> SeaographyBuilder {
+    {
+        let filter_types_map_helper = FilterTypesMapHelper {
+            context: builder.context,
+        };
+
+        builder.schema = builder
+            .schema
+            .register(filter_types_map_helper.generate_filter_input(&SUBSCRIBER_ID_FILTER_INFO));
+    }
+
+    {
+        builder.register_entity::<subscribers::Entity>(
+            <subscribers::RelatedEntity as sea_orm::Iterable>::iter()
+                .map(|rel| seaography::RelationBuilder::get_relation(&rel, builder.context))
+                .collect(),
+        );
+        builder = builder.register_entity_dataloader_one_to_one(subscribers::Entity, tokio::spawn);
+        builder = builder.register_entity_dataloader_one_to_many(subscribers::Entity, tokio::spawn);
+    }
+
+    builder
+}

apps/recorder/src/graphql/domains/subscribers/transformer.rs

@@ -0,0 +1,85 @@
+use std::{collections::BTreeMap, sync::Arc};
+
+use async_graphql::dynamic::ResolverContext;
+use sea_orm::{ColumnTrait, Condition, EntityTrait, Value as SeaValue};
+use seaography::{BuilderContext, FnFilterConditionsTransformer, FnMutationInputObjectTransformer};
+
+use crate::{
+    auth::AuthUserInfo,
+    graphql::infra::util::{get_column_key, get_entity_key},
+};
+
+pub fn generate_subscriber_id_filter_condition_transformer<T>(
+    _context: &BuilderContext,
+    column: &T::Column,
+) -> FnFilterConditionsTransformer
+where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let column = *column;
+    Box::new(
+        move |context: &ResolverContext, condition: Condition| -> Condition {
+            match context.ctx.data::<AuthUserInfo>() {
+                Ok(user_info) => {
+                    let subscriber_id = user_info.subscriber_auth.subscriber_id;
+                    condition.add(column.eq(subscriber_id))
+                }
+                Err(err) => unreachable!("auth user info must be guarded: {:?}", err),
+            }
+        },
+    )
+}
+
+pub fn generate_subscriber_id_mutation_input_object_transformer<T>(
+    context: &BuilderContext,
+    column: &T::Column,
+) -> FnMutationInputObjectTransformer
+where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let entity_key = get_entity_key::<T>(context);
+    let entity_name = context.entity_query_field.type_name.as_ref()(&entity_key);
+    let column_key = get_column_key::<T>(context, column);
+    let column_name = Arc::new(context.entity_object.column_name.as_ref()(
+        &entity_key,
+        &column_key,
+    ));
+    let entity_create_one_mutation_field_name = Arc::new(format!(
+        "{}{}",
+        entity_name, context.entity_create_one_mutation.mutation_suffix
+    ));
+    let entity_create_batch_mutation_field_name = Arc::new(format!(
+        "{}{}",
+        entity_name,
+        context.entity_create_batch_mutation.mutation_suffix.clone()
+    ));
+    Box::new(
+        move |context: &ResolverContext,
+              mut input: BTreeMap<String, SeaValue>|
+              -> BTreeMap<String, SeaValue> {
+            let field_name = context.field().name();
+            if field_name == entity_create_one_mutation_field_name.as_str()
+                || field_name == entity_create_batch_mutation_field_name.as_str()
+            {
+                match context.ctx.data::<AuthUserInfo>() {
+                    Ok(user_info) => {
+                        let subscriber_id = user_info.subscriber_auth.subscriber_id;
+                        let value = input.get_mut(column_name.as_str());
+                        if value.is_none() {
+                            input.insert(
+                                column_name.as_str().to_string(),
+                                SeaValue::Int(Some(subscriber_id)),
+                            );
+                        }
+                        input
+                    }
+                    Err(err) => unreachable!("auth user info must be guarded: {:?}", err),
+                }
+            } else {
+                input
+            }
+        },
+    )
+}

apps/recorder/src/graphql/domains/subscriptions.rs

@@ -66,7 +66,9 @@ impl SyncOneSubscriptionInfo {
     }
 }
 
-pub fn register_subscriptions_to_schema(mut builder: SeaographyBuilder) -> SeaographyBuilder {
+pub fn register_subscriptions_to_schema_builder(
+    mut builder: SeaographyBuilder,
+) -> SeaographyBuilder {
     builder.schema = builder
         .schema
         .register(SyncOneSubscriptionFilterInput::generate_input_object());

apps/recorder/src/graphql/infra/filter.rs

@@ -0,0 +1,6 @@
+use async_graphql::dynamic::ObjectAccessor;
+use sea_orm::Condition;
+use seaography::SeaResult;
+
+pub type FnFilterCondition =
+    Box<dyn Fn(Condition, &ObjectAccessor) -> SeaResult<Condition> + Send + Sync>;

apps/recorder/src/graphql/infra/filter/mod.rs

@@ -1,19 +0,0 @@
-mod json;
-mod subscriber;
-
-use async_graphql::dynamic::TypeRef;
-pub use json::{
-    JSONB_FILTER_NAME, jsonb_filter_condition_function,
-    register_jsonb_input_filter_to_dynamic_schema,
-};
-use maplit::btreeset;
-use seaography::{FilterInfo, FilterOperation as SeaographqlFilterOperation};
-pub use subscriber::{SUBSCRIBER_ID_FILTER_INFO, subscriber_id_condition_function};
-
-pub fn init_custom_filter_info() {
-    SUBSCRIBER_ID_FILTER_INFO.get_or_init(|| FilterInfo {
-        type_name: String::from("SubscriberIdFilterInput"),
-        base_type: TypeRef::INT.into(),
-        supported_operations: btreeset! { SeaographqlFilterOperation::Equals },
-    });
-}

apps/recorder/src/graphql/infra/json.rs

@@ -1,6 +1,6 @@
 use async_graphql::{
     Error as GraphqlError,
-    dynamic::{Scalar, SchemaBuilder, SchemaError},
+    dynamic::{Scalar, SchemaError},
     to_value,
 };
 use itertools::Itertools;
@@ -9,10 +9,13 @@ use sea_orm::{
     Condition, EntityTrait,
     sea_query::{ArrayType, Expr, ExprTrait, IntoLikeExpr, SimpleExpr, Value as DbValue},
 };
-use seaography::{BuilderContext, SeaographyError};
+use seaography::{Builder as SeaographyBuilder, BuilderContext, FilterType, SeaographyError};
 use serde_json::Value as JsonValue;
 
-use crate::{errors::RecorderResult, graphql::infra::filter::subscriber::FnFilterCondition};
+use crate::{
+    errors::RecorderResult,
+    graphql::infra::{filter::FnFilterCondition, util::get_entity_column_key},
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Copy)]
 pub enum JsonbFilterOperation {
@@ -892,7 +895,7 @@ where
 
 pub const JSONB_FILTER_NAME: &str = "JsonbFilterInput";
 
-pub fn jsonb_filter_condition_function<T>(
+pub fn generate_jsonb_filter_condition_function<T>(
     _context: &BuilderContext,
     column: &T::Column,
 ) -> FnFilterCondition
@@ -917,11 +920,24 @@ where
     })
 }
 
-pub fn register_jsonb_input_filter_to_dynamic_schema(
-    schema_builder: SchemaBuilder,
-) -> SchemaBuilder {
+pub fn register_jsonb_input_filter_to_schema_builder(
+    mut builder: SeaographyBuilder,
+) -> SeaographyBuilder {
     let json_filter_input_type = Scalar::new(JSONB_FILTER_NAME);
-    schema_builder.register(json_filter_input_type)
+    builder.schema = builder.schema.register(json_filter_input_type);
+    builder
+}
+
+pub fn restrict_jsonb_filter_input_for_entity<T>(context: &mut BuilderContext, column: &T::Column)
+where
+    T: EntityTrait,
+    <T as EntityTrait>::Model: Sync,
+{
+    let entity_column_key = get_entity_column_key::<T>(context, column);
+    context.filter_types.overwrites.insert(
+        entity_column_key.clone(),
+        Some(FilterType::Custom(JSONB_FILTER_NAME.to_string())),
+    );
 }
 
 #[cfg(test)]

apps/recorder/src/graphql/infra/mod.rs

@@ -1,6 +1,3 @@
-pub mod filter;
-pub mod guard;
-pub mod order;
-pub mod pagination;
-pub mod transformer;
+pub mod json;
 pub mod util;
+pub mod filter;

apps/recorder/src/graphql/infra/pagination.rs

@@ -1,36 +0,0 @@
-use async_graphql::{InputObject, SimpleObject};
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, InputObject)]
-pub struct CursorInput {
-    pub cursor: Option<String>,
-    pub limit: u64,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, InputObject)]
-pub struct PageInput {
-    pub page: u64,
-    pub limit: u64,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, InputObject)]
-pub struct OffsetInput {
-    pub offset: u64,
-    pub limit: u64,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, InputObject)]
-pub struct PaginationInput {
-    pub cursor: Option<CursorInput>,
-    pub page: Option<PageInput>,
-    pub offset: Option<OffsetInput>,
-}
-
-pub type PageInfo = async_graphql::connection::PageInfo;
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, SimpleObject)]
-pub struct PaginationInfo {
-    pub pages: u64,
-    pub current: u64,
-    pub offset: u64,
-    pub total: u64,
-}

apps/recorder/src/graphql/infra/transformer.rs

@@ -1,173 +0,0 @@
-use std::{collections::BTreeMap, sync::Arc};
-
-use async_graphql::dynamic::{ResolverContext, ValueAccessor};
-use sea_orm::{ColumnTrait, Condition, EntityTrait, Value as SeaValue};
-use seaography::{
-    BuilderContext, FnFilterConditionsTransformer, FnMutationInputObjectTransformer, SeaResult,
-};
-
-use super::util::{get_column_key, get_entity_key};
-use crate::{app::AppContextTrait, auth::AuthUserInfo, models::credential_3rd};
-
-pub fn build_filter_condition_transformer<T>(
-    _context: &BuilderContext,
-    column: &T::Column,
-) -> FnFilterConditionsTransformer
-where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let column = *column;
-    Box::new(
-        move |context: &ResolverContext, condition: Condition| -> Condition {
-            match context.ctx.data::<AuthUserInfo>() {
-                Ok(user_info) => {
-                    let subscriber_id = user_info.subscriber_auth.subscriber_id;
-                    condition.add(column.eq(subscriber_id))
-                }
-                Err(err) => unreachable!("auth user info must be guarded: {:?}", err),
-            }
-        },
-    )
-}
-
-pub fn build_mutation_input_object_transformer<T>(
-    context: &BuilderContext,
-    column: &T::Column,
-) -> FnMutationInputObjectTransformer
-where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let entity_key = get_entity_key::<T>(context);
-    let entity_name = context.entity_query_field.type_name.as_ref()(&entity_key);
-    let column_key = get_column_key::<T>(context, column);
-    let column_name = Arc::new(context.entity_object.column_name.as_ref()(
-        &entity_key,
-        &column_key,
-    ));
-    let entity_create_one_mutation_field_name = Arc::new(format!(
-        "{}{}",
-        entity_name, context.entity_create_one_mutation.mutation_suffix
-    ));
-    let entity_create_batch_mutation_field_name = Arc::new(format!(
-        "{}{}",
-        entity_name,
-        context.entity_create_batch_mutation.mutation_suffix.clone()
-    ));
-    Box::new(
-        move |context: &ResolverContext,
-              mut input: BTreeMap<String, SeaValue>|
-              -> BTreeMap<String, SeaValue> {
-            let field_name = context.field().name();
-            if field_name == entity_create_one_mutation_field_name.as_str()
-                || field_name == entity_create_batch_mutation_field_name.as_str()
-            {
-                match context.ctx.data::<AuthUserInfo>() {
-                    Ok(user_info) => {
-                        let subscriber_id = user_info.subscriber_auth.subscriber_id;
-                        let value = input.get_mut(column_name.as_str());
-                        if value.is_none() {
-                            input.insert(
-                                column_name.as_str().to_string(),
-                                SeaValue::Int(Some(subscriber_id)),
-                            );
-                        }
-                        input
-                    }
-                    Err(err) => unreachable!("auth user info must be guarded: {:?}", err),
-                }
-            } else {
-                input
-            }
-        },
-    )
-}
-
-fn add_crypto_column_input_conversion<T>(
-    context: &mut BuilderContext,
-    ctx: Arc<dyn AppContextTrait>,
-    column: &T::Column,
-) where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let entity_key = get_entity_key::<T>(context);
-    let column_name = get_column_key::<T>(context, column);
-    let entity_name = context.entity_object.type_name.as_ref()(&entity_key);
-    let column_name = context.entity_object.column_name.as_ref()(&entity_key, &column_name);
-
-    context.types.input_conversions.insert(
-        format!("{entity_name}.{column_name}"),
-        Box::new(move |value: &ValueAccessor| -> SeaResult<sea_orm::Value> {
-            let source = value.string()?;
-            let encrypted = ctx.crypto().encrypt_string(source.into())?;
-            Ok(encrypted.into())
-        }),
-    );
-}
-
-fn add_crypto_column_output_conversion<T>(
-    context: &mut BuilderContext,
-    ctx: Arc<dyn AppContextTrait>,
-    column: &T::Column,
-) where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let entity_key = get_entity_key::<T>(context);
-    let column_name = get_column_key::<T>(context, column);
-    let entity_name = context.entity_object.type_name.as_ref()(&entity_key);
-    let column_name = context.entity_object.column_name.as_ref()(&entity_key, &column_name);
-
-    context.types.output_conversions.insert(
-        format!("{entity_name}.{column_name}"),
-        Box::new(
-            move |value: &sea_orm::Value| -> SeaResult<async_graphql::Value> {
-                if let SeaValue::String(s) = value {
-                    if let Some(s) = s {
-                        let decrypted = ctx.crypto().decrypt_string(s)?;
-                        Ok(async_graphql::Value::String(decrypted))
-                    } else {
-                        Ok(async_graphql::Value::Null)
-                    }
-                } else {
-                    Err(async_graphql::Error::new("crypto column must be string column").into())
-                }
-            },
-        ),
-    );
-}
-
-pub fn add_crypto_transformers(context: &mut BuilderContext, ctx: Arc<dyn AppContextTrait>) {
-    add_crypto_column_input_conversion::<credential_3rd::Entity>(
-        context,
-        ctx.clone(),
-        &credential_3rd::Column::Cookies,
-    );
-    add_crypto_column_input_conversion::<credential_3rd::Entity>(
-        context,
-        ctx.clone(),
-        &credential_3rd::Column::Username,
-    );
-    add_crypto_column_input_conversion::<credential_3rd::Entity>(
-        context,
-        ctx.clone(),
-        &credential_3rd::Column::Password,
-    );
-    add_crypto_column_output_conversion::<credential_3rd::Entity>(
-        context,
-        ctx.clone(),
-        &credential_3rd::Column::Cookies,
-    );
-    add_crypto_column_output_conversion::<credential_3rd::Entity>(
-        context,
-        ctx.clone(),
-        &credential_3rd::Column::Username,
-    );
-    add_crypto_column_output_conversion::<credential_3rd::Entity>(
-        context,
-        ctx,
-        &credential_3rd::Column::Password,
-    );
-}

apps/recorder/src/graphql/mod.rs

@@ -1,8 +1,8 @@
 pub mod config;
+pub mod domains;
 pub mod infra;
 mod schema;
 pub mod service;
-pub mod views;
 
 pub use config::GraphQLConfig;
 pub use schema::build_schema;

apps/recorder/src/graphql/schema.rs

@@ -2,97 +2,30 @@ use std::sync::Arc;
 
 use async_graphql::dynamic::*;
 use once_cell::sync::OnceCell;
-use sea_orm::{EntityTrait, Iterable};
-use seaography::{Builder, BuilderContext, FilterType, FilterTypesMapHelper};
+use seaography::{Builder, BuilderContext};
 
 use crate::{
     app::AppContextTrait,
     graphql::{
-        infra::{
-            filter::{
-                JSONB_FILTER_NAME, SUBSCRIBER_ID_FILTER_INFO, init_custom_filter_info,
-                register_jsonb_input_filter_to_dynamic_schema, subscriber_id_condition_function,
+        domains::{
+            credential_3rd::register_credential3rd_to_schema_builder,
+            crypto::register_crypto_to_schema_context,
+            subscriber_tasks::{
+                register_subscriber_tasks_to_schema_builder,
+                register_subscriber_tasks_to_schema_context,
             },
-            guard::{guard_entity_with_subscriber_id, guard_field_with_subscriber_id},
-            transformer::{
-                add_crypto_transformers, build_filter_condition_transformer,
-                build_mutation_input_object_transformer,
+            subscribers::{
+                register_subscribers_to_schema_builder, register_subscribers_to_schema_context,
+                restrict_subscriber_for_entity,
             },
-            util::{get_entity_column_key, get_entity_key},
+            subscriptions::register_subscriptions_to_schema_builder,
         },
-        views::{register_credential3rd_to_schema, register_subscriptions_to_schema},
+        infra::json::register_jsonb_input_filter_to_schema_builder,
     },
 };
 
 pub static CONTEXT: OnceCell<BuilderContext> = OnceCell::new();
 
-fn restrict_filter_input_for_entity<T>(
-    context: &mut BuilderContext,
-    column: &T::Column,
-    filter_type: Option<FilterType>,
-) where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let key = get_entity_column_key::<T>(context, column);
-    context.filter_types.overwrites.insert(key, filter_type);
-}
-
-fn restrict_jsonb_filter_input_for_entity<T>(context: &mut BuilderContext, column: &T::Column)
-where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let entity_column_key = get_entity_column_key::<T>(context, column);
-    context.filter_types.overwrites.insert(
-        entity_column_key.clone(),
-        Some(FilterType::Custom(JSONB_FILTER_NAME.to_string())),
-    );
-}
-
-fn restrict_subscriber_for_entity<T>(context: &mut BuilderContext, column: &T::Column)
-where
-    T: EntityTrait,
-    <T as EntityTrait>::Model: Sync,
-{
-    let entity_key = get_entity_key::<T>(context);
-    let entity_column_key = get_entity_column_key::<T>(context, column);
-    context.guards.entity_guards.insert(
-        entity_key.clone(),
-        guard_entity_with_subscriber_id::<T>(context, column),
-    );
-    context.guards.field_guards.insert(
-        entity_column_key.clone(),
-        guard_field_with_subscriber_id::<T>(context, column),
-    );
-    context.filter_types.overwrites.insert(
-        entity_column_key.clone(),
-        Some(FilterType::Custom(
-            SUBSCRIBER_ID_FILTER_INFO.get().unwrap().type_name.clone(),
-        )),
-    );
-    context.filter_types.condition_functions.insert(
-        entity_column_key.clone(),
-        subscriber_id_condition_function::<T>(context, column),
-    );
-    context.transformers.filter_conditions_transformers.insert(
-        entity_key.clone(),
-        build_filter_condition_transformer::<T>(context, column),
-    );
-    context
-        .transformers
-        .mutation_input_object_transformers
-        .insert(
-            entity_key,
-            build_mutation_input_object_transformer::<T>(context, column),
-        );
-    context
-        .entity_input
-        .insert_skips
-        .push(entity_column_key.clone());
-    context.entity_input.update_skips.push(entity_column_key);
-}
-
 pub fn build_schema(
     app_ctx: Arc<dyn AppContextTrait>,
     depth: Option<usize>,
@@ -101,70 +34,58 @@ pub fn build_schema(
     use crate::models::*;
     let database = app_ctx.db().as_ref().clone();
 
-    init_custom_filter_info();
     let context = CONTEXT.get_or_init(|| {
         let mut context = BuilderContext::default();
 
-        context.pagination_input.type_name = "PaginationInput".to_string();
-        context.pagination_info_object.type_name = "PaginationInfo".to_string();
-        context.cursor_input.type_name = "CursorInput".to_string();
-        context.offset_input.type_name = "OffsetInput".to_string();
-        context.page_input.type_name = "PageInput".to_string();
-        context.page_info_object.type_name = "PageInfo".to_string();
+        {
+            // domains
+            register_subscribers_to_schema_context(&mut context);
 
-        restrict_subscriber_for_entity::<bangumi::Entity>(
-            &mut context,
-            &bangumi::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<downloaders::Entity>(
-            &mut context,
-            &downloaders::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<downloads::Entity>(
-            &mut context,
-            &downloads::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<episodes::Entity>(
-            &mut context,
-            &episodes::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<subscriptions::Entity>(
-            &mut context,
-            &subscriptions::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<subscribers::Entity>(
-            &mut context,
-            &subscribers::Column::Id,
-        );
-        restrict_subscriber_for_entity::<subscription_bangumi::Entity>(
-            &mut context,
-            &subscription_bangumi::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<subscription_episode::Entity>(
-            &mut context,
-            &subscription_episode::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<subscriber_tasks::Entity>(
-            &mut context,
-            &subscriber_tasks::Column::SubscriberId,
-        );
-        restrict_subscriber_for_entity::<credential_3rd::Entity>(
-            &mut context,
-            &credential_3rd::Column::SubscriberId,
-        );
-        restrict_jsonb_filter_input_for_entity::<subscriber_tasks::Entity>(
-            &mut context,
-            &subscriber_tasks::Column::Job,
-        );
-        add_crypto_transformers(&mut context, app_ctx.clone());
-        for column in subscribers::Column::iter() {
-            if !matches!(column, subscribers::Column::Id) {
-                restrict_filter_input_for_entity::<subscribers::Entity>(
+            {
+                restrict_subscriber_for_entity::<bangumi::Entity>(
                     &mut context,
-                    &column,
-                    None,
+                    &bangumi::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<downloaders::Entity>(
+                    &mut context,
+                    &downloaders::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<downloads::Entity>(
+                    &mut context,
+                    &downloads::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<episodes::Entity>(
+                    &mut context,
+                    &episodes::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<subscriptions::Entity>(
+                    &mut context,
+                    &subscriptions::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<subscribers::Entity>(
+                    &mut context,
+                    &subscribers::Column::Id,
+                );
+                restrict_subscriber_for_entity::<subscription_bangumi::Entity>(
+                    &mut context,
+                    &subscription_bangumi::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<subscription_episode::Entity>(
+                    &mut context,
+                    &subscription_episode::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<subscriber_tasks::Entity>(
+                    &mut context,
+                    &subscriber_tasks::Column::SubscriberId,
+                );
+                restrict_subscriber_for_entity::<credential_3rd::Entity>(
+                    &mut context,
+                    &credential_3rd::Column::SubscriberId,
                 );
             }
+
+            register_crypto_to_schema_context(&mut context, app_ctx.clone());
+            register_subscriber_tasks_to_schema_context(&mut context);
         }
         context
     });
@@ -172,50 +93,39 @@ pub fn build_schema(
     let mut builder = Builder::new(context, database.clone());
 
     {
-        let filter_types_map_helper = FilterTypesMapHelper { context };
+        // infra
+        builder = register_jsonb_input_filter_to_schema_builder(builder);
+    }
+    {
+        // domains
+        builder = register_subscribers_to_schema_builder(builder);
 
-        builder.schema = builder.schema.register(
-            filter_types_map_helper.generate_filter_input(SUBSCRIBER_ID_FILTER_INFO.get().unwrap()),
+        seaography::register_entities!(
+            builder,
+            [
+                bangumi,
+                downloaders,
+                downloads,
+                episodes,
+                subscription_bangumi,
+                subscription_episode,
+                subscriptions,
+                subscriber_tasks,
+                credential_3rd
+            ]
         );
-        builder.schema = register_jsonb_input_filter_to_dynamic_schema(builder.schema);
-    }
 
-    {
-        builder.register_entity::<subscribers::Entity>(
-            <subscribers::RelatedEntity as sea_orm::Iterable>::iter()
-                .map(|rel| seaography::RelationBuilder::get_relation(&rel, builder.context))
-                .collect(),
-        );
-        builder = builder.register_entity_dataloader_one_to_one(subscribers::Entity, tokio::spawn);
-        builder = builder.register_entity_dataloader_one_to_many(subscribers::Entity, tokio::spawn);
-    }
+        {
+            builder.register_enumeration::<downloads::DownloadStatus>();
+            builder.register_enumeration::<subscriptions::SubscriptionCategory>();
+            builder.register_enumeration::<downloaders::DownloaderCategory>();
+            builder.register_enumeration::<downloads::DownloadMime>();
+            builder.register_enumeration::<credential_3rd::Credential3rdType>();
+        }
 
-    seaography::register_entities!(
-        builder,
-        [
-            bangumi,
-            downloaders,
-            downloads,
-            episodes,
-            subscription_bangumi,
-            subscription_episode,
-            subscriptions,
-            subscriber_tasks,
-            credential_3rd
-        ]
-    );
-
-    {
-        builder.register_enumeration::<downloads::DownloadStatus>();
-        builder.register_enumeration::<subscriptions::SubscriptionCategory>();
-        builder.register_enumeration::<downloaders::DownloaderCategory>();
-        builder.register_enumeration::<downloads::DownloadMime>();
-        builder.register_enumeration::<credential_3rd::Credential3rdType>();
-    }
-
-    {
-        builder = register_subscriptions_to_schema(builder);
-        builder = register_credential3rd_to_schema(builder);
+        builder = register_subscriptions_to_schema_builder(builder);
+        builder = register_credential3rd_to_schema_builder(builder);
+        builder = register_subscriber_tasks_to_schema_builder(builder);
     }
 
     let schema = builder.schema_builder();

apps/recorder/src/graphql/views/mod.rs

@@ -1,5 +0,0 @@
-mod credential_3rd;
-mod subscription;
-
-pub use credential_3rd::register_credential3rd_to_schema;
-pub use subscription::register_subscriptions_to_schema;

apps/recorder/src/models/subscriber_tasks.rs

@@ -1,6 +1,6 @@
 use sea_orm::entity::prelude::*;
 
-use crate::task::SubscriberTask;
+pub use crate::task::SubscriberTask;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
 #[sea_orm(table_name = "subscriber_tasks")]