feat: development mode with hot-reloading

Cargo.toml

@@ -39,6 +39,7 @@ tower-service = "0.3.3"
 metassr-create = { path = "crates/metassr-create" }
 metassr-bundler = { path = "crates/metassr-bundler" }
 metassr-fs-analyzer = { path = "crates/metassr-fs-analyzer" }
+metassr-watcher = { path = "crates/metassr-watcher" }
 
 [build-dependencies]
 metacall-sys = "0.1.1"
@@ -54,6 +55,7 @@ members = [
     "crates/metassr-create",
     "crates/metassr-bundler",
     "crates/metassr-fs-analyzer",
+    "crates/metassr-watcher",
 ]
 
 [[bin]]

crates/metassr-build/Cargo.toml

@@ -15,3 +15,7 @@ lazy_static = "1.5.0"
 serde = { version = "1.0.207", features = ["derive"] }
 metassr-bundler = { path = "../metassr-bundler" }
 metassr-fs-analyzer = { path = "../metassr-fs-analyzer" }
+
+
+[build-dependencies]
+metacall-sys = "0.1.1"

crates/metassr-build/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    metacall_sys::build();
+}

crates/metassr-bundler/Cargo.toml

@@ -12,3 +12,7 @@ metacall = "0.5.1"
 metassr-utils = { path = "../metassr-utils" }
 serde_json = "1.0.128"
 tracing = "0.1.40"
+
+
+[build-dependencies]
+metacall-sys = "0.1.1"

crates/metassr-bundler/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    metacall_sys::build();
+}

crates/metassr-server/Cargo.toml

@@ -9,12 +9,20 @@ edition = "2021"
 anyhow = "1.0.82"
 axum = "0.7.5"
 chrono = "0.4.38"
+metacall = "0.4.1"
 metassr-build = { path = "../metassr-build" }
 metassr-fs-analyzer = { path = "../metassr-fs-analyzer" }
 metassr-utils = { path = "../metassr-utils" }
+metassr-watcher = { path = "../metassr-watcher" }
 serde_json = "1.0.122"
 tokio = { version = "1.36.0", features = ["full"] }
+tokio-tungstenite = "0.26.2"
+futures-util = "0.3.31"
+serde = "1.0.218"
 tower-http = { version = "0.5.2", features = ["trace", "fs"] }
 tower-layer = "0.3.3"
 tower-service = "0.3.3"
 tracing = "0.1.40"
+notify = { version = "8.0.0", features = ["serde"] }
+notify-debouncer-full = "0.6.0"
+walkdir = "2"

crates/metassr-server/src/lib.rs

@@ -1,30 +1,67 @@
 mod fallback;
 mod handler;
 mod layers;
+pub mod live_reload;
+pub mod rebuilder;
 mod router;
 
 use fallback::Fallback;
 use handler::PagesHandler;
 use layers::tracing::{LayerSetup, TracingLayer, TracingLayerOptions};
 
 use anyhow::Result;
+use axum::routing::get;
 use axum::{http::StatusCode, response::Redirect, Router};
+use live_reload::LiveReloadServer;
+use rebuilder::Rebuilder;
 use router::RouterMut;
-use std::path::{Path, PathBuf};
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use tokio::net::TcpListener;
 use tower_http::services::ServeDir;
-use tracing::info;
+use tracing::{debug, info};
+
+use crate::live_reload::inject_live_reload_script;
+
+#[derive(Debug, Clone, Copy)]
+pub enum ServerMode {
+    Development,
+    Production,
+}
+
+impl std::fmt::Display for ServerMode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match *self {
+            Self::Development => write!(f, "development"),
+            Self::Production => write!(f, "production"),
+        }
+    }
+}
 
 #[derive(Debug, Clone, Copy)]
 pub enum RunningType {
     StaticSiteGeneration,
     ServerSideRendering,
 }
 
+impl std::fmt::Display for RunningType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::StaticSiteGeneration => write!(f, "SSG"),
+            Self::ServerSideRendering => write!(f, "SSR"),
+        }
+    }
+}
+
 pub struct ServerConfigs {
     pub port: u16,
     pub _enable_http_logging: bool,
     pub root_path: PathBuf,
     pub running_type: RunningType,
+    pub mode: ServerMode,
+    pub rebuilder: Option<Arc<Rebuilder>>,
 }
 
 pub struct Server {
@@ -47,11 +84,46 @@ impl Server {
             self.configs.root_path.to_str().unwrap()
         ));
 
