systemprompt_api/services/static_content/static_files/

mod.rs

//! Static-file request handling with caching and content fallback.
//!
//! [`serve_static_content`] routes an incoming URI to a static asset,
//! prerendered HTML page, metadata file, or the content-repository fallback,
//! applying the appropriate cache policy and `ETag` for each.
//! [`StaticContentState`] carries the app context, matcher, and route
//! classifier into the handler.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

mod cache;
mod responses;

pub use cache::{
    CACHE_HTML, CACHE_METADATA, CACHE_STATIC_ASSET, CACHE_STATIC_ASSET_REVALIDATE,
    asset_cache_policy, compute_etag,
};

use axum::extract::State;
use axum::http::{HeaderMap, Uri};
use axum::response::IntoResponse;
use std::sync::Arc;
use systemprompt_traits::RepositoryError;

use super::config::StaticContentMatcher;
use cache::serve_cached_file;
use responses::{not_found_response, not_prerendered_response};
use systemprompt_files::FilesConfig;
use systemprompt_identifiers::{LocaleCode, SourceId};
use systemprompt_models::api::ApiError;
use systemprompt_models::{RouteClassifier, RouteType};
use systemprompt_runtime::AppContext;

use crate::error::ApiHttpError;

#[derive(Clone, Debug)]
pub struct StaticContentState {
    pub ctx: Arc<AppContext>,
    pub matcher: Arc<StaticContentMatcher>,
    pub route_classifier: Arc<RouteClassifier>,
}

pub async fn serve_static_content(
    State(state): State<StaticContentState>,
    uri: Uri,
    headers: HeaderMap,
    _req_ctx: Option<axum::Extension<systemprompt_models::RequestContext>>,
) -> impl IntoResponse {
    let dist_dir = state.ctx.app_paths().web().dist().to_path_buf();

    let path = uri.path();

    if matches!(
        state.route_classifier.classify(path, "GET"),
        RouteType::StaticAsset { .. }
    ) {
        return serve_static_asset(path, &dist_dir, &headers).await;
    }

    if path == "/" {
        return serve_cached_file(
            &dist_dir.join("index.html"),
            &headers,
            "text/html; charset=utf-8",
            CACHE_HTML,
        )
        .await;
    }

    if matches!(
        path,
        "/sitemap.xml" | "/robots.txt" | "/llms.txt" | "/feed.xml"
    ) {
        return serve_metadata_file(path, &dist_dir, &headers).await;
    }

    let trimmed_path = path.trim_start_matches('/');
    let parent_route_path = dist_dir.join(trimmed_path).join("index.html");
    if parent_route_path.exists() {
        return serve_cached_file(
            &parent_route_path,
            &headers,
            "text/html; charset=utf-8",
            CACHE_HTML,
        )
        .await;
    }

    if let Some((slug, source_id)) = state.matcher.matches(path) {
        let req = ContentPageRequest {
            path,
            trimmed_path,
            slug: &slug,
            source_id: &source_id,
            dist_dir: &dist_dir,
            headers: &headers,
        };
        return serve_content_page(req, &state.ctx).await;
    }

    not_found_response(&dist_dir, &headers).await
}

async fn serve_static_asset(
    path: &str,
    dist_dir: &std::path::Path,
    headers: &HeaderMap,
) -> axum::response::Response {
    let files_config = match FilesConfig::get() {
        Ok(config) => config,
        Err(e) => {
            return ApiHttpError::from(ApiError::internal("FilesConfig not initialized", e))
                .into_response();
        },
    };

    let files_prefix = format!("{}/", files_config.url_prefix());
    let stored_file = path.strip_prefix(&files_prefix);
    let asset_path = stored_file.map_or_else(
        || dist_dir.join(path.trim_start_matches('/')),
        |relative_path| files_config.files().join(relative_path),
    );

    if asset_path.exists() && asset_path.is_file() {
        let mime_type = systemprompt_models::mime::http_content_type(&asset_path);
        let cache_control = stored_file
            .and_then(|_| files_config.cache_control())
            .unwrap_or_else(|| asset_cache_policy(&asset_path));
        return serve_cached_file(&asset_path, headers, mime_type, cache_control).await;
    }

    ApiHttpError::not_found("Asset not found").into_response()
}

async fn serve_metadata_file(
    path: &str,
    dist_dir: &std::path::Path,
    headers: &HeaderMap,
) -> axum::response::Response {
    let trimmed_path = path.trim_start_matches('/');
    let file_path = dist_dir.join(trimmed_path);
    if !file_path.exists() {
        return ApiHttpError::not_found("File not found").into_response();
    }

    let mime_type = if path == "/feed.xml" {
        "application/rss+xml; charset=utf-8"
    } else {
        systemprompt_models::mime::http_content_type_opt(&file_path)
            .unwrap_or("text/plain; charset=utf-8")
    };

    serve_cached_file(&file_path, headers, mime_type, CACHE_METADATA).await
}

struct ContentPageRequest<'a> {
    path: &'a str,
    trimmed_path: &'a str,
    slug: &'a str,
    source_id: &'a SourceId,
    dist_dir: &'a std::path::Path,
    headers: &'a HeaderMap,
}

async fn serve_content_page(
    req: ContentPageRequest<'_>,
    ctx: &AppContext,
) -> axum::response::Response {
    let exact_path = req.dist_dir.join(req.trimmed_path);
    if exact_path.exists() && exact_path.is_file() {
        return serve_cached_file(
            &exact_path,
            req.headers,
            "text/html; charset=utf-8",
            CACHE_HTML,
        )
        .await;
    }

    let index_path = req.dist_dir.join(req.trimmed_path).join("index.html");
    if index_path.exists() {
        return serve_cached_file(
            &index_path,
            req.headers,
            "text/html; charset=utf-8",
            CACHE_HTML,
        )
        .await;
    }

    let content_repo = &ctx.content_repositories().content;

    match content_repo
        .find_by_source_and_slug(req.source_id, req.slug, &LocaleCode::english())
        .await
    {
        Ok(Some(_)) => not_prerendered_response(req.path, req.slug),
        Ok(None) => not_found_response(req.dist_dir, req.headers).await,
        Err(e) => ApiHttpError::from(RepositoryError::from(e)).into_response(),
    }
}