nizaam-core 1.0.1

Domain-agnostic Rust infrastructure core for building secure, observable, reliable, and extensible Nizaam engines.
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

//! Universal logical-message representation for Response interactions.
//!
//! A Response is one interaction form of the common universal message boundary.
//! Its common occurrence identity and semantic metadata are owned by
//! `UniversalEvent`; `Status` remains Response-specific.

use crate::contracts::UniversalEvent;
use crate::contracts::descriptor::Interaction;
use crate::contracts::envelope::MessageEnvelope;
use crate::identity::EventId;
use crate::status::Status;

/// A universal logical message carrying Response interaction semantics.
#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct UniversalResponse {
    pub event: UniversalEvent,
    pub status: Status,
}

impl UniversalResponse {
    /// Creates a Response wrapper and constructs its universal occurrence
    /// internally. Callers do not construct `UniversalEvent` themselves.
    pub fn new(envelope: MessageEnvelope, status: Status) -> Self {
        let event = UniversalEvent::new(envelope, "universal.response", "response", "global")
            .expect("response occurrence metadata is static and valid");

        Self { event, status }
    }

    /// Returns the Response occurrence identity.
    pub fn event_id(&self) -> &EventId {
        self.event.event_id()
    }

    /// Returns the logical message identity carried by the universal occurrence.
    pub fn message_id(&self) -> &crate::identity::MessageId {
        self.event.message_id()
    }

    /// Returns the common universal occurrence boundary.
    pub fn universal_event(&self) -> &UniversalEvent {
        &self.event
    }

    /// Returns whether this logical message declares Response interaction semantics.
    pub fn has_response_interaction(&self) -> bool {
        self.event.envelope.metadata.descriptor.interaction == Interaction::Response
    }

    pub fn event_name(&self) -> &crate::events::EventName {
        self.event.event_name()
    }

    pub fn event_type(&self) -> &str {
        self.event.event_type()
    }

    pub fn event_scope(&self) -> &str {
        self.event.scope()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::contracts::descriptor::{
        ContractDescriptor, EncodedPayload, Interaction, PayloadDescriptor, Version,
    };
    use crate::contracts::envelope::MessageEnvelope;
    use crate::contracts::metadata::{ContractMetadata, Participants};
    use crate::identity::{
        CapabilityId, ContractId, CorrelationId, EngineId, MessageId, OperationId,
    };
    use crate::operation::{Operation, OperationContext};

    fn make_envelope(interaction: Interaction) -> MessageEnvelope {
        let desc = ContractDescriptor::new(
            ContractId::new("test.contract").unwrap(),
            CapabilityId::new("test-cap").unwrap(),
            Version::new(1, 0, 0),
            interaction,
            PayloadDescriptor::new("application/octet-stream", Version::new(1, 0, 0)).unwrap(),
        );
        let metadata = ContractMetadata::new(
            desc.clone(),
            Participants::new(
                EngineId::new("sender").unwrap(),
                EngineId::new("receiver").unwrap(),
            ),
        );
        let op_ctx = OperationContext::new(Operation::new(
            OperationId::new("op-1").unwrap(),
            CorrelationId::new("corr-1").unwrap(),
        ));
        MessageEnvelope::new(
            MessageId::new("msg-1").unwrap(),
            op_ctx,
            metadata,
            EncodedPayload::new(desc.payload, b"test payload"),
        )
    }

    #[test]
    fn response_has_response_interaction() {
        let response =
            UniversalResponse::new(make_envelope(Interaction::Response), Status::Success);

        assert!(response.has_response_interaction());
        assert!(!response.event_id().as_str().is_empty());
        assert_eq!(response.event_type(), "response");
    }

    #[test]
    fn response_does_not_have_request_or_event_interaction() {
        let response = UniversalResponse::new(make_envelope(Interaction::Request), Status::Success);
        assert!(!response.has_response_interaction());

        let response = UniversalResponse::new(make_envelope(Interaction::Event), Status::Success);
        assert!(!response.has_response_interaction());
    }

    #[test]
    fn response_preserves_envelope_status_and_universal_event() {
        let envelope = make_envelope(Interaction::Response);
        let message_id = envelope.message_id.as_str().to_string();

        let response = UniversalResponse::new(envelope, Status::TimedOut);

        assert_eq!(response.event.envelope.message_id.as_str(), message_id);
        assert_eq!(response.status, Status::TimedOut);
        assert!(!response.event_id().as_str().is_empty());
        assert_eq!(response.message_id().as_str(), "msg-1");
        assert_eq!(response.event_name().as_str(), "universal.response");
        assert_eq!(response.event_scope(), "global");
    }

    #[test]
    fn response_serialization_preserves_universal_event() {
        let response =
            UniversalResponse::new(make_envelope(Interaction::Response), Status::Success);

        let encoded = serde_json::to_string(&response).unwrap();
        let decoded: UniversalResponse = serde_json::from_str(&encoded).unwrap();

        assert_eq!(decoded, response);
    }
}