-        let mut app = RouterMut::from(
-            Router::new()
-                .nest_service("/static", ServeDir::new(&static_dir))
-                .nest_service("/dist", ServeDir::new(&dist_dir)),
-        );
+        let mut base_router = Router::new()
+            .nest_service("/static", ServeDir::new(&static_dir))
+            .nest_service("/dist", ServeDir::new(&dist_dir));
+
+        if let ServerMode::Development = self.configs.mode {
+            info!("Configuring server for development mode");
+            let live_reload_script = include_str!("scripts/live-reload.js");
+            base_router = base_router.route(
+                "/livereload/script.js",
+                get(|| async {
+                    info!("Serving live-reload.js");
+                    axum::response::Response::builder()
+                        .header("Content-Type", "application/javascript")
+                        .body(live_reload_script.to_string())
+                        .unwrap()
+                }),
+            );
+            // Apply live reload middleware
+            base_router = base_router.layer(axum::middleware::from_fn(inject_live_reload_script));
+
+            // Start the WebSocket server for live reload
+            let ws_listener = TcpListener::bind("127.0.0.1:3001")
+                .await
+                .map_err(|e| anyhow::anyhow!("WebSocket bind error: {}", e))?;
+            debug!(
+                "WebSocket server listening on {:?}",
+                ws_listener.local_addr()?
+            );
+            if let Some(rebuilder) = self.configs.rebuilder.clone() {
+                tokio::spawn(async move {
+                    while let Ok((stream, addr)) = ws_listener.accept().await {
+                        let live_reload = LiveReloadServer::new(rebuilder.subscribe());
+                        // live_reload.handle_connection(socket).await;
+                        tokio::spawn(live_reload.handle_connection(stream, addr));
+                    }
+                });
+            }
+        }
+
+        let mut app = RouterMut::from(base_router);
 
         match self.configs.running_type {
             RunningType::StaticSiteGeneration => {
@@ -65,7 +137,7 @@ impl Server {
                         .to_html(),
                     )
                 };
-                app.fallback(fallback)
+                app.fallback(fallback);
             }
             RunningType::ServerSideRendering => {
                 app.fallback(|| async { Redirect::to("/_notfound") })
@@ -74,17 +146,28 @@ impl Server {
 
         PagesHandler::new(&mut app, &dist_dir, self.configs.running_type)?.build()?;
 
-        // **Setting up layers**
+        // Apply middleware again after PagesHandler to catch dynamic HTML
+        if let ServerMode::Development = self.configs.mode {
+            debug!("Applying live reload middleware after PagesHandler");
+            app = RouterMut::from(
+                app.app()
+                    .layer(axum::middleware::from_fn(inject_live_reload_script)),
+            );
+        }
 
-        // Tracing layer
         TracingLayer::setup(
             TracingLayerOptions {
                 enable_http_logging: self.configs._enable_http_logging,
+                // mode: self.configs.mode,
             },
             &mut app,
         );
 
-        info!("Listening on http://{}", listener.local_addr()?);
+        info!(
+            message = format!("Listening on http://{}", listener.local_addr()?),
+            mode = self.configs.mode.to_string()
+        );
+
         axum::serve(listener, app.app()).await?;
         Ok(())
     }

crates/metassr-server/src/live_reload.rs

@@ -0,0 +1,105 @@
+use crate::rebuilder::RebuildType;
+use axum::{
+    body::Body,
+    http::{header, Request, Response, StatusCode},
+    middleware::Next,
+};
+use futures_util::{SinkExt, StreamExt};
+use serde::Serialize;
+use tokio_tungstenite::tungstenite::Message;
+
+use tokio::{net::TcpStream, sync::broadcast::Receiver};
+use tracing::info;
+
+#[derive(Debug, Serialize)]
+struct LiveReloadMessage {
+    #[serde(rename = "type")]
+    type_: String,
+    path: Option<String>,
+}
+
+impl RebuildType {
+    fn as_message(&self) -> LiveReloadMessage {
+        let (type_, path) = match self {
+            RebuildType::Page(path) => {
+                ("page".to_string(), Some(path.to_string_lossy().to_string()))
+            }
+            _ => (self.to_string(), None),
+        };
+
+        LiveReloadMessage { type_, path }
+    }
+}
+
+pub struct LiveReloadServer {
+    receiver: Receiver<RebuildType>,
+}
+
+impl LiveReloadServer {
+    pub fn new(receiver: Receiver<RebuildType>) -> Self {
+        Self { receiver }
+    }
+
+    pub async fn handle_connection(mut self, stream: TcpStream, addr: std::net::SocketAddr) {
+        let ws_stream = tokio_tungstenite::accept_async(stream)
+            .await
+            .expect("Error during websocket handshake");
+
+        let (mut ws_sender, _) = ws_stream.split();
+
+        while let Ok(rebuild_type) = self.receiver.recv().await {
+            let message = rebuild_type.as_message();
+            let message_json = serde_json::to_string(&message).unwrap();
+
+            if let Err(e) = ws_sender.send(Message::Text(message_json.into())).await {
+                tracing::error!("Failed to send LiveReload message: {}", e);
+                break;
+            }
+        }
+    }
+}
+
+/// middlware to indject the live-reload.js script
+pub async fn inject_live_reload_script(
+    req: Request<Body>,
+    next: Next,
+) -> Result<Response<Body>, StatusCode> {
+    let response = next.run(req).await;
+
+    // Check if the response is HTML
+    let is_html: bool = response
+        .headers()
+        .get(header::CONTENT_TYPE)
+        .map(|v| {
+            v.to_str()
+                .unwrap_or("")
+                .to_lowercase()
+                .contains("text/html")
+        })
+        .unwrap_or(false);
+
+    if is_html {
+        let (parts, body) = response.into_parts();
+
+        let body_bytes = axum::body::to_bytes(body, usize::MAX).await.map_err(|e| {
+            info!("Failed to read response body: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+        let body_str = String::from_utf8_lossy(&body_bytes).to_string();
+
+        // Inject script before </body> or append if </body> is missing
+        let modified_body = body_str.replace(
+            "</body>",
+            r#"<script src="/livereload/script.js"></script></body>"#,
+        );
+
+        return Ok(Response::builder()
+            .status(parts.status)
+            .header(header::CONTENT_TYPE, "text/html")
+            .header(header::CACHE_CONTROL, "no-cache") // Prevent caching in dev
+            .body(Body::from(modified_body))
+            .unwrap());
+    }
+
+    Ok(response)
+}