hatchet-sdk 0.2.4

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
50
51
52
53
54
55

use hatchet_sdk::{Context, Hatchet, Runnable, anyhow, serde_json, tokio};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, JsonSchema)]
pub struct SchemaInput {
    pub first: i64,
    pub second: i64,
}

#[derive(Serialize, Deserialize)]
pub struct AddOutput {
    pub value: i64,
}

pub async fn create_schema_workflow() -> hatchet_sdk::Workflow<SchemaInput, AddOutput> {
    let hatchet = Hatchet::from_env().await.unwrap();

    let schema = schemars::schema_for!(SchemaInput);
    let schema_value = serde_json::to_value(schema).unwrap();

    let task = hatchet
        .task(
            "add",
            async move |input: SchemaInput, _context: Context| -> anyhow::Result<AddOutput> {
                Ok(AddOutput {
                    value: input.first + input.second,
                })
            },
        )
        .build()
        .unwrap();

    hatchet
        .workflow::<SchemaInput, AddOutput>("schema-workflow")
        .input_json_schema(Some(schema_value))
        .build()
        .unwrap()
        .add_task(&task)
}

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

    let workflow = create_schema_workflow().await;

    let input = SchemaInput {
        first: 3,
        second: 7,
    };
    let result = workflow.run(&input, None).await.unwrap();
    println!("Result: {}", result.value);
}