lenso 0.3.47

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
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
145
146
147
148
149
150

#![cfg(feature = "host")]

use async_trait::async_trait;
use lenso::host::outbox::{ClaimedOutboxEvent, EventHandler};
use lenso::host::runtime::{
    AppContext, AppResult, ExecutionContext, FunctionDefinition, FunctionHandler, LinkedBinding,
    Module, RetryPolicy, RuntimeDescriptor,
};
use lenso::host::{HostComposition, HostLinkedModule, Migration};
use lenso::{
    EventHandlerDeclaration, EventSurface, ModuleManifest, RuntimeFunctionDeclaration,
    RuntimeSurface, ScheduledFunctionDeclaration,
};
use platform_core::{
    AppConfig, AuthConfig, DatabaseConfig, HttpConfig, LoggingEventPublisher, ModuleSourcesConfig,
    RedisConfig, ServiceConfig, TelemetryConfig,
};
use serde_json::Value;
use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;

const FUNCTION_NAME: &str = "fixture.external_runtime.v1";
const EVENT_HANDLER_NAME: &str = "fixture.external_event_handler.v1";
const EVENT_NAME: &str = "fixture.external_event.v1";
const SCHEDULE_NAME: &str = "fixture-external-runtime";
const MIGRATIONS: &[Migration] = &[];

#[derive(Debug)]
struct ExternalHandler;

#[async_trait]
impl FunctionHandler for ExternalHandler {
    async fn call(&self, _ctx: ExecutionContext, input: Value) -> AppResult<Value> {
        Ok(input)
    }
}

#[derive(Debug)]
struct ExternalEventHandler;

#[async_trait]
impl EventHandler for ExternalEventHandler {
    fn handler_name(&self) -> &str {
        EVENT_HANDLER_NAME
    }

    fn event_name(&self) -> &str {
        EVENT_NAME
    }

    async fn handle(&self, _event: &ClaimedOutboxEvent) -> AppResult<()> {
        Ok(())
    }
}

fn manifest() -> ModuleManifest {
    ModuleManifest::builder("fixture/external-runtime")
        .events(EventSurface {
            handlers: vec![EventHandlerDeclaration {
                name: EVENT_HANDLER_NAME.to_owned(),
                event_name: EVENT_NAME.to_owned(),
                operation: None,
            }],
        })
        .runtime(RuntimeSurface {
            functions: vec![RuntimeFunctionDeclaration {
                name: FUNCTION_NAME.to_owned(),
                version: 1,
                queue: "fixture".to_owned(),
                input_schema: Some(format!("{FUNCTION_NAME}.input")),
                retry_policy: None,
                operation: None,
            }],
            schedules: vec![ScheduledFunctionDeclaration {
                name: SCHEDULE_NAME.to_owned(),
                function_name: FUNCTION_NAME.to_owned(),
                cron: "*/5 * * * *".to_owned(),
                input: serde_json::json!({"source": "fixture"}),
            }],
            workflows: Vec::new(),
        })
        .build()
}

fn binding() -> LinkedBinding {
    LinkedBinding::builder()
        .event_handlers(vec![Arc::new(ExternalEventHandler)])
        .runtime(RuntimeDescriptor {
            module: "external-runtime",
            functions: vec![FunctionDefinition {
                name: FUNCTION_NAME.to_owned(),
                version: 1,
                queue: "fixture".to_owned(),
                retry_policy: RetryPolicy::fixed(3, Duration::from_secs(1)),
                handler: Arc::new(ExternalHandler),
            }],
            ..RuntimeDescriptor::default()
        })
        .build()
}

fn load(_context: &AppContext) -> Module {
    Module::linked(manifest(), binding())
}

fn test_context() -> AppContext {
    let db = platform_core::DbPool::connect_lazy("postgres://localhost/lenso_test")
        .expect("lazy test pool");
    AppContext::new(
        AppConfig {
            service: ServiceConfig::default(),
            database: DatabaseConfig {
                url: "postgres://localhost/lenso_test".to_owned(),
                max_connections: 1,
            },
            redis: RedisConfig::default(),
            http: HttpConfig::default(),
            telemetry: TelemetryConfig::default(),
            auth: AuthConfig::default(),
            module_sources: ModuleSourcesConfig {
                linked_profile: "core".to_owned(),
            },
            modules: BTreeMap::new(),
        },
        db,
        Arc::new(LoggingEventPublisher),
    )
}

#[tokio::test]
async fn external_crate_can_author_runtime_behavior_through_the_lenso_facade() {
    let linked = HostLinkedModule::linked("external-runtime", manifest, load, MIGRATIONS);
    let context = test_context();
    let composition = HostComposition::new().with_linked_module(linked);
    let modules = lenso_bootstrap::modules_for_config_with_composition(&context, &composition)
        .expect("host should load external linked module");
    let registry = lenso_bootstrap::try_function_registry(&modules)
        .expect("host should admit manifest-declared runtime binding");
    let event_handlers = lenso_bootstrap::try_event_handlers(&modules)
        .expect("host should admit manifest-declared Event binding");
    let schedules = lenso_bootstrap::scheduled_functions(&modules, &registry)
        .expect("host should collect manifest-declared schedule");

    assert!(registry.get(FUNCTION_NAME).is_some());
    assert_eq!(event_handlers.handler_count(EVENT_NAME), 1);
    assert_eq!(schedules.len(), 1);
    assert_eq!(schedules[0].schedule_name, SCHEDULE_NAME);
    assert_eq!(schedules[0].function_name, FUNCTION_NAME);
}