minco-interaction 1.12.0

Provider-neutral support entry, attachments, transcription, workflow, and activity helpers for Minco applications
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

use minco_plugin_audit::{AuditEvent, AuditService};
use minco_plugin_events::{DomainEvent, EventServices, OutboxRecord};
use minco_plugin_notifications::{Notification, NotificationService};
use serde::{Deserialize, Serialize};

/// Stable public warning emitted by the explicitly post-commit recorder.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct PostCommitActivityWarning {
    pub code: String,
    pub detail: String,
}

/// Compatibility helper for best-effort work after an operational commit.
///
/// This helper does not provide transactional audit durability. An adapter may
/// claim that only when it atomically commits the mutation and local audit or
/// outbox intent in its own store transaction.
#[derive(Debug, Clone)]
pub struct PostCommitActivityRecorder {
    pub audit: AuditService,
    pub events: EventServices,
    pub notifications: NotificationService,
}

impl PostCommitActivityRecorder {
    pub async fn record(
        &self,
        audit: AuditEvent,
        event: DomainEvent,
        notification: Option<Notification>,
    ) -> Vec<PostCommitActivityWarning> {
        let mut warnings = Vec::new();
        if self.audit.append(audit).await.is_err() {
            warnings.push(warning(
                "interaction_post_commit_audit_failed",
                "The operation completed, but its external audit record was not appended.",
            ));
        }
        if self
            .events
            .outbox
            .enqueue(OutboxRecord::pending(event))
            .await
            .is_err()
        {
            warnings.push(warning(
                "interaction_post_commit_event_failed",
                "The operation completed, but its external event was not queued.",
            ));
        }
        if let Some(notification) = notification
            && self.notifications.send(notification).await.is_err()
        {
            warnings.push(warning(
                "interaction_post_commit_notification_failed",
                "The operation completed, but its notification was not sent.",
            ));
        }
        warnings
    }
}

fn warning(code: &str, detail: &str) -> PostCommitActivityWarning {
    PostCommitActivityWarning {
        code: code.into(),
        detail: detail.into(),
    }
}