syrup-rail-postgres 0.4.0

Canonical provider-neutral PostgreSQL schema contract and SQLx orchestration for Syrup Rail
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

use super::*;

impl SubscriptionBillingService {
    /// Applies an already-observed provider outcome without another submission.
    ///
    /// Reconciliation enters the same application authority as foreground
    /// enrollment but reconstructs its secret-free reservation from the exact
    /// durable attempt and canonical gateway account.
    pub async fn apply_reconciled_outcome(
        &self,
        billing_scope_id: BillingScopeId,
        attempt_id: PaymentAttemptId,
        outcome: &GatewayPaymentOutcome,
    ) -> Result<SubscriptionEnrollmentPaymentResult, SubscriptionBillingServiceError> {
        let mut transaction = self.pool.begin().await?;
        let attempt = crate::find_payment_attempt_by_id_in_transaction(
            &mut transaction,
            billing_scope_id,
            attempt_id,
        )
        .await?
        .ok_or(SubscriptionBillingServiceError::InvalidState(
            "reconciled subscription payment attempt was not found",
        ))?;
        transaction.commit().await?;
        match attempt.kind() {
            PaymentAttemptKind::SubscriptionInitial => {
                apply_reconciled_subscription_enrollment_gateway_outcome(
                    &self.pool,
                    self.coordinator.as_ref(),
                    billing_scope_id,
                    attempt_id,
                    outcome,
                )
                .await
            }
            PaymentAttemptKind::SubscriptionRecovery => {
                apply_reconciled_subscription_recovery_gateway_outcome(
                    &self.pool,
                    self.coordinator.as_ref(),
                    billing_scope_id,
                    attempt_id,
                    outcome,
                )
                .await
            }
            PaymentAttemptKind::SubscriptionRenewal => {
                apply_reconciled_subscription_renewal_gateway_outcome(
                    &self.pool,
                    self.coordinator.as_ref(),
                    billing_scope_id,
                    attempt_id,
                    outcome,
                )
                .await
            }
            PaymentAttemptKind::SubscriptionPaymentMethodUpdate => {
                apply_reconciled_subscription_payment_method_replacement_gateway_outcome(
                    &self.pool,
                    self.coordinator.as_ref(),
                    billing_scope_id,
                    attempt_id,
                    outcome,
                )
                .await
            }
            _ => Err(SubscriptionEnrollmentApplicationError::InvalidState(
                "attempt kind is not owned by the subscription billing service",
            )),
        }
        .map_err(Into::into)
    }
}