use std::sync::Arc;
use serde::{Deserialize, Serialize};
use crate::TxId;
pub const AUDIT_EVENT_SCHEMA_VERSION: u16 = 1;
pub const ENTERPRISE_STATUS_SCHEMA_VERSION: u16 = 1;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnterpriseConfig {
pub database_id: String,
pub environment: String,
}
impl EnterpriseConfig {
pub fn new(
database_id: impl Into<String>,
environment: impl Into<String>,
) -> Result<Self, String> {
let database_id = database_id.into();
let environment = environment.into();
if database_id.trim().is_empty() {
return Err("database_id must not be empty".into());
}
if environment.trim().is_empty() {
return Err("environment must not be empty".into());
}
if database_id.len() > 256 || environment.len() > 64 {
return Err("enterprise identity exceeds its length limit".into());
}
Ok(Self {
database_id,
environment,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum AuditEventKind {
TransactionBegan,
TransactionCommitted,
TransactionRolledBack,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AuditEvent {
pub schema_version: u16,
pub database_id: String,
pub environment: String,
pub kind: AuditEventKind,
pub transaction_id: TxId,
}
impl AuditEvent {
pub(crate) fn pending(kind: AuditEventKind, transaction_id: TxId) -> PendingAuditEvent {
PendingAuditEvent {
kind,
transaction_id,
}
}
}
pub(crate) struct PendingAuditEvent {
kind: AuditEventKind,
transaction_id: TxId,
}
pub trait AuditSink: Send + Sync {
fn record(&self, event: &AuditEvent);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnterpriseCapabilities {
pub schema_version: u16,
pub crash_safe_transactions: bool,
pub transaction_audit_events: bool,
pub encryption_at_rest: bool,
pub replication_stream: bool,
pub identity_provider: bool,
}
impl EnterpriseCapabilities {
pub const fn current() -> Self {
Self {
schema_version: 1,
crash_safe_transactions: true,
transaction_audit_events: true,
encryption_at_rest: false,
replication_stream: false,
identity_provider: false,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct EnterpriseStatus {
pub schema_version: u16,
pub engine_version: String,
pub format_version: u16,
pub deployment: Option<EnterpriseConfig>,
pub current_transaction_id: TxId,
pub capabilities: EnterpriseCapabilities,
}
impl EnterpriseStatus {
pub(crate) fn current(
deployment: Option<EnterpriseConfig>,
current_transaction_id: TxId,
) -> Self {
Self {
schema_version: ENTERPRISE_STATUS_SCHEMA_VERSION,
engine_version: env!("CARGO_PKG_VERSION").to_owned(),
format_version: crate::FORMAT_VERSION,
deployment,
current_transaction_id,
capabilities: EnterpriseCapabilities::current(),
}
}
}
#[derive(Clone, Default)]
pub(crate) struct EnterpriseRuntime {
config: Option<EnterpriseConfig>,
sink: Option<Arc<dyn AuditSink>>,
}
impl EnterpriseRuntime {
pub(crate) fn configure(&mut self, config: EnterpriseConfig) {
self.config = Some(config);
}
pub(crate) fn config(&self) -> Option<&EnterpriseConfig> {
self.config.as_ref()
}
pub(crate) fn set_sink(&mut self, sink: Arc<dyn AuditSink>) {
self.sink = Some(sink);
}
pub(crate) fn emit(&self, pending: PendingAuditEvent) {
let (Some(config), Some(sink)) = (&self.config, &self.sink) else {
return;
};
sink.record(&AuditEvent {
schema_version: AUDIT_EVENT_SCHEMA_VERSION,
database_id: config.database_id.clone(),
environment: config.environment.clone(),
kind: pending.kind,
transaction_id: pending.transaction_id,
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Mutex;
#[derive(Default)]
struct Collector(Mutex<Vec<AuditEvent>>);
impl AuditSink for Collector {
fn record(&self, event: &AuditEvent) {
self.0.lock().unwrap().push(event.clone());
}
}
#[test]
fn rejects_empty_or_oversized_identity() {
assert!(EnterpriseConfig::new("", "production").is_err());
assert!(EnterpriseConfig::new("db", "").is_err());
assert!(EnterpriseConfig::new("x".repeat(257), "production").is_err());
}
#[test]
fn runtime_emits_only_after_configuration_and_sink() {
let sink = Arc::new(Collector::default());
let mut runtime = EnterpriseRuntime::default();
runtime.emit(AuditEvent::pending(AuditEventKind::TransactionBegan, 3));
runtime.set_sink(sink.clone());
runtime.configure(EnterpriseConfig::new("orders", "production").unwrap());
runtime.emit(AuditEvent::pending(AuditEventKind::TransactionCommitted, 4));
let events = sink.0.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(events[0].database_id, "orders");
assert_eq!(events[0].transaction_id, 4);
}
}