Struct DurableHandlerBuilder 

pub struct DurableHandlerBuilder<F, Fut>
where
    F: Fn(Value, BuilderContext) -> Fut + Send + Sync + 'static,
    Fut: Future<Output = Result<Value, DurableError>> + Send,
{ /* private fields */ }

A builder for constructing durable Lambda handlers.

Created via the handler function. Call .run() to start the Lambda runtime. Optionally configure tracing and error handling before calling .run() using the builder methods.

Examples

use durable_lambda_builder::prelude::*;

#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    durable_lambda_builder::handler(|event: serde_json::Value, mut ctx: BuilderContext| async move {
        let result: Result<i32, String> = ctx.step("validate", || async { Ok(42) }).await?;
        Ok(serde_json::json!({"result": result.unwrap()}))
    })
    .run()
    .await
}

Implementations

impl<F, Fut> DurableHandlerBuilder<F, Fut>

where F: Fn(Value, BuilderContext) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Value, DurableError>> + Send,

pub fn with_tracing( self, subscriber: impl Subscriber + Send + Sync + 'static, ) -> Self

Configure a tracing subscriber to install before the Lambda runtime starts.

The provided subscriber is installed via tracing::subscriber::set_global_default when run() is called, before any Lambda invocations are processed.

Arguments

• subscriber — Any type implementing tracing::Subscriber + Send + Sync + 'static

Examples

use durable_lambda_builder::prelude::*;

#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    durable_lambda_builder::handler(|event: serde_json::Value, mut ctx: BuilderContext| async move {
        Ok(serde_json::json!({"ok": true}))
    })
    .with_tracing(tracing_subscriber::fmt().finish())
    .run()
    .await
}

pub fn with_error_handler( self, handler: impl Fn(DurableError) -> DurableError + Send + Sync + 'static, ) -> Self

Configure a custom error handler to transform errors before they propagate.

The provided function is called whenever the user handler returns an Err(DurableError), allowing error transformation, logging, or enrichment before the error is returned to the Lambda runtime.

Arguments

• handler — A closure Fn(DurableError) -> DurableError that transforms errors

Examples

use durable_lambda_builder::prelude::*;
use durable_lambda_core::error::DurableError;

#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    durable_lambda_builder::handler(|event: serde_json::Value, mut ctx: BuilderContext| async move {
        Ok(serde_json::json!({"ok": true}))
    })
    .with_error_handler(|e: DurableError| {
        // Log or transform the error before it propagates.
        e
    })
    .run()
    .await
}

pub async fn run(self) -> Result<(), Error>

Consume the builder and start the Lambda runtime.

This method:

1. Installs the tracing subscriber (if configured via with_tracing)
2. Initializes AWS configuration and creates a Lambda client
3. Creates a RealBackend for durable execution API calls
4. Registers with lambda_runtime to receive invocations
5. On each invocation, extracts durable execution metadata from the event, creates a BuilderContext, and calls the user handler
6. Routes handler errors through the error handler (if configured via with_error_handler)

Errors

Returns lambda_runtime::Error if the Lambda runtime fails to start or encounters a fatal error.

Panics

Panics if a tracing subscriber is configured and a global default subscriber has already been set (e.g., by another library or test framework).

Examples

use durable_lambda_builder::prelude::*;

#[tokio::main]
async fn main() -> Result<(), lambda_runtime::Error> {
    durable_lambda_builder::handler(|event: serde_json::Value, mut ctx: BuilderContext| async move {
        Ok(serde_json::json!({"ok": true}))
    })
    .run()
    .await
}