Add AssetType enum and prerendered path transformation

Add AssetType enum (Immutable/Static/Prerendered) to map route priorities
in a type-safe way. Transform paths for prerendered routes by adding .html
extension when no extension is present (/ becomes /index.html, /about
becomes /about.html).

Author: max-lt

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-  "rust-analyzer.cargo.features": ["v8", "database"],
+  "rust-analyzer.cargo.features": ["v8", "database", "telemetry"],
   "cSpell.words": [
     "actix",
     "appender",

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "openworkers-runner"
-version = "0.12.10"
+version = "0.12.11"
 edition = "2024"
 license = "MIT"
 default-run = "openworkers-runner"

Cargo.toml

@@ -239,38 +239,40 @@ async fn handle_worker_request(
     // Handle resolution result
     let worker = match resolution {
         Some(res) => {
+            use openworkers_runner::BackendType;
+            use openworkers_runner::store::get_worker_with_bindings;
+
             // Project routing: check backend type
             if res.project_id.is_some() {
                 // Record backend type for telemetry
                 span.record("backend_type", tracing::field::display(&res.backend_type));
 
                 match res.backend_type {
-                    openworkers_runner::BackendType::Worker => {
+                    BackendType::Worker => {
                         if let Some(worker_id) = res.worker_id {
-                            let worker = openworkers_runner::store::get_worker_with_bindings(
-                                conn,
-                                WorkerIdentifier::Id(worker_id),
-                            )
-                            .await;
+                            let worker =
+                                get_worker_with_bindings(conn, WorkerIdentifier::Id(worker_id))
+                                    .await;
 
                             match worker {
                                 Some(w) => w,
                                 None => {
                                     return Ok(error_response_with_span(
                                         &span,
-                                        404,
-                                        "Worker not found",
+                                        500,
+                                        "Route has worker backend but worker not found",
                                     ));
                                 }
                             }
                         } else {
-                            return Ok(error_response(
+                            return Ok(error_response_with_span(
+                                &span,
                                 500,
                                 "Route has worker backend but no worker_id",
                             ));
                         }
                     }
-                    openworkers_runner::BackendType::Storage => {
+                    BackendType::Storage => {
                         use openworkers_core::{
                             HttpMethod, HttpRequest, OperationsHandler, RequestBody,
                         };
@@ -279,17 +281,28 @@ async fn handle_worker_request(
                         let storage_config_id = match &res.assets_storage_id {
                             Some(id) => id,
                             None => {
-                                return Ok(error_response(500, "ASSETS storage config not found"));
+                                return Ok(error_response_with_span(
+                                    &span,
+                                    500,
+                                    "ASSETS storage config not found",
+                                ));
                             }
                         };
 
                         // Load storage config
                         let storage_config =
                             openworkers_runner::store::get_storage_config(conn, storage_config_id)
                                 .await;
+
                         let storage_config = match storage_config {
                             Some(config) => config,
-                            None => return Ok(error_response(500, "Storage config not found")),
+                            None => {
+                                return Ok(error_response_with_span(
+                                    &span,
+                                    500,
+                                    "Storage config not found",
+                                ));
+                            }
                         };
 
                         // Create RunnerOperations with ASSETS binding to get limiters and stats
@@ -300,9 +313,24 @@ async fn handle_worker_request(
                             },
                         ]);
 
+                        // Transform path for prerendered routes (add .html extension)
+                        let request_path = if matches!(
+                            res.asset_type,
+                            Some(openworkers_runner::store::AssetType::Prerendered)
+                        ) && !path.contains('.')
+                        {
+                            if path == "/" || path.is_empty() {
+                                "/index.html".to_string()
+                            } else {
+                                format!("{}.html", path)
+                            }
+                        } else {
+                            path.to_string()
+                        };
+
                         // Create HttpRequest for binding fetch
                         let http_request = HttpRequest {
-                            url: path.to_string(),
+                            url: request_path,
                             method: HttpMethod::Get,
                             headers: std::collections::HashMap::new(),
                             body: RequestBody::None,
@@ -331,8 +359,12 @@ async fn handle_worker_request(
                                 );
 
                                 error!("Failed to fetch from storage: {}", e);
-                                span.record("response_status_code", 404u16);
-                                return Ok(error_response(404, "File not found"));
+                                span.record("response_status_code", 500u16);
+                                return Ok(error_response_with_span(
+                                    &span,
+                                    500,
+                                    "Failed to fetch from storage",
+                                ));
                             }
                         }
                     }
@@ -341,16 +373,18 @@ async fn handle_worker_request(
             // Standalone worker
             else if let Some(worker_id) = res.worker_id {
                 // Record backend type for standalone workers
-                span.record("backend_type", "worker");
-                let worker = openworkers_runner::store::get_worker_with_bindings(
-                    conn,
-                    WorkerIdentifier::Id(worker_id),
-                )
-                .await;
+                span.record("backend_type", tracing::field::display(BackendType::Worker));
+                let worker = get_worker_with_bindings(conn, WorkerIdentifier::Id(worker_id)).await;
 
                 match worker {
                     Some(w) => w,
-                    None => return Ok(error_response_with_span(&span, 404, "Worker not found")),
+                    None => {
+                        return Ok(error_response_with_span(
+                            &span,
+                            500,
+                            "Route has worker_id but worker not found",
+                        ));
+                    }
                 }
             } else {
                 return Ok(error_response_with_span(
@@ -363,8 +397,8 @@ async fn handle_worker_request(
         None => {
             return Ok(error_response_with_span(
                 &span,
-                404,
-                "Endpoint or route not found",
+                502,
+                "No worker or project found for request",
             ));
         }
     };

bin/main.rs

@@ -702,6 +702,26 @@ impl std::fmt::Display for BackendType {
     }
 }
 
+/// Asset type for storage routes (mapped from priority)
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum AssetType {
+    Immutable,   // priority 3 - hashed files, cache forever
+    Static,      // priority 2 - public files (robots.txt, favicon, etc.)
+    Prerendered, // priority 1 - HTML pages (need .html extension)
+}
+
+impl AssetType {
+    /// Map from database priority to asset type
+    pub fn from_priority(priority: i32) -> Option<Self> {
+        match priority {
+            3 => Some(AssetType::Immutable),
+            2 => Some(AssetType::Static),
+            1 => Some(AssetType::Prerendered),
+            _ => None,
+        }
+    }
+}
+
 /// Project route
 #[derive(Debug, Clone)]
 pub struct Route {
@@ -720,6 +740,7 @@ pub struct RequestResolution {
     pub project_id: Option<String>,
     pub backend_type: BackendType,
     pub assets_storage_id: Option<String>,
+    pub asset_type: Option<AssetType>,
 }
 
 /// Resolve worker from request in a single DB call
@@ -740,10 +761,11 @@ pub async fn resolve_worker_from_request(
         project_id: Option<String>,
         backend_type: BackendType,
         assets_storage_id: Option<String>,
+        priority: Option<i32>,
     }
 
     let result = sqlx::query_as::<_, ResolutionRow>(
-        "SELECT worker_id::text, project_id::text, backend_type, assets_storage_id::text
+        "SELECT worker_id::text, project_id::text, backend_type, assets_storage_id::text, priority
          FROM resolve_worker_from_request($1, $2::uuid, $3, $4)",
     )
     .bind(domain)
@@ -759,6 +781,7 @@ pub async fn resolve_worker_from_request(
             project_id: row.project_id,
             backend_type: row.backend_type,
             assets_storage_id: row.assets_storage_id,
+            asset_type: row.priority.and_then(AssetType::from_priority),
         }),
         Err(err) => {
             tracing::debug!("Failed to resolve request: {:?}", err);