hatchet-sdk 0.2.8

This is an unofficial Rust SDK for Hatchet, a distributed, fault-tolerant task queue.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

use hatchet_sdk::{Context, Hatchet, Runnable, TriggerWorkflowOptionsBuilder};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct SimpleInput {
    pub message: String,
}

#[derive(Serialize, Deserialize)]
pub struct SimpleOutput {
    pub transformed_message: String,
}

pub async fn create_simple_task() -> hatchet_sdk::Task<SimpleInput, SimpleOutput> {
    async fn simple_task_func(input: SimpleInput, ctx: Context) -> anyhow::Result<SimpleOutput> {
        ctx.log("Starting simple task").await?;
        Ok(SimpleOutput {
            transformed_message: input.message.to_lowercase(),
        })
    }

    let hatchet: Hatchet = Hatchet::from_env().await.unwrap();

    hatchet
        .task("simple-task", simple_task_func)
        .build()
        .unwrap()
}

#[tokio::main]
#[allow(dead_code)]
async fn main() {
    dotenvy::dotenv().ok();

    let task = create_simple_task().await;

    let options = TriggerWorkflowOptionsBuilder::default()
        .additional_metadata(Some(serde_json::json!({
            "environment": "dev",
        })))
        .build()
        .unwrap();

    let input = SimpleInput {
        message: String::from("Hello, world!"),
    };
    let result = task.run(&input, Some(&options)).await.unwrap();
    println!("Result: {}", result.transformed_message);
}