@browsersync/bslive 0.0.7 → 0.0.9

package/crates/bsnext_client/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "bsnext_client",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "tsc": "tsc",
+    "build": "esbuild ts/index.ts --bundle --outdir=dist --format=esm",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "schema": "ts-to-zod generated/dto.ts generated/schema.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "esbuild": "^0.20.2",
+    "livereload-js": "^4.0.2",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.4.5",
+    "@types/node": "18.19.25",
+    "ts-to-zod": "^3.8.2",
+    "zod": "^3.22.4"
+  }
+}

package/crates/bsnext_client/src/lib.rs

@@ -0,0 +1 @@
+pub const DIR: &str = "dist";

package/crates/bsnext_client/style.css

@@ -0,0 +1,3 @@
+body {
+    background: green;
+}

package/crates/bsnext_client/ts/console.ts

@@ -0,0 +1,25 @@
+import {Observable, Subject} from "rxjs";
+
+export enum Level {
+  Trace = "Trace",
+  Debug = "Debug",
+  Info = "Info",
+  Error = "Error",
+}
+
+export interface ConsoleEvent {
+  level: Level,
+  text: string
+}
+
+export function createLRConsoleObserver(): [Subject<ConsoleEvent>, Pick<typeof console, "log">] {
+  const subject = new Subject<ConsoleEvent>;
+  return [subject, {
+    log: function (...data: any[]): void {
+      subject.next({
+        level: Level.Debug,
+        text: data.join('\n')
+      });
+    },
+  }]
+}

package/crates/bsnext_client/ts/index.ts

@@ -0,0 +1,73 @@
+// @ts-ignore
+import {Reloader} from "livereload-js/src/reloader.js";
+// @ts-ignore
+import {Timer} from "livereload-js/src/timer.js";
+
+import {webSocket} from "rxjs/webSocket";
+import {retry} from "rxjs";
+import {clientEventSchema} from "../generated/schema.js";
+import {ChangeDTO, ClientEvent} from "../generated/dto";
+import {createLRConsoleObserver, Level} from "./console";
+
+const [consoleSubject, consoleApi] = createLRConsoleObserver();
+
+const r = new Reloader(window, consoleApi, Timer);
+const url = new URL(window.location.href);
+url.protocol = url.protocol === 'http:' ? 'ws' : 'wss';
+url.pathname = '/__bs_ws'
+const socket = webSocket<ClientEvent>(url.href);
+
+socket
+  .pipe(retry({delay: 5000}))
+  .subscribe(m => {
+    console.log(JSON.stringify(m, null, 2))
+    const parsed = clientEventSchema.parse(m);
+    switch (parsed.kind) {
+      case "Change": {
+        changedPath(parsed.payload);
+        break;
+      }
+      default: {
+        console.warn("unhandled client event")
+      }
+    }
+  })
+
+function changedPath(change: ChangeDTO) {
+  switch (change.kind) {
+    case "FsMany": {
+      // todo: if this collection of events contains
+      // anything that will cause a refresh, just do it immediately
+      for (let changeDTO of change.payload) {
+        changedPath(changeDTO);
+      }
+      break
+    }
+    case "Fs": {
+      let path = change.payload.path;
+      r.reload(path, {
+        liveCSS: true,
+        liveImg: true,
+        reloadMissingCSS: false,
+        originalPath: '',
+        overrideURL: '',
+        serverURL: ``,
+      })
+    }
+  }
+}
+
+consoleSubject.subscribe(evt => {
+  switch (evt.level) {
+    case Level.Trace:
+      break;
+    case Level.Debug:
+      console.log('[debug]', evt.text)
+      break;
+    case Level.Info:
+      break;
+    case Level.Error:
+      break;
+  }
+})
+

package/crates/bsnext_client/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "commonjs",
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": [
+    "ts"
+  ]
+}

