backbone-integrations 0.6.0

Integration registry: connectors, integration accounts and an idempotent inbound event lane, with one OAuth flow (HMAC-bound state, PKCE)
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
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
111
112

//! Integrations Module Handlers
//!
//! Generated by metaphor-schema. Do not edit manually.
//!
//! This module provides:
//! - AppState dependency injection container
//! - Custom handler integration points

use std::sync::Arc;

// Import all services
use crate::application::service::IntegrationConnectorService;
use crate::application::service::IntegrationAccountService;
use crate::application::service::IntegrationEventService;

/// Application state for dependency injection.
///
/// This struct holds references to all module services
/// and is passed to HTTP handlers via Axum's State extractor.
///
/// # Example
///
/// ```ignore
/// use axum::extract::State;
///
/// async fn custom_handler(
///     State(state): State<AppState>,
/// ) -> impl IntoResponse {
///     // Access services via state
/// }
/// ```
#[derive(Clone)]
pub struct AppState {
    /// IntegrationConnector service
    pub integration_connector_service: Arc<IntegrationConnectorService>,
    /// IntegrationAccount service
    pub integration_account_service: Arc<IntegrationAccountService>,
    /// IntegrationEvent service
    pub integration_event_service: Arc<IntegrationEventService>,
}

impl AppState {
    /// Create a new AppState with all services.
    pub fn new(
        integration_connector_service: Arc<IntegrationConnectorService>,
        integration_account_service: Arc<IntegrationAccountService>,
        integration_event_service: Arc<IntegrationEventService>
    ) -> Self {
        Self {
            integration_connector_service,
            integration_account_service,
            integration_event_service,
        }
    }

    /// Create AppState from module instance.
    pub fn from_module(module: &crate::IntegrationsModule) -> Self {
        Self {
            integration_connector_service: module.integration_connector_service.clone(),
            integration_account_service: module.integration_account_service.clone(),
            integration_event_service: module.integration_event_service.clone(),
        }
    }
}

/// Builder for AppState.
///
/// Allows incremental construction of AppState.
#[derive(Default)]
pub struct AppStateBuilder {
    integration_connector_service: Option<Arc<IntegrationConnectorService>>,
    integration_account_service: Option<Arc<IntegrationAccountService>>,
    integration_event_service: Option<Arc<IntegrationEventService>>,
}

impl AppStateBuilder {
    /// Create a new builder.
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the IntegrationConnector service.
    pub fn with_integration_connector_service(mut self, service: Arc<IntegrationConnectorService>) -> Self {
        self.integration_connector_service = Some(service);
        self
    }

    /// Set the IntegrationAccount service.
    pub fn with_integration_account_service(mut self, service: Arc<IntegrationAccountService>) -> Self {
        self.integration_account_service = Some(service);
        self
    }

    /// Set the IntegrationEvent service.
    pub fn with_integration_event_service(mut self, service: Arc<IntegrationEventService>) -> Self {
        self.integration_event_service = Some(service);
        self
    }

    /// Build the AppState.
    ///
    /// # Panics
    ///
    /// Panics if any required service is not set.
    pub fn build(self) -> AppState {
        AppState {
            integration_connector_service: self.integration_connector_service.expect("integration_connector_service is required"),
            integration_account_service: self.integration_account_service.expect("integration_account_service is required"),
            integration_event_service: self.integration_event_service.expect("integration_event_service is required"),
        }
    }
}