dex-sdk 0.2.2

Strongly typed Rust SDK for Dex
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// Copyright (c) 2026 Super Durable, Inc.
//
// Licensed under the Super Durable Source License 1.0.
// You may not use this file except in compliance with the License.
// See the LICENSE file in the repository root.
//
// SPDX-License-Identifier: LicenseRef-Super-Durable-1.0

use crate::{
    Context, HandlerResult, PersistenceSchema, RpcList, StepDecision, StepList, Value,
    short_type_name,
};

/// Function registered by a [`Flow`] to handle expiration of its soft timeout.
pub type FlowTimeoutHandler<SomeFlow> = fn(&SomeFlow, &mut Context) -> HandlerResult<StepDecision>;

/// Defines a durable application Flow and its registered API surface.
///
/// A Flow owns a typed start input, Step list, persistence schema, and RPC list. Implementations are
/// registered as owned values in [`crate::Registry`] and shared safely across Worker invocations.
/// Keep [`Self::flow_type`] and all subordinate names stable while any execution is running.
///
/// # Examples
///
/// ```
/// use dex_sdk::{Flow, StepList};
///
/// struct OrderFlow;
///
/// impl Flow for OrderFlow {
///     type StartInput = String;
///
///     fn steps(&self) -> StepList<'_, Self::StartInput> {
///         StepList::empty()
///     }
/// }
/// ```
pub trait Flow: Send + Sync + 'static {
    /// Value accepted by [`crate::Client::start_flow`] and the starting Step.
    type StartInput: Value;

    /// Returns the stable Flow type sent to Dex.
    ///
    /// The default is the final Rust type-name segment.
    fn flow_type(&self) -> &'static str {
        short_type_name::<Self>()
    }

    /// Returns the starting Step and all other Step definitions.
    ///
    /// The default is an empty list, which is valid only for Flows driven entirely by RPCs.
    fn steps(&self) -> StepList<'_, Self::StartInput> {
        StepList::empty()
    }

    /// Declares every Attribute and Channel used by this Flow.
    ///
    /// The default schema is empty.
    fn persistence(&self) -> PersistenceSchema {
        PersistenceSchema::new()
    }

    /// Returns the optional handler invoked after this Flow's durable timeout timer expires.
    ///
    /// Returning `Some` makes a positive timeout default to [`crate::FlowTimeoutPolicy::Handler`].
    /// The handler runs at most once and its decision uses normal Step Execute validation.
    fn timeout_handler(&self) -> Option<FlowTimeoutHandler<Self>>
    where
        Self: Sized,
    {
        None
    }

    /// Binds public RPC names to methods on this Flow implementation.
    ///
    /// The default list is empty.
    fn rpcs(&self) -> RpcList<Self>
    where
        Self: Sized,
    {
        RpcList::new()
    }
}