systemprompt-runtime 0.1.22

Application runtime context and module registry for systemprompt.io
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

use axum::Router;
use std::collections::HashMap;

pub use systemprompt_models::modules::{Module, ModuleType, Modules, ServiceCategory};

use crate::AppContext;

#[derive(Debug)]
pub struct ModuleApiRegistry {
    registry: HashMap<String, ModuleApiImpl>,
}

#[derive(Debug)]
struct ModuleApiImpl {
    category: ServiceCategory,
    module_type: ModuleType,
    router_fn: fn(&AppContext) -> Router,
    auth_required: bool,
}

#[derive(Debug, Copy, Clone)]
pub struct ModuleApiRegistration {
    pub module_name: &'static str,
    pub category: ServiceCategory,
    pub module_type: ModuleType,
    pub router_fn: fn(&AppContext) -> Router,
    pub auth_required: bool,
}

inventory::collect!(ModuleApiRegistration);

#[derive(Debug, Clone, Copy)]
pub struct WellKnownRoute {
    pub path: &'static str,
    pub handler_fn: fn(&AppContext) -> Router,
    pub methods: &'static [axum::http::Method],
}

inventory::collect!(WellKnownRoute);

impl Default for ModuleApiRegistry {
    fn default() -> Self {
        Self::new()
    }
}

impl ModuleApiRegistry {
    pub fn new() -> Self {
        let mut registry = HashMap::new();

        for registration in inventory::iter::<ModuleApiRegistration> {
            let api_impl = ModuleApiImpl {
                category: registration.category,
                module_type: registration.module_type,
                router_fn: registration.router_fn,
                auth_required: registration.auth_required,
            };
            registry.insert(registration.module_name.to_string(), api_impl);
        }

        Self { registry }
    }

    pub fn get_routes(&self, module_name: &str, ctx: &AppContext) -> Option<Router> {
        self.registry
            .get(module_name)
            .map(|impl_| (impl_.router_fn)(ctx))
    }

    pub fn get_category(&self, module_name: &str) -> Option<ServiceCategory> {
        self.registry.get(module_name).map(|impl_| impl_.category)
    }

    pub fn get_module_type(&self, module_name: &str) -> Option<ModuleType> {
        self.registry
            .get(module_name)
            .map(|impl_| impl_.module_type)
    }

    pub fn get_auth_required(&self, module_name: &str) -> Option<bool> {
        self.registry
            .get(module_name)
            .map(|impl_| impl_.auth_required)
    }

    #[allow(private_interfaces)]
    pub fn get_registration(&self, module_name: &str) -> Option<&ModuleApiImpl> {
        self.registry.get(module_name)
    }

    pub fn modules_by_category(&self, category: ServiceCategory) -> Vec<String> {
        self.registry
            .iter()
            .filter(|(_, impl_)| matches!(impl_.category, c if c as u8 == category as u8))
            .map(|(name, _)| name.clone())
            .collect()
    }
}

pub trait ModuleRuntime {
    fn routes(&self, ctx: &AppContext, registry: &ModuleApiRegistry) -> Option<Router>;
    fn create_api_registry(&self) -> ModuleApiRegistry;
}

impl ModuleRuntime for Module {
    fn routes(&self, ctx: &AppContext, registry: &ModuleApiRegistry) -> Option<Router> {
        if let Some(api) = &self.api {
            if api.enabled {
                return registry.get_routes(&self.name, ctx);
            }
        }
        None
    }

    fn create_api_registry(&self) -> ModuleApiRegistry {
        ModuleApiRegistry::new()
    }
}

impl ModuleRuntime for Modules {
    fn routes(&self, _ctx: &AppContext, _registry: &ModuleApiRegistry) -> Option<Router> {
        None
    }

    fn create_api_registry(&self) -> ModuleApiRegistry {
        ModuleApiRegistry::new()
    }
}