use std::future::IntoFuture;
use std::marker::PhantomData;
use serde::Serialize;
use crate::Serdes;
use crate::context::DurableContext;
use crate::engine::OperationId;
use crate::error::OperationError;
use crate::future::DurableFuture;
use crate::serdes::JsonSerdes;
use crate::serdes::PayloadSerializer;
#[must_use = "builders do nothing unless awaited or spawned"]
#[non_exhaustive]
pub struct InvokeBuilder<O, I, PS = JsonSerdes, RS = JsonSerdes> {
ctx: DurableContext,
op_id: OperationId,
name: Option<String>,
function_id: String,
input: I,
payload_serdes: PS,
result_serdes: RS,
tenant_id: Option<String>,
_marker: PhantomData<O>,
}
impl<O, I, PS, RS> std::fmt::Debug for InvokeBuilder<O, I, PS, RS> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("InvokeBuilder")
.field("name", &self.name)
.field("function_id", &self.function_id)
.finish_non_exhaustive()
}
}
impl<O, I> InvokeBuilder<O, I>
where
O: Send + 'static,
I: Send + 'static,
{
pub(crate) fn new_internal(
ctx: DurableContext,
op_id: OperationId,
function_id: String,
input: I,
) -> Self {
Self {
ctx,
op_id,
name: None,
function_id,
input,
payload_serdes: JsonSerdes,
result_serdes: JsonSerdes,
tenant_id: None,
_marker: PhantomData,
}
}
}
impl<O, I, PS, RS> InvokeBuilder<O, I, PS, RS>
where
O: Send + 'static,
I: Send + 'static,
{
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
pub fn serdes<RS2>(self, serdes: RS2) -> InvokeBuilder<O, I, PS, RS2>
where
RS2: Serdes<O>,
{
InvokeBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
function_id: self.function_id,
input: self.input,
payload_serdes: self.payload_serdes,
result_serdes: serdes,
tenant_id: self.tenant_id,
_marker: PhantomData,
}
}
pub fn payload_serdes<PS2: PayloadSerializer>(
self,
serdes: PS2,
) -> InvokeBuilder<O, I, PS2, RS> {
InvokeBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
function_id: self.function_id,
input: self.input,
payload_serdes: serdes,
result_serdes: self.result_serdes,
tenant_id: self.tenant_id,
_marker: PhantomData,
}
}
pub fn tenant_id(mut self, tenant_id: impl Into<String>) -> Self {
self.tenant_id = Some(tenant_id.into());
self
}
}
impl<O, I, PS, RS> InvokeBuilder<O, I, PS, RS>
where
O: Send + 'static,
I: Serialize + Send + 'static,
PS: PayloadSerializer,
RS: Serdes<O>,
{
pub fn future(self) -> DurableFuture<O> {
<Self as IntoFuture>::into_future(self)
}
pub fn spawn(self) -> DurableFuture<O> {
spawn_terminal!(self, awaited)
}
}
impl<O, I, PS, RS> IntoFuture for InvokeBuilder<O, I, PS, RS>
where
O: Send + 'static,
I: Serialize + Send + 'static,
PS: PayloadSerializer,
RS: Serdes<O>,
{
type Output = Result<O, OperationError>;
type IntoFuture = DurableFuture<O>;
fn into_future(self) -> Self::IntoFuture {
use crate::invoke::InvokeExecution;
preflight_identity!(
self,
"ChainedInvoke",
crate::invoke::CHAINED_INVOKE_SUB_TYPE
);
let gate = self.ctx.clone();
let execution = InvokeExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
function_id: self.function_id,
input: self.input,
payload_serdes: self.payload_serdes,
result_serdes: self.result_serdes,
tenant_id: self.tenant_id,
_marker: PhantomData,
};
DurableFuture::for_first_poll_operation(&gate, execution.execute())
}
}