lenso-platform-module 0.1.26

Module behavior seams for the Lenso backend framework.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::{LinkedBinding, Module, ModuleManifest};
use platform_core::{AppContext, AppResult, Migration};
use std::any::{Any, TypeId};
use std::sync::Arc;

#[derive(Clone)]
pub struct HostContribution {
    type_id: TypeId,
    value: Arc<dyn Any + Send + Sync>,
}

impl std::fmt::Debug for HostContribution {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("HostContribution")
            .field("type_id", &self.type_id)
            .finish_non_exhaustive()
    }
}

impl HostContribution {
    pub fn typed<T>(value: T) -> Self
    where
        T: Send + Sync + 'static,
    {
        Self {
            type_id: TypeId::of::<T>(),
            value: Arc::new(value),
        }
    }

    pub fn get<T>(&self) -> Option<&T>
    where
        T: Send + Sync + 'static,
    {
        (self.type_id == TypeId::of::<T>())
            .then(|| self.value.downcast_ref::<T>())
            .flatten()
    }
}

#[derive(Debug, Clone)]
pub struct HostLinkedModule {
    pub module_name: &'static str,
    pub manifest: fn() -> ModuleManifest,
    pub load: Option<fn(&AppContext) -> Module>,
    try_load: Option<fn(&AppContext) -> AppResult<Module>>,
    pub http_binding: Option<fn() -> LinkedBinding>,
    pub migrations: &'static [Migration],
    contributions: Vec<HostContribution>,
}

impl HostLinkedModule {
    #[must_use]
    pub fn manifest_only(
        module_name: &'static str,
        manifest: fn() -> ModuleManifest,
        migrations: &'static [Migration],
    ) -> Self {
        Self {
            module_name,
            manifest,
            load: None,
            try_load: None,
            http_binding: None,
            migrations,
            contributions: Vec::new(),
        }
    }

    #[must_use]
    pub fn linked(
        module_name: &'static str,
        manifest: fn() -> ModuleManifest,
        load: fn(&AppContext) -> Module,
        migrations: &'static [Migration],
    ) -> Self {
        Self {
            module_name,
            manifest,
            load: Some(load),
            try_load: None,
            http_binding: None,
            migrations,
            contributions: Vec::new(),
        }
    }

    /// Compose a linked Module whose context-bound setup can reject invalid
    /// deployment configuration without panicking.
    #[must_use]
    pub fn try_linked(
        module_name: &'static str,
        manifest: fn() -> ModuleManifest,
        load: fn(&AppContext) -> AppResult<Module>,
        migrations: &'static [Migration],
    ) -> Self {
        Self {
            module_name,
            manifest,
            load: None,
            try_load: Some(load),
            http_binding: None,
            migrations,
            contributions: Vec::new(),
        }
    }

    #[doc(hidden)]
    pub fn try_load_module(&self, context: &AppContext) -> AppResult<Module> {
        if let Some(load) = self.try_load {
            return load(context);
        }
        Ok(match self.load {
            Some(load) => load(context),
            None => Module::linked((self.manifest)(), LinkedBinding::builder().build()),
        })
    }

    #[must_use]
    pub fn with_http_binding(mut self, http_binding: fn() -> LinkedBinding) -> Self {
        self.http_binding = Some(http_binding);
        self
    }

    #[must_use]
    pub fn with_contribution<T>(mut self, contribution: T) -> Self
    where
        T: Send + Sync + 'static,
    {
        self.contributions
            .push(HostContribution::typed(contribution));
        self
    }

    pub fn contributions<T>(&self) -> impl Iterator<Item = &T>
    where
        T: Send + Sync + 'static,
    {
        self.contributions
            .iter()
            .filter_map(HostContribution::get::<T>)
    }
}