package/crates/bsnext_core/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "bsnext_core"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bsnext_input = { path = "../bsnext_input" }
+bsnext_fs = { path = "../bsnext_fs" }
+bsnext_resp = { path = "../bsnext_resp" }
+bsnext_client = { path = "../bsnext_client" }
+
+axum-server = { version = "0.6.0", features = ["tls-rustls"] }
+axum-extra = { version = "0.9.3", features = ["typed-header"] }
+hyper = { version = "1.0.0", features = ["full"] }
+hyper-tls = { version = "0.6.0" }
+hyper-util = { version = "0.1.1", features = ["client-legacy"] }
+matchit = { version = "0.7.3" }
+htmlescape = { version = "0.3.1" }
+
+mime_guess = { workspace = true }
+axum = { workspace = true }
+clap = { workspace = true }
+http-body-util = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+tower = { workspace = true }
+tower-http = { workspace = true }
+tracing = { workspace = true }
+actix = { workspace = true }
+actix-rt = { workspace = true }
+anyhow = { workspace = true }
+futures = { workspace = true }
+futures-util = { workspace = true }
+serde = { workspace = true }
+serde_yaml = { workspace = true }
+thiserror = { workspace = true }
+tracing-subscriber = { workspace = true }
+serde_json = { workspace = true }
+bytes = { workspace = true }
+http = { workspace = true }
+typeshare = { workspace = true }

package/crates/bsnext_core/src/dir_loader.rs

