feat: task ui & custom filter mutation

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

@@ -1,33 +1,35 @@
 use std::{pin::Pin, sync::Arc};
 
 use async_graphql::dynamic::{
-    Field, FieldFuture, InputValue, ResolverContext, TypeRef, ValueAccessor,
+    Field, FieldFuture, FieldValue, InputValue, ResolverContext, TypeRef, ValueAccessor,
 };
 use sea_orm::EntityTrait;
-use seaography::{
-    BuilderContext, EntityDeleteMutationBuilder, EntityObjectBuilder, FilterInputBuilder,
-    GuardAction,
-};
+use seaography::{BuilderContext, EntityObjectBuilder, FilterInputBuilder, GuardAction};
 
 use crate::{app::AppContextTrait, errors::RecorderResult};
 
-pub type DeleteMutationFn = Arc<
-    dyn Fn(
-            &ResolverContext<'_>,
+pub type FilterMutationFn = Arc<
+    dyn for<'a> Fn(
+            &ResolverContext<'a>,
             Arc<dyn AppContextTrait>,
             Option<ValueAccessor<'_>>,
-        ) -> Pin<Box<dyn Future<Output = RecorderResult<Option<i32>>> + Send>>
-        + Send
+        ) -> Pin<
+            Box<dyn Future<Output = RecorderResult<Option<FieldValue<'a>>>> + Send + 'a>,
+        > + Send
         + Sync,
 >;
 
-pub fn generate_custom_entity_delete_mutation_field<T>(
+pub fn generate_entity_filter_mutation_field<T, N, R>(
     builder_context: &'static BuilderContext,
-    mutation_fn: DeleteMutationFn,
+    field_name: N,
+    type_ref: R,
+    mutation_fn: FilterMutationFn,
 ) -> Field
 where
     T: EntityTrait,
     <T as EntityTrait>::Model: Sync,
+    N: Into<String>,
+    R: Into<TypeRef>,
 {
     let entity_filter_input_builder = FilterInputBuilder {
         context: builder_context,
@@ -35,43 +37,38 @@ where
     let entity_object_builder = EntityObjectBuilder {
         context: builder_context,
     };
-    let entity_delete_mutation_builder = EntityDeleteMutationBuilder {
-        context: builder_context,
-    };
     let object_name: String = entity_object_builder.type_name::<T>();
 
     let context = builder_context;
 
     let guard = builder_context.guards.entity_guards.get(&object_name);
 
-    Field::new(
-        entity_delete_mutation_builder.type_name::<T>(),
-        TypeRef::named_nn(TypeRef::INT),
-        move |ctx| {
-            let mutation_fn = mutation_fn.clone();
-            FieldFuture::new(async move {
-                let guard_flag = if let Some(guard) = guard {
-                    (*guard)(&ctx)
-                } else {
-                    GuardAction::Allow
-                };
+    Field::new(field_name, type_ref, move |ctx| {
+        let mutation_fn = mutation_fn.clone();
+        FieldFuture::new(async move {
+            let guard_flag = if let Some(guard) = guard {
+                (*guard)(&ctx)
+            } else {
+                GuardAction::Allow
+            };
 
-                if let GuardAction::Block(reason) = guard_flag {
-                    return Err::<Option<_>, async_graphql::Error>(async_graphql::Error::new(
-                        reason.unwrap_or("Entity guard triggered.".into()),
-                    ));
-                }
+            if let GuardAction::Block(reason) = guard_flag {
+                return Err::<Option<_>, async_graphql::Error>(async_graphql::Error::new(
+                    reason.unwrap_or("Entity guard triggered.".into()),
+                ));
+            }
 
-                let app_ctx = ctx.data::<Arc<dyn AppContextTrait>>()?;
+            let app_ctx = ctx.data::<Arc<dyn AppContextTrait>>()?;
 
-                let filters = ctx.args.get(&context.entity_delete_mutation.filter_field);
+            let filters = ctx.args.get(&context.entity_delete_mutation.filter_field);
 
-                let result = mutation_fn(&ctx, app_ctx.clone(), filters).await?;
+            let result = mutation_fn(&ctx, app_ctx.clone(), filters)
+                .await
+                .map_err(async_graphql::Error::new_with_source)?;
 
-                Ok(result.map(async_graphql::Value::from))
-            })
-        },
-    )
+            Ok(result)
+        })
+    })
     .argument(InputValue::new(
         &context.entity_delete_mutation.filter_field,
         TypeRef::named(entity_filter_input_builder.type_name(&object_name)),