dumtruck/konobangu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: refactor graphql

Browse Source
This commit is contained in:
master
2025-06-12 00:15:26 +08:00
parent b09e9e6aaa
commit 258eeddc74
36 changed files with 680 additions and 612 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
apps/recorder/src/graphql/infra/filter.rs Normal file
View File

@@ -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>;

19
apps/recorder/src/graphql/infra/filter/mod.rs
View File

@@ -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 },
});
}

39
apps/recorder/src/graphql/infra/filter/subscriber.rs
View File

@@ -1,39 +0,0 @@
use async_graphql::dynamic::ObjectAccessor;
use once_cell::sync::OnceCell;
use sea_orm::{ColumnTrait, Condition, EntityTrait};
use seaography::{
BuilderContext, FilterInfo, FilterOperation as SeaographqlFilterOperation, SeaResult,
};
pub static SUBSCRIBER_ID_FILTER_INFO: OnceCell<FilterInfo> = OnceCell::new();
pub type FnFilterCondition =
Box<dyn Fn(Condition, &ObjectAccessor) -> SeaResult<Condition> + Send + Sync>;
pub fn subscriber_id_condition_function<T>(
_context: &BuilderContext,
column: &T::Column,
) -> FnFilterCondition
where
T: EntityTrait,
<T as EntityTrait>::Model: Sync,
{
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 {
match operation {
SeaographqlFilterOperation::Equals => {
if let Some(value) = filter.get("eq") {
let value: i32 = value.i64()?.try_into()?;
let value = sea_orm::Value::Int(Some(value));
condition = condition.add(column.eq(value));
}
}
_ => unreachable!("unreachable filter operation for subscriber_id"),
}
}
Ok(condition)
})
}

183
apps/recorder/src/graphql/infra/guard.rs
View File

@@ -1,183 +0,0 @@
use std::sync::Arc;
use async_graphql::dynamic::{ResolverContext, ValueAccessor};
use sea_orm::EntityTrait;
use seaography::{BuilderContext, FnGuard, GuardAction};
use crate::{
auth::{AuthError, AuthUserInfo},
graphql::infra::util::{get_column_key, get_entity_key},
};
fn guard_data_object_accessor_with_subscriber_id(
value: ValueAccessor<'_>,
column_name: &str,
subscriber_id: i32,
) -> async_graphql::Result<()> {
let obj = value.object()?;
let subscriber_id_value = obj.try_get(column_name)?;
let id = subscriber_id_value.i64()?;
if id == subscriber_id as i64 {
Ok(())
} else {
Err(async_graphql::Error::new("subscriber not match"))
}
}
fn guard_data_object_accessor_with_optional_subscriber_id(
value: ValueAccessor<'_>,
column_name: &str,
subscriber_id: i32,
) -> async_graphql::Result<()> {
if value.is_null() {
return Ok(());
}
let obj = value.object()?;
if let Some(subscriber_id_value) = obj.get(column_name) {
let id = subscriber_id_value.i64()?;
if id == subscriber_id as i64 {
Ok(())
} else {
Err(async_graphql::Error::new("subscriber not match"))
}
} else {
Ok(())
}
}
pub fn guard_entity_with_subscriber_id<T>(_context: &BuilderContext, _column: &T::Column) -> FnGuard
where
T: EntityTrait,
<T as EntityTrait>::Model: Sync,
{
Box::new(move |context: &ResolverContext| -> GuardAction {
match context.ctx.data::<AuthUserInfo>() {
Ok(_) => GuardAction::Allow,
Err(err) => GuardAction::Block(Some(err.message)),
}
})
}
pub fn guard_field_with_subscriber_id<T>(context: &BuilderContext, column: &T::Column) -> FnGuard
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_one_mutation_data_field_name =
Arc::new(context.entity_create_one_mutation.data_field.clone());
let entity_create_batch_mutation_field_name = Arc::new(format!(
"{}{}",
entity_name,
context.entity_create_batch_mutation.mutation_suffix.clone()
));
let entity_create_batch_mutation_data_field_name =
Arc::new(context.entity_create_batch_mutation.data_field.clone());
let entity_update_mutation_field_name = Arc::new(format!(
"{}{}",
entity_name, context.entity_update_mutation.mutation_suffix
));
let entity_update_mutation_data_field_name =
Arc::new(context.entity_update_mutation.data_field.clone());
Box::new(move |context: &ResolverContext| -> GuardAction {
match context.ctx.data::<AuthUserInfo>() {
Ok(user_info) => {
let subscriber_id = user_info.subscriber_auth.subscriber_id;
let validation_result = match context.field().name() {
field if field == entity_create_one_mutation_field_name.as_str() => {
if let Some(data_value) = context
.args
.get(&entity_create_one_mutation_data_field_name)
{
guard_data_object_accessor_with_subscriber_id(
data_value,
&column_name,
subscriber_id,
)
.map_err(|inner_error| {
AuthError::from_graphql_dynamic_subscribe_id_guard(
inner_error,
context,
&entity_create_one_mutation_data_field_name,
&column_name,
)
})
} else {
Ok(())
}
}
field if field == entity_create_batch_mutation_field_name.as_str() => {
if let Some(data_value) = context
.args
.get(&entity_create_batch_mutation_data_field_name)
{
data_value
.list()
.and_then(|data_list| {
data_list.iter().try_for_each(|data_item_value| {
guard_data_object_accessor_with_optional_subscriber_id(
data_item_value,
&column_name,
subscriber_id,
)
})
})
.map_err(|inner_error| {
AuthError::from_graphql_dynamic_subscribe_id_guard(
inner_error,
context,
&entity_create_batch_mutation_data_field_name,
&column_name,
)
})
} else {
Ok(())
}
}
field if field == entity_update_mutation_field_name.as_str() => {
if let Some(data_value) =
context.args.get(&entity_update_mutation_data_field_name)
{
guard_data_object_accessor_with_optional_subscriber_id(
data_value,
&column_name,
subscriber_id,
)
.map_err(|inner_error| {
AuthError::from_graphql_dynamic_subscribe_id_guard(
inner_error,
context,
&entity_update_mutation_data_field_name,
&column_name,
)
})
} else {
Ok(())
}
}
_ => Ok(()),
};
match validation_result {
Ok(_) => GuardAction::Allow,
Err(err) => GuardAction::Block(Some(err.to_string())),
}
}
Err(err) => GuardAction::Block(Some(err.message)),
}
})
}

32
apps/recorder/src/graphql/infra/filter/json.rs → apps/recorder/src/graphql/infra/json.rs
View File

@@ -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)]

7
apps/recorder/src/graphql/infra/mod.rs
View File

@@ -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;

0
apps/recorder/src/graphql/infra/order.rs
View File

36
apps/recorder/src/graphql/infra/pagination.rs
View File

@@ -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,
}

173
apps/recorder/src/graphql/infra/transformer.rs
View File

@@ -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,
);
}