greentic-deployer-dev 1.1.27501952916

Greentic deployer runtime for plan construction and deployment-pack dispatch
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

//! Messaging-endpoint projection producer (`Phase M1.2`).
//!
//! `environment.json` is the source of truth; per-endpoint files under
//! `<env_dir>/messaging/` are derived projections rebuilt on every mutation.
//! Mirrors the [`runtime_config`](super::runtime_config) pattern: a single
//! pure projector + a [`Locked::refresh_messaging_projection`] helper that
//! reconciles disk against the just-saved env inside the same transaction.
//!
//! Per-endpoint file: `<env_dir>/messaging/<endpoint_id>.json`. Each endpoint
//! is written verbatim so external tooling can read one endpoint without
//! parsing the full `environment.json`. An index file
//! `<env_dir>/messaging/index.json` carries a stable list of `(endpoint_id,
//! provider_type, provider_id, display_name)` tuples for quick enumeration.
//!
//! `refresh_messaging_projection` removes per-endpoint files for ids no
//! longer in the env so the directory tracks the source-of-truth set exactly.

use greentic_deploy_spec::{Environment, MessagingEndpoint, MessagingEndpointId};
use serde::{Deserialize, Serialize};

/// One row of the on-disk `messaging/index.json` projection.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MessagingEndpointIndexEntry {
    pub endpoint_id: MessagingEndpointId,
    pub provider_type: String,
    pub provider_id: String,
    pub display_name: String,
}

impl MessagingEndpointIndexEntry {
    pub fn from(endpoint: &MessagingEndpoint) -> Self {
        Self {
            endpoint_id: endpoint.endpoint_id,
            provider_type: endpoint.provider_type.clone(),
            provider_id: endpoint.provider_id.clone(),
            display_name: endpoint.display_name.clone(),
        }
    }
}

/// Materialize the `messaging/index.json` projection. Pure and total: one
/// row per endpoint in `Environment.messaging_endpoints` order. An env with
/// no endpoints yields an empty list (callers delete the file instead of
/// writing an empty array, mirroring the runtime-config "absence is the
/// nothing-live signal" precedent).
pub fn materialize_messaging_index(env: &Environment) -> Vec<MessagingEndpointIndexEntry> {
    env.messaging_endpoints
        .iter()
        .map(MessagingEndpointIndexEntry::from)
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use greentic_deploy_spec::{
        EnvId, EnvironmentHostConfig, MessagingEndpoint, MessagingEndpointId, SchemaVersion,
    };

    fn endpoint(provider_type: &str, provider_id: &str) -> MessagingEndpoint {
        MessagingEndpoint {
            schema: SchemaVersion::new(SchemaVersion::MESSAGING_ENDPOINT_V1),
            env_id: EnvId::try_from("local").unwrap(),
            endpoint_id: MessagingEndpointId::new(),
            provider_id: provider_id.into(),
            provider_type: provider_type.into(),
            display_name: format!("{provider_type}: {provider_id}"),
            secret_refs: vec![],
            webhook_secret_ref: None,
            linked_bundles: vec![],
            welcome_flow: None,
            generation: 1,
            created_at: Utc::now(),
            updated_at: Utc::now(),
            updated_by: "operator://test".into(),
        }
    }

    fn env(endpoints: Vec<MessagingEndpoint>) -> Environment {
        let env_id = EnvId::try_from("local").unwrap();
        Environment {
            schema: SchemaVersion::new(SchemaVersion::ENVIRONMENT_V1),
            environment_id: env_id.clone(),
            name: "local".into(),
            host_config: EnvironmentHostConfig {
                env_id,
                region: None,
                tenant_org_id: None,
                listen_addr: None,
                public_base_url: None,
            },
            packs: vec![],
            credentials_ref: None,
            bundles: vec![],
            revisions: vec![],
            traffic_splits: vec![],
            messaging_endpoints: endpoints,
            extensions: Vec::new(),
            revocation: Default::default(),
            retention: Default::default(),
            health: Default::default(),
        }
    }

    #[test]
    fn empty_env_yields_empty_index() {
        assert!(materialize_messaging_index(&env(vec![])).is_empty());
    }

    #[test]
    fn index_preserves_endpoint_order() {
        let legal = endpoint("teams", "legal-bot");
        let accounting = endpoint("teams", "accounting-bot");
        let index = materialize_messaging_index(&env(vec![legal.clone(), accounting.clone()]));
        assert_eq!(index.len(), 2);
        assert_eq!(index[0].endpoint_id, legal.endpoint_id);
        assert_eq!(index[1].endpoint_id, accounting.endpoint_id);
    }

    #[test]
    fn index_carries_human_label() {
        let ep = endpoint("teams", "legal-bot");
        let index = materialize_messaging_index(&env(vec![ep.clone()]));
        assert_eq!(index[0].display_name, ep.display_name);
        assert_eq!(index[0].provider_type, "teams");
        assert_eq!(index[0].provider_id, "legal-bot");
    }
}