@@ -0,0 +1,230 @@
+#![allow(clippy::redundant_pattern_matching)]
+#![allow(clippy::single_match)]
+use crate::handlers::proxy::ProxyConfig;
+use crate::meta::MetaData;
+use crate::raw_loader::add_route_layers;
+use axum::body::Body;
+use axum::extract::{Request, State};
+
+use axum::middleware::Next;
+use axum::response::{IntoResponse, Response};
+use axum::{middleware, Extension, Router};
+use bytes::Bytes;
+use futures::channel::mpsc::unbounded;
+use futures::SinkExt;
+
+use crate::handlers::proxy;
+use crate::server::state::ServerState;
+use axum::routing::any;
+use bsnext_input::route::{DirRoute, ProxyRoute, Route, RouteKind};
+use bsnext_resp::{response_modifications_layer, RespMod};
+use http::{HeaderValue, StatusCode};
+use http_body_util::BodyExt;
+use std::collections::HashMap;
+use std::convert::Infallible;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::fs::File;
+use tokio::io::{AsyncWriteExt, BufWriter};
+use tokio_stream::StreamExt;
+use tower::{ServiceBuilder, ServiceExt};
+use tower_http::decompression::DecompressionLayer;
+use tower_http::services::ServeDir;
+use tracing::{span, Instrument, Level};
+
+pub async fn serve_dir_loader(
+    State(state): State<Arc<ServerState>>,
+    req: Request,
+    _next: Next,
+) -> Response {
+    let _path = req.uri().path().to_owned();
+    let span = span!(parent: None, Level::INFO, "serve_dir_loader", path = req.uri().path());
+    let _guard = span.enter();
+
+    let accepts_html = RespMod::accepts_html(&req);
+    let routes = state.routes.read().instrument(span.clone()).await;
+    let mut app = Router::new();
+    let route_map = routes
+        .iter()
+        .filter(|r| matches!(&r.kind, RouteKind::Proxy(_) | RouteKind::Dir(_)))
+        .fold(HashMap::<&str, Vec<&Route>>::new(), |mut acc, route| {
+            acc.entry(route.path.as_str())
+                .and_modify(|acc| acc.push(route))
+                .or_insert(vec![route]);
+            acc
+        });
+
+    for (_, routes) in route_map.iter() {
+        if routes.len() > 1 {
+            tracing::error!(
+                "cannot register duplicate dir or proxy routes, only the first will take effect"
+            );
+        }
+
+        let route = routes.first().expect("guarded");
+        let mut router = match &route.kind {
+            RouteKind::Proxy(ProxyRoute { proxy }) => {
+                let response_handling = if accepts_html {
+                    ResponseHandling::Modify
+                } else {
+                    ResponseHandling::None
+                };
+                service_for_proxy(response_handling, route).layer(Extension(ProxyConfig {
+                    target: proxy.to_owned(),
+                    path: route.path.clone(),
+                }))
+            }
+            RouteKind::Dir(DirRoute { dir }) => service_for_dir(route, dir),
+            _ => unreachable!("{:?}", route.kind),
+        };
+        router = add_route_layers(router, route);
+        app = app.merge(router);
+    }
+
+    drop(routes);
+
+    let r = app.oneshot(req).await;
+
+    r.into_response()
+}
+
+fn service_for_dir(route: &Route, dir: &str) -> Router {
+    Router::new()
+        .nest_service(route.path.as_str(), ServeDir::new(dir))
+        .layer(middleware::from_fn(tag_file))
+        .layer(middleware::from_fn(response_modifications_layer))
+}
+
+async fn tag_file(req: Request, next: Next) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let (mut parts, body) = next.run(req).await.into_parts();
+    if parts.status.as_u16() == 200 {
+        parts.extensions.insert(MetaData::ServedFile);
+    }
+    Ok(Response::from_parts(parts, body))
+}
+
+enum ResponseHandling {
+    Modify,
+    None,
+}
+
+fn service_for_proxy(handling: ResponseHandling, route: &Route) -> Router {
+    match handling {
+        ResponseHandling::Modify => Router::new()
+            .nest_service(route.path.as_str(), any(proxy::proxy_handler))
+            .layer(
+                ServiceBuilder::new()
+                    .layer(middleware::from_fn(response_modifications_layer))
+                    .layer(DecompressionLayer::new()),
+            ),
+        ResponseHandling::None => Router::new()
+            .nest_service(route.path.as_str(), any(proxy::proxy_handler))
+            .layer(middleware::from_fn(response_modifications_layer)),
+    }
+}
+
+#[allow(dead_code)]
+async fn print_request_response(
+    req: Request,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let (parts, body) = req.into_parts();
+    let bytes = buffer_and_print("request", body).await?;
+    let req = Request::from_parts(parts, Body::from(bytes));
+
+    let res = next.run(req).await;
+    let (parts, body) = res.into_parts();
+
+    let (mut sender, rec) = unbounded::<Bytes>();
+    let is_event_stream = parts.headers.get("content-type")
+        == Some(&HeaderValue::from_str("text/event-stream").unwrap());
+
+    tokio::spawn(async move {
+        let mut stream = body.into_data_stream();
+        let mut chunks: Vec<Bytes> = vec![];
+        while let Some(b) = stream.next().await {
+            tracing::info!("CHUNK");
+            match b {
+                Ok(bytes) => {
+                    if is_event_stream {
+                        // let _written = file.write(&bytes).await;
+                        chunks.push(bytes.to_owned());
+                        match sender.send(bytes.to_owned()).await {
+                            Ok(_) => tracing::trace!("stripped chunk sent"),
+                            Err(_) => tracing::error!("stripped chunk not sent"),
+                        };
+                    } else {
+                        match sender.send(bytes.to_owned()).await {
+                            Ok(_) => tracing::trace!("chunk sent"),
+                            Err(_) => tracing::error!("not sent"),
+                        };
+                    }
+                }
+                Err(e) => {
+                    tracing::error!(?e, "error")
+                }
+            }
+        }
+        if is_event_stream {
+            let path = std::path::Path::new("record").join("out4.yml");
+            let mut file = BufWriter::new(File::create(path).await.expect("file"));
+            let to_str = chunks
+                .into_iter()
+                .map(|x| std::str::from_utf8(&x).expect("bytes").to_owned())
+                .collect::<Vec<_>>();
+            let yml = serde_yaml::to_string(&to_str).expect("to yaml");
+            println!("yml={}", yml);
+            let _r = file.write(yml.as_bytes());
+
+            match file.flush().await {
+                Ok(_) => {}
+                Err(_) => {}
+            }
+        }
+    });
+
+    // let res = Response::from_parts(parts, body);
+    // while let Some(b) = res.body().next().await {
+    //     dbg!(b);
+    // }
+
+    // let (parts, body) = res.into_parts();
+    // let bytes = buffer_and_print("response", body).await?;
+    // let l = lines
+    //     .lines()
+    //     .map(|l| l.to_owned())
+    //     .map(|l| l.strip_prefix("data:").unwrap_or(&l).to_owned())
+    //     .filter(|l| !l.trim().is_empty())
+    //     .collect::<Vec<_>>();
+
+    let stream = rec
+        .throttle(Duration::from_millis(500))
+        .map(Ok::<_, Infallible>);
+
+    let res = Response::from_parts(parts, Body::from_stream(stream));
+
+    Ok(res)
+}
+
+#[allow(dead_code)]
+async fn buffer_and_print<B>(direction: &str, body: B) -> Result<Bytes, (StatusCode, String)>
+where
+    B: axum::body::HttpBody<Data = Bytes>,
+    B::Error: std::fmt::Display,
+{
+    let bytes = match body.collect().await {
+        Ok(collected) => collected.to_bytes(),
+        Err(err) => {
+            return Err((
+                StatusCode::BAD_REQUEST,
+                format!("failed to read {direction} body: {err}"),
+            ));
+        }
+    };
+
+    if let Ok(body) = std::str::from_utf8(&bytes) {
+        tracing::debug!("{direction} body = {body:?}");
+    }
+
+    Ok(bytes)
+}

