1use anyhow::Context as _;
2use axum::Router;
3use axum::http::{HeaderName, HeaderValue, Method, header};
4use axum::middleware;
5use axum::response::Html;
6use platform_core::{
7 AppConfig, AppContext, LoggingEventPublisher, PostgresRuntimeConfigProvider,
8 RuntimeConfigRegistry, Shutdown, connect_pool, connect_redis, telemetry,
9};
10use platform_http::request_context_middleware;
11use std::net::SocketAddr;
12use std::path::PathBuf;
13use std::sync::Arc;
14use tower_http::cors::CorsLayer;
15use tower_http::services::{ServeDir, ServeFile};
16use tracing::info;
17
18pub mod openapi;
19
20pub use openapi::openapi_document;
21
22pub async fn run_from_env() -> anyhow::Result<()> {
23 run_from_env_with_composition(lenso_bootstrap::HostComposition::default()).await
24}
25
26pub async fn run_from_env_with_composition(
27 composition: lenso_bootstrap::HostComposition,
28) -> anyhow::Result<()> {
29 let config = AppConfig::try_from_env().context("invalid application configuration")?;
30 telemetry::init(&config.telemetry)?;
31
32 let db = connect_pool(&config.database).await?;
33 let redis = connect_redis(&config.redis).await?;
34 let mut ctx = AppContext::new(config, db, Arc::new(LoggingEventPublisher)).with_redis(redis);
35
36 let descriptors =
37 lenso_bootstrap::runtime_config_descriptors_with_composition(&ctx, &composition)
38 .context("failed to collect runtime-config descriptors")?;
39 let groups =
40 lenso_bootstrap::runtime_config_group_descriptors_with_composition(&ctx, &composition)
41 .context("failed to collect runtime-config groups")?;
42 let registry = RuntimeConfigRegistry::try_new_with_groups(descriptors, groups)
43 .context("duplicate runtime-config descriptor registered")?;
44 platform_admin::install_runtime_config_registry(registry.clone());
45 let runtime_config =
46 PostgresRuntimeConfigProvider::connect(ctx.db.clone(), Arc::new(registry), "api")
47 .await
48 .context("failed to load runtime-config snapshot")?;
49 runtime_config.spawn_listener();
50 ctx = ctx.with_runtime_config_provider(runtime_config);
51
52 let _remote_services = lenso_bootstrap::start_installed_remote_module_services(&ctx)
53 .await
54 .context("failed to start remote module services")?;
55
56 let admin_modules = lenso_bootstrap::load_admin_modules_with_composition(&ctx, &composition)
57 .await
58 .context("failed to load admin modules")?;
59 platform_admin_data::install_admin_modules(admin_modules);
60 let admin_module_metadata =
61 lenso_bootstrap::load_admin_module_metadata_with_composition(&ctx, &composition)
62 .await
63 .context("failed to load admin module metadata")?;
64 install_admin_module_metadata(admin_module_metadata);
65 let remote_http_proxy_registry = lenso_bootstrap::load_remote_http_proxy_registry(&ctx)
66 .await
67 .context("failed to load remote HTTP proxy registry")?;
68 platform_module_remote::install_remote_http_proxy_registry(remote_http_proxy_registry);
69
70 let admin_refresh_ctx = ctx.clone();
71 let admin_refresh_composition = composition.clone();
72 platform_admin_data::install_admin_module_refresh_fn(move || {
73 let ctx = admin_refresh_ctx.clone();
74 let composition = admin_refresh_composition.clone();
75 async move { lenso_bootstrap::load_admin_modules_with_composition(&ctx, &composition).await }
76 });
77 let admin_metadata_refresh_ctx = ctx.clone();
78 let admin_metadata_refresh_composition = composition.clone();
79 platform_admin_data::install_admin_module_metadata_refresh_fn(move || {
80 let ctx = admin_metadata_refresh_ctx.clone();
81 let composition = admin_metadata_refresh_composition.clone();
82 async move {
83 let metadata =
84 lenso_bootstrap::load_admin_module_metadata_with_composition(&ctx, &composition)
85 .await?;
86 install_platform_admin_catalogs(&metadata);
87 Ok(metadata)
88 }
89 });
90
91 let app = try_build_router_with_composition(ctx.clone(), &composition)
92 .context("failed to build API router")?;
93 let address: SocketAddr = format!("{}:{}", ctx.config.http.host, ctx.config.http.port)
94 .parse()
95 .context("invalid HTTP bind address")?;
96
97 info!(%address, "starting API server");
98 let listener = tokio::net::TcpListener::bind(address).await?;
99
100 let shutdown = ctx.shutdown.clone();
101 axum::serve(
102 listener,
103 app.into_make_service_with_connect_info::<SocketAddr>(),
104 )
105 .with_graceful_shutdown(async move {
106 let mut shutdown_rx = shutdown.subscribe();
107 tokio::select! {
108 () = Shutdown::wait_for_signal() => {},
109 changed = shutdown_rx.changed() => {
110 let _ = changed;
111 },
112 }
113 })
114 .await?;
115
116 Ok(())
117}
118
119pub fn build_router(ctx: AppContext) -> Router {
120 try_build_router(ctx).expect("Runtime API router should build with a valid composition profile")
121}
122
123pub fn try_build_router(ctx: AppContext) -> platform_core::AppResult<Router> {
124 try_build_router_with_composition(ctx, &lenso_bootstrap::HostComposition::default())
125}
126
127pub fn try_build_router_with_composition(
128 mut ctx: AppContext,
129 composition: &lenso_bootstrap::HostComposition,
130) -> platform_core::AppResult<Router> {
131 if let Some(actor_resolver) =
132 lenso_bootstrap::auth_actor_resolver_for_context_with_composition(&ctx, composition)?
133 {
134 ctx = ctx.with_actor_resolver(actor_resolver);
135 }
136 let host_wiring = lenso_bootstrap::host_wiring_for_context_with_composition(&ctx, composition)?;
137 install_default_platform_admin_catalogs(&ctx, composition)?;
138 let (router, mut document) =
139 openapi::api_router_for_context_with_composition(&ctx, composition)?.split_for_parts();
140 openapi::normalize_error_response_content_types(&mut document);
141 let document = Arc::new(document);
142 let console_dist_dir = ctx.config.console.dist_dir.clone();
143 let console_index = PathBuf::from(&console_dist_dir).join("index.html");
144
145 Ok(router
146 .route("/docs", axum::routing::get(scalar_docs))
147 .route("/openapi.json", axum::routing::get(serve_openapi))
148 .nest_service(
149 "/console/extensions",
150 ServeDir::new(ctx.config.console.extensions_dir.clone()),
151 )
152 .nest_service(
153 "/console",
154 ServeDir::new(console_dist_dir).fallback(ServeFile::new(console_index)),
155 )
156 .layer(axum::Extension(document))
157 .layer(axum::Extension(host_wiring.auth_session_policy()))
158 .layer(middleware::from_fn_with_state(
159 ctx.clone(),
160 request_context_middleware,
161 ))
162 .layer(cors_layer(&ctx))
163 .with_state(ctx))
164}
165
166fn install_default_platform_admin_catalogs(
167 ctx: &AppContext,
168 composition: &lenso_bootstrap::HostComposition,
169) -> platform_core::AppResult<()> {
170 lenso_bootstrap::install_default_story_display_catalog_with_composition(ctx, composition)?;
171 platform_admin::install_default_runtime_function_declarations(
172 platform_admin::runtime_function_declarations_from_modules(
173 lenso_bootstrap::linked_runtime_function_declaration_sources_for_context_with_composition(
174 ctx,
175 composition,
176 )?,
177 ),
178 );
179 Ok(())
180}
181
182fn install_admin_module_metadata(metadata: Vec<platform_admin_data::AdminModuleMetadata>) {
183 install_platform_admin_catalogs(&metadata);
184 platform_admin_data::install_admin_module_metadata(metadata);
185}
186
187fn install_platform_admin_catalogs(metadata: &[platform_admin_data::AdminModuleMetadata]) {
188 lenso_bootstrap::install_story_display_catalog(metadata);
189 platform_admin::install_runtime_function_declarations(
190 platform_admin::runtime_function_declarations_from_modules(
191 lenso_bootstrap::runtime_function_declaration_sources_from_metadata(metadata),
192 ),
193 );
194}
195
196async fn scalar_docs() -> ([(HeaderName, HeaderValue); 3], Html<&'static str>) {
197 (
198 [
199 (
200 HeaderName::from_static("content-security-policy"),
201 HeaderValue::from_static(SCALAR_DOCS_CSP),
202 ),
203 (
204 HeaderName::from_static("referrer-policy"),
205 HeaderValue::from_static("no-referrer"),
206 ),
207 (
208 HeaderName::from_static("x-content-type-options"),
209 HeaderValue::from_static("nosniff"),
210 ),
211 ],
212 Html(SCALAR_DOCS_HTML),
213 )
214}
215
216async fn serve_openapi(
217 axum::Extension(document): axum::Extension<Arc<utoipa::openapi::OpenApi>>,
218) -> axum::Json<utoipa::openapi::OpenApi> {
219 axum::Json((*document).clone())
220}
221
222fn cors_layer(ctx: &AppContext) -> CorsLayer {
223 let origins: Vec<HeaderValue> = ctx
224 .config
225 .http
226 .cors_allowed_origins
227 .iter()
228 .filter_map(|origin| origin.parse().ok())
229 .collect();
230
231 CorsLayer::new()
232 .allow_origin(origins)
233 .allow_methods([
234 Method::GET,
235 Method::POST,
236 Method::PUT,
237 Method::PATCH,
238 Method::DELETE,
239 Method::OPTIONS,
240 ])
241 .allow_headers([header::ACCEPT, header::AUTHORIZATION, header::CONTENT_TYPE])
242}
243
244const SCALAR_DOCS_CSP: &str = "default-src 'none'; script-src https://cdn.jsdelivr.net 'sha256-wT12sSim/cr/4i3SfCUXmSC76WSRp+uWevWj0uNZ/vU='; style-src 'unsafe-inline'; connect-src 'self'; img-src 'self' data: https:; font-src 'self' data: https:; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
245
246const SCALAR_DOCS_HTML: &str = r##"<!doctype html>
247<html lang="en">
248 <head>
249 <meta charset="utf-8" />
250 <meta name="viewport" content="width=device-width, initial-scale=1" />
251 <title>Lenso API Docs</title>
252 <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference@1.62.5" integrity="sha384-jVBCKhcCfx34USN27x4iQK1SBNdL/HxKq3KuBAxTS4WPaP5w80K4fjpwB+DezJL5" crossorigin="anonymous"></script>
253 <style>
254 body {
255 margin: 0;
256 }
257 </style>
258 </head>
259 <body>
260 <div id="app"></div>
261 <script>Scalar.createApiReference("#app",{url:"/openapi.json",theme:"default"});</script>
262 </body>
263</html>
264"##;