aviso-server 0.6.0

Notification service for data-driven workflows with live and replay APIs.
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

// (C) Copyright 2024- ECMWF and individual contributors.
//
// This software is licensed under the terms of the Apache Licence Version 2.0
// which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
// In applying this licence, ECMWF does not waive the privileges and immunities
// granted to it by virtue of its status as an intergovernmental organisation nor
// does it submit to any jurisdiction.

//! Schema registry for notification processing.

use anyhow::Result;
use std::collections::HashMap;

use crate::configuration::EventSchema;

/// In-memory lookup map for event schemas.
#[derive(Clone)]
pub struct NotificationRegistry {
    /// Event type -> schema.
    schemas: HashMap<String, EventSchema>,
    /// When true, the registry rejects event types that are not in `schemas`.
    /// When false, callers fall back to generic processing for unknown event types.
    strict: bool,
}

impl Default for NotificationRegistry {
    fn default() -> Self {
        Self::new()
    }
}

impl NotificationRegistry {
    /// Create an empty, non-strict registry.
    pub fn new() -> Self {
        Self {
            schemas: HashMap::new(),
            strict: false,
        }
    }

    /// Build registry from config schemas without strict enforcement.
    /// Prefer `from_config_with_strict` in production code paths so callers
    /// stay explicit about the policy.
    pub fn from_config(schemas: &HashMap<String, EventSchema>) -> Self {
        Self::from_config_with_strict(schemas, false)
    }

    /// Build registry from config schemas with an explicit strict-mode flag.
    pub fn from_config_with_strict(schemas: &HashMap<String, EventSchema>, strict: bool) -> Self {
        Self {
            schemas: schemas.clone(),
            strict,
        }
    }

    /// Get schema for event type, if present.
    pub fn get_schema(&self, event_type: &str) -> Option<&EventSchema> {
        self.schemas.get(event_type)
    }

    /// Check schema presence for event type.
    pub fn has_schema(&self, event_type: &str) -> bool {
        self.schemas.contains_key(event_type)
    }

    /// Whether unknown event types must be rejected instead of falling back
    /// to generic processing.
    pub fn is_strict(&self) -> bool {
        self.strict
    }

    /// List configured event types in a deterministic (sorted) order.
    pub fn get_schema_names(&self) -> Vec<String> {
        let mut names: Vec<String> = self.schemas.keys().cloned().collect();
        names.sort();
        names
    }

    /// Get identifier field names for an event type.
    /// Unknown event types return an empty list.
    pub fn get_identifier_keys(&self, event_type: &str) -> Result<Vec<String>> {
        if let Some(schema) = self.get_schema(event_type) {
            Ok(schema.identifier.keys().cloned().collect())
        } else {
            Ok(Vec::new())
        }
    }

    /// Get required identifier field names for an event type.
    pub fn get_required_identifier_keys(&self, event_type: &str) -> Result<Vec<String>> {
        if let Some(schema) = self.get_schema(event_type) {
            let required_keys: Vec<String> = schema
                .identifier
                .iter()
                .filter_map(|(key, field_config)| {
                    let is_required = field_config.is_required();
                    if is_required { Some(key.clone()) } else { None }
                })
                .collect();
            Ok(required_keys)
        } else {
            Ok(Vec::new())
        }
    }

    /// Get the full schema map.
    pub fn get_whole_schema(&self) -> &HashMap<String, EventSchema> {
        &self.schemas
    }
}