use super::action_trait::PermissionMode;
use super::meta::ActionMeta;
use super::{ActionContext, ApiResponse, DynAction};
use crate::definition::ParamInput;
use crate::error::BaseError;
use async_trait::async_trait;
use schemars::JsonSchema;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::any::{Any, TypeId};
use std::future::Future;
use std::marker::PhantomData;
use std::sync::OnceLock;
pub(crate) struct FnAction<F, I, O> {
handler: F,
marker: PhantomData<fn(I) -> O>,
}
impl<F, I, O> FnAction<F, I, O> {
pub(crate) fn new(handler: F) -> Self {
Self {
handler,
marker: PhantomData,
}
}
}
fn placeholder_meta() -> &'static ActionMeta {
static INPUT_SCHEMA: OnceLock<schemars::schema::RootSchema> = OnceLock::new();
static OUTPUT_SCHEMA: OnceLock<schemars::schema::RootSchema> = OnceLock::new();
static META: OnceLock<ActionMeta> = OnceLock::new();
META.get_or_init(|| {
ActionMeta::new(
"<functional>",
"<functional>",
"函数式 Action 的占位元信息;真实定义以注册期 ActionSpec 为准",
&[],
PermissionMode::All,
false,
INPUT_SCHEMA.get_or_init(|| schemars::schema_for!(serde_json::Value)),
OUTPUT_SCHEMA.get_or_init(|| schemars::schema_for!(serde_json::Value)),
)
})
}
#[async_trait]
impl<F, I, O, Fut> DynAction for FnAction<F, I, O>
where
F: Fn(ActionContext, I) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<O, BaseError>> + Send,
I: ParamInput + DeserializeOwned + JsonSchema + Send + 'static,
O: Serialize + JsonSchema + Send + 'static,
{
async fn dispatch(&self, ctx: ActionContext) -> Result<ApiResponse, BaseError> {
let mut ctx = ctx;
let input = I::decode(&mut ctx.request)?;
let output = (self.handler)(ctx, input).await?;
super::response::wrap_dispatch_output(output, "成功")
}
fn meta(&self) -> &'static ActionMeta {
placeholder_meta()
}
fn input_type_id(&self) -> TypeId {
TypeId::of::<I>()
}
fn output_type_id(&self) -> TypeId {
TypeId::of::<O>()
}
async fn call_boxed(
&self,
ctx: ActionContext,
input: Box<dyn Any + Send>,
) -> Result<Box<dyn Any + Send>, BaseError> {
let input = input.downcast::<I>().map_err(|_| {
BaseError::ConfigError("函数式 Action 的内部调用输入类型不匹配".to_string())
})?;
let output = (self.handler)(ctx, *input).await?;
Ok(Box::new(output))
}
}
pub struct CrudFnAction<F, I, O> {
name: &'static str,
handler: F,
marker: PhantomData<fn(I) -> O>,
}
impl<F, I, O> CrudFnAction<F, I, O> {
pub fn new(name: &'static str, handler: F) -> Self {
Self {
name,
handler,
marker: PhantomData,
}
}
}
#[async_trait]
impl<F, I, O, Fut> DynAction for CrudFnAction<F, I, O>
where
F: Fn(ActionContext, I) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<O, BaseError>> + Send,
I: DeserializeOwned + Send + 'static,
O: Serialize + Send + 'static,
{
async fn dispatch(&self, ctx: ActionContext) -> Result<ApiResponse, BaseError> {
use tracing::Instrument;
let span = tracing::info_span!("handle", action = self.name);
async {
let mut ctx = ctx;
let body = std::mem::take(&mut ctx.request.body);
let input: I = serde_json::from_value(body)
.map_err(|error| BaseError::ParamInvalid("body".to_string(), error.to_string()))?;
let output = (self.handler)(ctx, input).await?;
ApiResponse::success(output, "成功")
}
.instrument(span)
.await
}
fn meta(&self) -> &'static ActionMeta {
placeholder_meta()
}
fn input_type_id(&self) -> TypeId {
TypeId::of::<I>()
}
fn output_type_id(&self) -> TypeId {
TypeId::of::<O>()
}
async fn call_boxed(
&self,
ctx: ActionContext,
input: Box<dyn Any + Send>,
) -> Result<Box<dyn Any + Send>, BaseError> {
let input = input.downcast::<I>().map_err(|_| {
BaseError::ConfigError("函数式 CRUD 写 Action 的内部调用输入类型不匹配".to_string())
})?;
let output = (self.handler)(ctx, *input).await?;
Ok(Box::new(output))
}
}