greentic-types 0.5.2

Shared primitives for Greentic: TenantCtx, InvocationEnvelope, NodeError, ids.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Wizard planning and delegation primitives.

use alloc::{collections::BTreeMap, string::String, vec::Vec};

#[cfg(feature = "schemars")]
use schemars::JsonSchema;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Stable wizard identifier.
#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(feature = "serde", serde(transparent))]
pub struct WizardId(pub String);

impl WizardId {
    /// Returns the identifier as a string slice.
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl From<String> for WizardId {
    fn from(value: String) -> Self {
        Self(value)
    }
}

impl From<&str> for WizardId {
    fn from(value: &str) -> Self {
        Self(value.to_owned())
    }
}

impl From<WizardId> for String {
    fn from(value: WizardId) -> Self {
        value.0
    }
}

/// Target system that will execute wizard actions.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
pub enum WizardTarget {
    /// Component scope.
    Component,
    /// Flow scope.
    Flow,
    /// Pack scope.
    Pack,
    /// Operator scope.
    Operator,
    /// Development tooling scope.
    Dev,
    /// Bundle scope.
    Bundle,
}

/// Canonical wizard mode.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
pub enum WizardMode {
    /// Default mode.
    Default,
    /// Setup mode.
    Setup,
    /// Update mode.
    Update,
    /// Remove mode.
    Remove,
    /// Scaffold mode.
    Scaffold,
    /// Build mode.
    Build,
    /// New mode.
    New,
}

/// Wizard plan metadata.
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct WizardPlanMeta {
    /// Wizard identifier.
    pub id: WizardId,
    /// Wizard target scope.
    pub target: WizardTarget,
    /// Requested execution mode.
    pub mode: WizardMode,
}

/// Deterministic wizard plan.
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
pub struct WizardPlan {
    /// Plan metadata and routing identity.
    pub meta: WizardPlanMeta,
    /// Ordered steps to execute.
    pub steps: Vec<WizardStep>,
}

/// A single wizard plan step.
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case", tag = "type"))]
pub enum WizardStep {
    /// Ensure directories exist.
    EnsureDir {
        /// Directories to ensure.
        paths: Vec<String>,
    },
    /// Write files as path -> UTF-8 content.
    WriteFiles {
        /// Map of relative path to content.
        files: BTreeMap<String, String>,
    },
    /// Legacy bridge to invoke CLI commands.
    RunCli {
        /// Executable command.
        command: String,
        /// Command arguments.
        #[cfg_attr(
            feature = "serde",
            serde(default, skip_serializing_if = "Vec::is_empty")
        )]
        args: Vec<String>,
    },
    /// Delegate part of the wizard to another target/id/mode.
    Delegate {
        /// Target scope for delegation.
        target: WizardTarget,
        /// Delegate wizard identifier.
        id: WizardId,
        /// Delegate mode.
        mode: WizardMode,
        /// Optional prefilled answers for deterministic replay.
        #[cfg_attr(
            feature = "serde",
            serde(default, skip_serializing_if = "BTreeMap::is_empty")
        )]
        prefilled_answers: BTreeMap<String, Value>,
        /// Optional output key remapping.
        #[cfg_attr(
            feature = "serde",
            serde(default, skip_serializing_if = "BTreeMap::is_empty")
        )]
        output_map: BTreeMap<String, String>,
    },
}