lenso 0.3.45

Public facade for authoring and hosting Lenso backend modules.
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

//! Atomic transaction boundary for host-owned linked modules.

use platform_core::{
    OutboxPublisher, begin_transaction, claim_idempotency_key_in_tx, commit_transaction,
    rollback_transaction,
};

pub use platform_core::{
    AppError, AppResult, DbPool, DbTransaction, IdempotencyClaim, IdempotencyKey, OutboxEvent,
};

#[derive(Debug)]
pub struct LinkedTransaction<'a> {
    transaction: DbTransaction<'a>,
}

impl<'a> LinkedTransaction<'a> {
    pub async fn begin(pool: &'a DbPool) -> AppResult<Self> {
        let transaction = begin_transaction(pool).await?;
        Ok(Self { transaction })
    }

    pub async fn claim_idempotency_key(
        &mut self,
        key: &IdempotencyKey,
    ) -> AppResult<IdempotencyClaim> {
        claim_idempotency_key_in_tx(&mut self.transaction, key).await
    }

    /// Access the caller transaction for app-owned business SQL.
    ///
    /// The facade intentionally does not provide repositories or query builders.
    pub fn sql(&mut self) -> &mut DbTransaction<'a> {
        &mut self.transaction
    }

    pub async fn publish_outbox(&mut self, event: &OutboxEvent) -> AppResult<()> {
        OutboxPublisher
            .publish_in_tx(&mut self.transaction, event)
            .await
    }

    pub async fn commit(self) -> AppResult<()> {
        commit_transaction(self.transaction).await
    }

    pub async fn rollback(self) -> AppResult<()> {
        rollback_transaction(self.transaction).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn minimal_feature_exposes_the_public_transaction_contract() {
        let key = IdempotencyKey::parse("example:create", "request-1").unwrap();
        assert_eq!(key.scope(), "example:create");
        assert_eq!(key.value(), "request-1");
        let _claim = IdempotencyClaim::Acquired;
        let _begin = LinkedTransaction::begin;
    }
}