package/crates/bsnext_core/src/dto.rs

@@ -0,0 +1,281 @@
+use actix::MessageResponse;
+use bsnext_input::server_config::Identity;
+use bsnext_input::InputError;
+use std::fmt::{Display, Formatter};
+use std::path::Path;
+
+use crate::server::handler_change::{Change, ChangeKind};
+use bsnext_fs::Debounce;
+use typeshare::typeshare;
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct ServersStarted {
+    pub servers_resp: GetServersMessageResponse,
+    pub changeset: ServerChangeSet,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub enum EventLevel {
+    #[serde(rename = "BSLIVE_EXTERNAL")]
+    External,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct ExternalEvent {
+    pub level: EventLevel,
+    pub fields: ExternalEvents,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum ExternalEvents {
+    ServersStarted(ServersStarted),
+    Watching(Watching),
+    WatchingStopped(StoppedWatching),
+    FileChanged(FileChanged),
+    FilesChanged(FilesChangedDTO),
+    InputFileChanged(FileChanged),
+    InputAccepted(InputAccepted),
+    StartupFailed(InputErrorDTO),
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct InputAccepted {
+    pub path: String,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct FileChanged {
+    pub path: String,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct FilesChangedDTO {
+    pub paths: Vec<String>,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct Watching {
+    pub paths: Vec<String>,
+    pub debounce: DebounceDTO,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct StoppedWatching {
+    pub paths: Vec<String>,
+}
+
+impl StoppedWatching {
+    pub fn from_path_buf(p: &Path) -> Self {
+        Self {
+            paths: vec![p.to_string_lossy().to_string()],
+        }
+    }
+}
+
+impl Display for Watching {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "yo")
+    }
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct DebounceDTO {
+    kind: String,
+    ms: String,
+}
+
+impl Display for DebounceDTO {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}:{}ms", self.kind, self.ms)
+    }
+}
+
+impl From<Debounce> for DebounceDTO {
+    fn from(value: Debounce) -> Self {
+        match value {
+            Debounce::Trailing { duration } => Self {
+                kind: "trailing".to_string(),
+                ms: duration.as_millis().to_string(),
+            },
+            Debounce::Buffered { duration } => Self {
+                kind: "buffered".to_string(),
+                ms: duration.as_millis().to_string(),
+            },
+        }
+    }
+}
+
+impl FileChanged {
+    pub fn from_path_buf(p: &Path) -> Self {
+        Self {
+            path: p.to_string_lossy().to_string(),
+        }
+    }
+}
+
+impl Watching {
+    pub fn from_path_buf(p: &Path, debounce: Debounce) -> Self {
+        Self {
+            paths: vec![p.to_string_lossy().to_string()],
+            debounce: debounce.into(),
+        }
+    }
+}
+
+#[typeshare]
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum ServerChange {
+    Stopped { bind_address: String },
+    Started,
+    Patched,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct ServerChangeSetItem {
+    pub identity: IdentityDTO,
+    pub change: ServerChange,
+}
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct ServerChangeSet {
+    pub items: Vec<ServerChangeSetItem>,
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, MessageResponse)]
+pub struct GetServersMessageResponse {
+    pub servers: Vec<ServersDTO>,
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct ServersDTO {
+    pub identity: IdentityDTO,
+    pub socket_addr: String,
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum IdentityDTO {
+    Both { name: String, bind_address: String },
+    Address { bind_address: String },
+    Named { name: String },
+}
+
+impl From<&Identity> for IdentityDTO {
+    fn from(value: &Identity) -> Self {
+        match value {
+            Identity::Both { name, bind_address } => IdentityDTO::Both {
+                name: name.to_owned(),
+                bind_address: bind_address.to_owned(),
+            },
+            Identity::Address { bind_address } => IdentityDTO::Address {
+                bind_address: bind_address.to_owned(),
+            },
+            Identity::Named { name } => IdentityDTO::Named {
+                name: name.to_owned(),
+            },
+        }
+    }
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, PartialEq, Hash, Eq, Clone, serde::Deserialize, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum InputErrorDTO {
+    MissingInputs(String),
+    InvalidInput(String),
+    NotFound(String),
+    InputWriteError(String),
+    PathError(String),
+    PortError(String),
+    DirError(String),
+}
+
+impl From<&InputError> for InputErrorDTO {
+    fn from(value: &InputError) -> Self {
+        match value {
+            e @ InputError::MissingInputs => InputErrorDTO::MissingInputs(e.to_string()),
+            e @ InputError::InvalidInput(_) => InputErrorDTO::InvalidInput(e.to_string()),
+            e @ InputError::NotFound(_) => InputErrorDTO::NotFound(e.to_string()),
+            e @ InputError::InputWriteError(_) => InputErrorDTO::InputWriteError(e.to_string()),
+            e @ InputError::PathError(_) => InputErrorDTO::PathError(e.to_string()),
+            e @ InputError::PortError(_) => InputErrorDTO::PortError(e.to_string()),
+            e @ InputError::DirError(_) => InputErrorDTO::DirError(e.to_string()),
+        }
+    }
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum ClientEvent {
+    Change(ChangeDTO),
+}
+
+#[typeshare::typeshare]
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum ChangeDTO {
+    Fs {
+        path: String,
+        change_kind: ChangeKind,
+    },
+    FsMany(Vec<ChangeDTO>),
+}
+
+impl From<&Change> for ChangeDTO {
+    fn from(value: &Change) -> Self {
+        match value {
+            Change::Fs { path, change_kind } => Self::Fs {
+                path: path.to_string_lossy().to_string(),
+                change_kind: change_kind.clone(),
+            },
+            Change::FsMany(changes) => Self::FsMany(
+                changes
+                    .iter()
+                    .map(|change| match change {
+                        Change::Fs { path, change_kind } => Self::Fs {
+                            path: path.to_string_lossy().to_string(),
+                            change_kind: change_kind.clone(),
+                        },
+                        Change::FsMany(_) => unreachable!("recursive not supported"),
+                    })
+                    .collect(),
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_serialize() -> anyhow::Result<()> {
+        let fs = Change::fs("./a.js");
+        let evt = ClientEvent::Change((&fs).into());
+        let _json = serde_json::to_string(&evt).unwrap();
+        Ok(())
+    }
+    #[test]
+    fn test_serialize_server_start() -> anyhow::Result<()> {
+        let fs = Change::fs("./a.js");
+        let evt = ClientEvent::Change((&fs).into());
+        let _json = serde_json::to_string(&evt).unwrap();
+        Ok(())
+    }
+}

package/crates/bsnext_core/src/handlers/mod.rs

@@ -0,0 +1 @@
+pub mod proxy;