You are a constitutional council ranking individual git commits for ownership allocation. Compare these two commits. Decide which contributed more lasting value to the project. Judge substance, not spectacle: - Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise. - Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one. - Do not favor a side merely because its patch is longer or noisier. - Weight what the change does for the project, not the contributor's name. Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."} The explanation must cite concrete differences in the patches (1-3 sentences). Side A — contributor: tommy-mor Side A — commit message: [3f35edab] progress Side A — unified diff (full patch): diff --git a/server/src/api/mod.rs b/server/src/api/mod.rs index a10ce662105cff8fad949c6b83f7035ce79bed18..a986f706ea4b261cbaf004c02b4cf84184b41371 100644 --- a/server/src/api/mod.rs +++ b/server/src/api/mod.rs @@ -3,6 +3,7 @@ mod helpers; mod rpc; mod stream; mod validate; +mod ui_html; mod web_post; pub use auth::{ @@ -33,6 +34,7 @@ pub use stream::{get_html_stream, get_stream}; pub use validate::{normalize_room_and_thread, validate_ingest_document, ValidatedIngest}; +pub use ui_html::post_ui_html; pub use web_post::{check_web_ingest, post_web_ingest, post_web_redact}; #[cfg(test)] diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs new file mode 100644 index 0000000000000000000000000000000000000000..2b40a72059981d558768f73d189b991f3448c257 --- /dev/null +++ b/server/src/api/ui_html.rs @@ -0,0 +1,139 @@ +//! Single `POST /ui` entry for browser [`crate::html::ui_action::HtmlUiAction`] (JSON in `__rpc__` + holes). + +use axum::{ + body::Body, + extract::State, + http::{header, HeaderMap, StatusCode}, + response::{IntoResponse, Response}, + Form, +}; +use axum_extra::extract::cookie::CookieJar; +use std::collections::HashMap; + +use crate::{ + api::{ + auth::optional_principal, + web_post::{run_check_web_ingest, run_post_web_ingest, run_post_web_redact, WebPostForm, WebRedactForm}, + }, + html::{ + fragment_public_new_thread_form, fragment_room_new_thread_form, login_to_post_hint_markup, + parse_html_ui_from_form, user_can_post_room, user_can_view_room, HtmlUiAction, JsBuilder, + ThreadNav, + }, + state::AppState, +}; + +pub async fn post_ui_html( + State(state): State, + headers: HeaderMap, + jar: CookieJar, + Form(form): Form>, +) -> impl IntoResponse { + let action = match parse_html_ui_from_form(&form) { + Ok(a) => a, + Err(e) => return ui_js_warn(&e.to_string()).into_response(), + }; + + match action { + HtmlUiAction::PostIngest { + room, + thread_tag, + text, + error_target, + form_id, + } => { + run_post_web_ingest( + &state, + &headers, + &jar, + WebPostForm { + room, + thread_tag, + text, + error_target, + form_id, + }, + ) + .await + } + HtmlUiAction::CheckIngest { + room, + thread_tag, + text, + error_target, + form_id, + } => { + run_check_web_ingest( + &state, + &headers, + &jar, + WebPostForm { + room, + thread_tag, + text, + error_target, + form_id, + }, + ) + .await + } + HtmlUiAction::RedactPost { post_id } => { + run_post_web_redact(&state, &headers, &jar, WebRedactForm { post_id }).await + } + HtmlUiAction::ExpandPublicNewThreadForm => { + let reduced = state.reduced.read().await; + let user = optional_principal(&headers, &jar, &reduced); + drop(reduced); + let markup = if user.is_some() { + fragment_public_new_thread_form(true) + } else { + login_to_post_hint_markup() + }; + JsBuilder::new() + .morph_selector("#public-new-thread-ui-slot", markup) + .into_response() + } + HtmlUiAction::ExpandRoomNewThreadForm { room_wire } => { + let room_wire = room_wire.trim().to_string(); + if room_wire.is_empty() { + return ui_js_warn("missing room").into_response(); + } + let reduced = state.reduced.read().await; + let user = optional_principal(&headers, &jar, &reduced); + if !reduced.rooms.contains(&room_wire) { + drop(reduced); + return ui_js_warn("room not found").into_response(); + } + if !user_can_view_room(&reduced, &room_wire, user.as_deref()) { + drop(reduced); + return ui_js_warn("forbidden").into_response(); + } + let can_post = user + .as_ref() + .map(|u| user_can_post_room(&reduced, &room_wire, u)) + .unwrap_or(false); + drop(reduced); + let Some(nav) = ThreadNav::from_room_id(&room_wire) else { + return ui_js_warn("bad room").into_response(); + }; + let markup = if can_post { + fragment_room_new_thread_form(&nav, true) + } else { + login_to_post_hint_markup() + }; + JsBuilder::new() + .morph_selector("#room-new-thread-ui-slot", markup) + .into_response() + } + } +} + +fn ui_js_warn(msg: &str) -> Response { + use crate::html::js_string_literal; + let js = format!("console.warn({});", js_string_literal(msg)); + Response::builder() + .status(StatusCode::OK) + .header(header::CONTENT_TYPE, "text/javascript; charset=utf-8") + .body(Body::from(js)) + .unwrap() +} diff --git a/server/src/api/web_post.rs b/server/src/api/web_post.rs index a64010e382d3039821c836a5529adad0fe67cce5..265025f41ff1548d05b2d2d5d84202245388053f 100644 --- a/server/src/api/web_post.rs +++ b/server/src/api/web_post.rs @@ -222,8 +222,18 @@ pub async fn post_web_redact( jar: CookieJar, Form(form): Form, ) -> impl IntoResponse { + run_post_web_redact(&state, &headers, &jar, form).await +} + +/// Shared with [`crate::api::ui_html::post_ui_html`]. +pub(crate) async fn run_post_web_redact( + state: &AppState, + headers: &HeaderMap, + jar: &CookieJar, + form: WebRedactForm, +) -> Response { let reduced = state.reduced.read().await; - let Some(_username) = optional_principal(&headers, &jar, &reduced) else { + let Some(_username) = optional_principal(headers, jar, &reduced) else { drop(reduced); return js_redirect("/login").into_response(); }; @@ -239,8 +249,8 @@ pub async fn post_web_redact( return js_redirect("/login").into_response(); }; - match rpc_post_redact(&state, &headers, form.post_id).await { - Ok(RpcResult::RedactPostOk {}) => redact_success_response(&state).await.into_response(), + match rpc_post_redact(state, headers, form.post_id).await { + Ok(RpcResult::RedactPostOk {}) => redact_success_response(state).await.into_response(), Ok(_) => (StatusCode::BAD_REQUEST, "unexpected response").into_response(), Err((msg, hint)) => { let detail = hint.as_deref().unwrap_or(""); @@ -255,8 +265,18 @@ pub async fn post_web_ingest( jar: CookieJar, Form(form): Form, ) -> impl IntoResponse { + run_post_web_ingest(&state, &headers, &jar, form).await +} + +/// Shared with [`crate::api::ui_html::post_ui_html`] (`POST /ui`). +pub(crate) async fn run_post_web_ingest( + state: &AppState, + headers: &HeaderMap, + jar: &CookieJar, + form: WebPostForm, +) -> Response { let reduced = state.reduced.read().await; - let Some(_username) = optional_principal(&headers, &jar, &reduced) else { + let Some(_username) = optional_principal(headers, jar, &reduced) else { drop(reduced); return js_redirect("/login").into_response(); }; @@ -282,8 +302,8 @@ pub async fn post_web_ingest( .into_response(); } - match rpc_post_with_bearer(&state, &bearer, room.clone(), thread_tag.clone(), text).await { - Ok(RpcResult::PostOk { .. }) => post_success_response(&state, &form, &headers, &jar) + match rpc_post_with_bearer(state, &bearer, room.clone(), thread_tag.clone(), text).await { + Ok(RpcResult::PostOk { .. }) => post_success_response(state, &form, headers, jar) .await .into_response(), Ok(_) => form_js_error(&form, "unexpected response", "Post did not return PostOk.").into_response(), @@ -297,8 +317,18 @@ pub async fn check_web_ingest( jar: CookieJar, Form(form): Form, ) -> impl IntoResponse { + run_check_web_ingest(&state, &headers, &jar, form).await +} + +/// Shared with [`crate::api::ui_html::post_ui_html`] (`POST /ui`). +pub(crate) async fn run_check_web_ingest( + state: &AppState, + headers: &HeaderMap, + jar: &CookieJar, + form: WebPostForm, +) -> Response { let reduced = state.reduced.read().await; - let Some(_username) = optional_principal(&headers, &jar, &reduced) else { + let Some(_username) = optional_principal(headers, jar, &reduced) else { drop(reduced); return js_redirect("/login").into_response(); }; @@ -324,7 +354,7 @@ pub async fn check_web_ingest( return js_clear_errors(&form_error_target(&form)).into_response(); } - match rpc_check_with_bearer(&state, &bearer, room, form.text.clone()).await { + match rpc_check_with_bearer(state, &bearer, room, form.text.clone()).await { Ok(RpcResult::CheckOk { .. }) => js_clear_errors(&form_error_target(&form)).into_response(), Ok(_) => form_js_error(&form, "unexpected response", "Check did not return CheckOk.").into_response(), Err((msg, hint)) => form_js_error(&form, &msg, hint.as_deref().unwrap_or("")).into_response(), diff --git a/server/src/form_template.rs b/server/src/form_template.rs new file mode 100644 index 0000000000000000000000000000000000000000..3709c2c09a859da006e4af173413d5d235bc19be --- /dev/null +++ b/server/src/form_template.rs @@ -0,0 +1,142 @@ +//! Plan2-style JSON templates with `{"$form": "field_name"}` holes, filled from +//! `application/x-www-form-urlencoded` (or any `String` → `String` map) **before** +//! deserializing into a typed struct. +//! +//! # Wire format +//! +//! Templates are **compact JSON** (`serde_json::to_string`): one line, no pretty +//! printing, strings escaped per JSON rules (`\"`, `\n`, etc.). Embed that string +//! in HTML attributes or text nodes with normal HTML escaping (e.g. maud), not +//! bespoke encodings. +//! +//! # Power vs flat hidden fields +//! +//! A form is always a string→string map. You can fake depth with dotted keys (`a.b.c`), +//! but one structured blob (`__rpc__` = compact JSON) gives you nested objects, +//! arrays, and optional fields without inventing a new naming scheme each time. +//! +//! # Security +//! +//! Substitution runs **before** `serde` into your command type. It does not fix +//! authorization: if the client can replace the hidden `__rpc__` value, they can +//! change the command shape unless you validate (signed blob, server-side session +//! context, or treat the blob as hints only). Same threat model as any hidden field. + +use serde::Serialize; +use serde_json::Value; +use std::collections::HashMap; + +/// Serialize a value to compact JSON for a hidden `__rpc__` (or similar) field. +pub fn template_json_compact(v: &T) -> serde_json::Result { + serde_json::to_string(v) +} + +/// Recursively walk the JSON AST and replace `{"$form": "key"}` with the submitted +/// string for `key` (empty if missing). Other keys are unchanged. +pub fn substitute_form_vars(val: &mut Value, form_data: &HashMap) { + match val { + Value::Object(map) => { + if map.len() == 1 { + if let Some(Value::String(field_name)) = map.get("$form") { + let submitted = form_data + .get(field_name.as_str()) + .map(|s| s.as_str()) + .unwrap_or(""); + *val = Value::String(submitted.to_string()); + return; + } + } + for v in map.values_mut() { + substitute_form_vars(v, form_data); + } + } + Value::Array(arr) => { + for v in arr.iter_mut() { + substitute_form_vars(v, form_data); + } + } + _ => {} + } +} + +/// Parse JSON, apply [`substitute_form_vars`], return the mutated value. +pub fn fill_template_from_form( + template_json: &str, + form_data: &HashMap, +) -> Result { + let mut v: Value = serde_json::from_str(template_json)?; + substitute_form_vars(&mut v, form_data); + Ok(v) +} + +#[cfg(test)] +mod tests { + use super::*; + use serde::Deserialize; + + #[derive(Debug, Deserialize, PartialEq, Eq)] + struct Demo { + room: String, + thread_tag: String, + nested: Nested, + } + + #[derive(Debug, Deserialize, PartialEq, Eq)] + struct Nested { + text: String, + } + + #[test] + fn holes_become_strings() { + let json = r#"{ + "room": "public", + "thread_tag": {"$form": "tag"}, + "nested": {"text": {"$form": "body"}} + }"#; + let mut form = HashMap::new(); + form.insert("tag".into(), "foo".into()); + form.insert("body".into(), "hello\nworld".into()); + + let v = fill_template_from_form(json, &form).unwrap(); + let d: Demo = serde_json::from_value(v).unwrap(); + assert_eq!( + d, + Demo { + room: "public".into(), + thread_tag: "foo".into(), + nested: Nested { + text: "hello\nworld".into(), + }, + } + ); + } + + #[test] + fn missing_form_key_is_empty_string() { + let json = r#"{"x": {"$form": "nope"}}"#; + let mut form = HashMap::new(); + form.insert("other".into(), "y".into()); + let v = fill_template_from_form(json, &form).unwrap(); + assert_eq!(v["x"], ""); + } + + #[test] + fn array_of_holes() { + let json = r#"{"items": [{"$form": "a"}, {"$form": "b"}]}"#; + let mut form = HashMap::new(); + form.insert("a".into(), "1".into()); + form.insert("b".into(), "2".into()); + let v = fill_template_from_form(json, &form).unwrap(); + assert_eq!(v["items"], serde_json::json!(["1", "2"])); + } + + #[test] + fn template_json_compact_escapes_and_single_line() { + let s = template_json_compact(&serde_json::json!({ + "x": "quote\"and\nnewline" + })) + .unwrap(); + assert!(!s.contains('\n')); + assert!(s.contains("\\\"") || s.contains("\\n")); + } +} diff --git a/server/src/html/forum.rs b/server/src/html/forum.rs index f789e347dc136f8ffd356f4492f0bd76cea04bf0..b1c037f3dd93c7bb96d6624cab6019228432c501 100644 --- a/server/src/html/forum.rs +++ b/server/src/html/forum.rs @@ -11,12 +11,15 @@ use crate::{ api::optional_principal, canonical_path::{canonicalize_item, canonicalize_tag}, events::ThreadCapability, + form_template::template_json_compact, identity::parse_username, reducer::{scope_from_room_wire, ReducerState, ScopeId}, state::AppState, timeago, }; +use super::ui_action::{HtmlUiAction, UI_RPC_FIELD}; + use super::{ bc_segment, bc_threads, cli_panel, layout, now_ms, profile_href, recency_class, render_linkified_with_embeds_in_scope, theme_from_jar, theme_next_from_uri, JsBuilder, @@ -289,7 +292,7 @@ fn rooms_for_user(reduced: &ReducerState, username: &str) -> Vec { v } -fn user_can_view_room(reduced: &ReducerState, room_id: &str, username: Option<&str>) -> bool { +pub(crate) fn user_can_view_room(reduced: &ReducerState, room_id: &str, username: Option<&str>) -> bool { if !reduced.rooms.contains(room_id) { return false; } @@ -299,7 +302,7 @@ fn user_can_view_room(reduced: &ReducerState, room_id: &str, username: Option<&s reduced.user_has_cap(room_id, u, ThreadCapability::View) } -fn user_can_post_room(reduced: &ReducerState, room_id: &str, username: &str) -> bool { +pub(crate) fn user_can_post_room(reduced: &ReducerState, room_id: &str, username: &str) -> bool { reduced.user_has_cap(room_id, username, ThreadCapability::Post) } @@ -591,7 +594,6 @@ pub async fn home( let nav = ThreadNav::public(); let reduced_read = state.reduced.read().await; let strip = auth_strip(&headers, &jar, &reduced_read); - let show_forms = user.is_some(); drop(reduced_read); let page = layout( @@ -617,8 +619,14 @@ pub async fn home( } } p class="muted" { "dark = time-ordered · light = vote-ranked" } + div class="thread-feed-toolbar" { + form method="POST" action="/ui" { + input type="hidden" name=(UI_RPC_FIELD) value=(expand_public_new_thread_rpc_value()); + button type="submit" class="section-add-btn" { "+" } + } + } + div id="public-new-thread-ui-slot" {} (render_thread_feed(Some(&nav), "thread-feed", &public_rows, now)) - (new_thread_form_public(show_forms)) (cli_panel("npx slugsocial public forum list")) }, None, @@ -901,7 +909,13 @@ pub async fn room_page( h3 { "threads" } (render_thread_feed(Some(&nav), "room-thread-feed", &rows, now)) @if show_new { - (new_thread_form_for_room(&nav, show_new)) + div class="thread-feed-toolbar" { + form method="POST" action="/ui" { + input type="hidden" name=(UI_RPC_FIELD) value=(expand_room_new_thread_rpc_value(&nav)); + button type="submit" class="section-add-btn" { "+" } + } + } + div id="room-new-thread-ui-slot" {} } (cli_panel(&forum_cli)) (cli_panel(&garden_cli)) @@ -945,6 +959,31 @@ fn new_thread_form_for_room(nav: &ThreadNav, show: bool) -> Markup { } } +pub(crate) fn expand_public_new_thread_rpc_value() -> String { + template_json_compact(&HtmlUiAction::ExpandPublicNewThreadForm).expect("static json") +} + +pub(crate) fn expand_room_new_thread_rpc_value(nav: &ThreadNav) -> String { + template_json_compact(&HtmlUiAction::ExpandRoomNewThreadForm { + room_wire: nav.room_wire.clone(), + }) + .expect("static json") +} + +pub(crate) fn login_to_post_hint_markup() -> Markup { + html! { + p class="muted" { "log in to post" } + } +} + +pub(crate) fn fragment_public_new_thread_form(show: bool) -> Markup { + new_thread_form_public(show) +} + +pub(crate) fn fragment_room_new_thread_form(nav: &ThreadNav, show: bool) -> Markup { + new_thread_form_for_room(nav, show) +} + async fn thread_post_view_inner( state: AppState, tag: String, diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index 53041a0cf0b30e6f20749c92ecc15a4e9ac56e09..a4fd2dd60ac283f7eb9b2e64522501b21d1e27e9 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -16,6 +16,7 @@ mod editor; mod forum; mod garden; mod search; +pub mod ui_action; use breadcrumb_path::OntologyPath; pub use auth::{auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment, choose_username_page}; @@ -27,9 +28,15 @@ pub use forum::{ thread_post_collapse_deleted, thread_post_expand, thread_post_expand_deleted, thread_post_view, thread_view, ThreadNav, }; + +pub(crate) use forum::{ + fragment_public_new_thread_form, fragment_room_new_thread_form, login_to_post_hint_markup, + user_can_post_room, user_can_view_room, +}; pub use garden::{garden_index, ontology_path, room_garden_index, room_ontology_path}; pub use search::{search_page, search_results_fragment}; pub use forum::user_profile_page; +pub use ui_action::{parse_html_ui_from_form, HtmlUiAction, HtmlUiParseError, UI_RPC_FIELD}; /// Public profile URL path for a stored username (no `@`). pub(crate) fn profile_href(username: &str) -> String { diff --git a/server/src/html/ui_action.rs b/server/src/html/ui_action.rs new file mode 100644 index 0000000000000000000000000000000000000000..3bc69ecbb7e16a59d2d393b2d59f9cd3fedb12b1 --- /dev/null +++ b/server/src/html/ui_action.rs @@ -0,0 +1,116 @@ +//! Browser-only UI commands: JSON in hidden `__rpc__` plus hole fill ([`crate::form_template`]). +//! Not part of [`slug_types::RpcCommand`] (CLI / JSON API). + +use crate::form_template::fill_template_from_form; +use serde::{Deserialize, Serialize}; +use serde_json::Value; +use std::collections::HashMap; +use thiserror::Error; + +/// Form field name for the compact JSON template (possibly with `{"$form":"…"}` holes). +pub const UI_RPC_FIELD: &str = "__rpc__"; + +/// HTML form / fetch `POST /ui` payload after template fill and deserialization. +#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)] +#[serde(tag = "action", rename_all = "snake_case")] +pub enum HtmlUiAction { + /// Same semantics as `POST /post` (forum ingest). + PostIngest { + room: String, + thread_tag: String, + text: String, + #[serde(default)] + error_target: Option, + #[serde(default)] + form_id: Option, + }, + /// Same as `POST /post/check`. + CheckIngest { + room: String, + thread_tag: String, + text: String, + #[serde(default)] + error_target: Option, + #[serde(default)] + form_id: Option, + }, + /// Same as `POST /post/redact`. + RedactPost { + post_id: String, + }, + /// Morph `#public-new-thread-ui-slot` to the new-thread form (or login hint). + ExpandPublicNewThreadForm, + /// Morph `#room-new-thread-ui-slot` for the given room wire id. + ExpandRoomNewThreadForm { + room_wire: String, + }, +} + +#[derive(Debug, Error)] +pub enum HtmlUiParseError { + #[error("missing __rpc__ field")] + MissingRpc, + #[error("invalid template json: {0}")] + Template(serde_json::Error), + #[error("invalid ui action: {0}")] + Action(serde_json::Error), +} + +/// Parse `__rpc__` JSON, apply `$form` holes from the rest of the form map, deserialize. +pub fn parse_html_ui_from_form(form: &HashMap) -> Result { + let template = form + .get(UI_RPC_FIELD) + .ok_or(HtmlUiParseError::MissingRpc)?; + let mut hole_map = form.clone(); + hole_map.remove(UI_RPC_FIELD); + let v: Value = fill_template_from_form(template, &hole_map).map_err(HtmlUiParseError::Template)?; + serde_json::from_value(v).map_err(HtmlUiParseError::Action) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn round_trip_post_ingest_with_holes() { + let template = serde_json::json!({ + "action": "post_ingest", + "room": "public", + "thread_tag": {"$form": "thread_tag"}, + "text": {"$form": "text"}, + "error_target": "e", + "form_id": "f", + }); + let mut form = HashMap::new(); + form.insert( + UI_RPC_FIELD.to_string(), + serde_json::to_string(&template).unwrap(), + ); + form.insert("thread_tag".into(), "x".into()); + form.insert("text".into(), "body".into()); + + let a = parse_html_ui_from_form(&form).unwrap(); + assert_eq!( + a, + HtmlUiAction::PostIngest { + room: "public".into(), + thread_tag: "x".into(), + text: "body".into(), + error_target: Some("e".into()), + form_id: Some("f".into()), + } + ); + } + + #[test] + fn expand_public_unit_variant() { + let template = serde_json::json!({ "action": "expand_public_new_thread_form" }); + let mut form = HashMap::new(); + form.insert( + UI_RPC_FIELD.to_string(), + serde_json::to_string(&template).unwrap(), + ); + let a = parse_html_ui_from_form(&form).unwrap(); + assert_eq!(a, HtmlUiAction::ExpandPublicNewThreadForm); + } +} diff --git a/server/src/lib.rs b/server/src/lib.rs index b9d4b79791ba8dd3a3c26ff777943a2548092de5..5f5b6b0f01b29350c7415e5801ec5caa74f0b452 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -3,6 +3,7 @@ pub mod paths; pub mod api; pub mod canonical_path; pub mod dsl; +pub mod form_template; pub mod html; pub mod event_log; pub mod events; @@ -33,6 +34,7 @@ pub fn create_app(state: AppState) -> Router { .route("/post", post(api::post_web_ingest)) .route("/post/redact", post(api::post_web_redact)) .route("/post/check", post(api::check_web_ingest)) + .route("/ui", post(api::post_ui_html)) .route("/theme", post(crate::html::post_theme)) .route("/sse", get(api::get_html_stream)) .route("/stream", get(api::get_stream)) Side B — contributor: tommy-mor Side B — commit message: [6d04afc2] refactor Side B — unified diff (full patch): diff --git a/Cargo.lock b/Cargo.lock index 2cea973082716e761ef6f5dd5886acc08ff9aac0..8c43fb75c472b102e6e1d3b837dce3355be898f2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,6 +17,28 @@ version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" +[[package]] +name = "async-stream" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476" +dependencies = [ + "async-stream-impl", + "futures-core", + "pin-project-lite", +] + +[[package]] +name = "async-stream-impl" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "async-trait" version = "0.1.89" @@ -1242,9 +1264,11 @@ dependencies = [ name = "sorter2-server" version = "0.0.1" dependencies = [ + "async-stream", "axum", "axum-extra", "dotenvy", + "futures-util", "maud", "reqwest", "serde", diff --git a/server/Cargo.toml b/server/Cargo.toml index bd600138b613bd0f546bdec217a5334cdcb20aa5..c940acb687fb141d21760a3d6656172013cf6f41 100644 --- a/server/Cargo.toml +++ b/server/Cargo.toml @@ -18,6 +18,8 @@ tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } reqwest = { version = "0.12", features = ["json"] } dotenvy = "0.15" +async-stream = "0.3" +futures-util = { version = "0.3", default-features = false, features = ["std"] } [dev-dependencies] reqwest = { version = "0.12", features = ["json"] } diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index b33a84e8bb5e817b26592868d88090e6d664d950..7af6527d03c483f33f3469ce6766c01a554c5fe3 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -6,7 +6,8 @@ use axum::{ use std::collections::HashMap; use crate::{ - html::{entity_section, input_panel, js_string_literal, ranking_panel, JsBuilder}, + fetch, + html::{input_panel, js_string_literal, ranking_panel, JsBuilder}, parser::parse_reddit_url, path_types::ItemId, reddit::ensure_partial_tree, @@ -89,18 +90,8 @@ pub async fn post_ui_html( }, HtmlUiAction::FetchEntity { item } => { let id = parse_item_param(&item); - if id.is_root() { - return ui_js_warn("nothing to fetch for the root").into_response(); - } - state.queue_entity_fetch(id.clone()); - let tree = state.tree.read().await; - let empty = crate::reducer::NodeState::default(); - let node = tree.get(&id).unwrap_or(&empty); - let panel = entity_section(&id, node, true); - JsBuilder::new() - .morph_selector("#entity-section", panel) - .into_response() - }, + fetch::fetch_entity_stream(state, id).into_response() + } } } diff --git a/server/src/fetch/html.rs b/server/src/fetch/html.rs new file mode 100644 index 0000000000000000000000000000000000000000..63634508496e224c38b9ec0308b7a6086462f925 --- /dev/null +++ b/server/src/fetch/html.rs @@ -0,0 +1,67 @@ +//! Markup for entity import / “Fetch from Reddit” (`POST /ui`, SSE response). + +use maud::{html, Markup}; + +use crate::{ + form_template::template_json_compact, + path_types::ItemId, + reddit::is_fetchable, + reducer::NodeState, + ui_action::UI_RPC_FIELD, +}; + +fn entity_panel(node: &NodeState) -> Markup { + html! { + @if let Some(data) = &node.data { + div id="entity-panel" class="entity-card" { + h2 { (data.title) } + @if let Some(author) = &data.author { + p class="muted small" { "by " (author) } + } + @if let Some(body) = &data.body_html { + div class="entity-body" { (maud::PreEscaped(body)) } + } + } + } + } +} + +/// Reddit/API import — `POST /ui` with `fetch_entity` returns an SSE stream. +pub fn fetch_entity_panel(item: &ItemId, has_data: bool, fetching: bool) -> Markup { + if !is_fetchable(item) { + return html! {}; + } + let label = if fetching { + "Fetching…" + } else if has_data { + "Fetch more" + } else { + "Fetch from Reddit" + }; + let rpc = template_json_compact(&serde_json::json!({ + "action": "fetch_entity", + "item": item.as_str(), + })) + .expect("fetch_entity rpc template"); + html! { + form method="post" action="/ui" id="fetch-entity-form" class="fetch-entity-form" { + input type="hidden" name=(UI_RPC_FIELD) value=(rpc); + @if fetching { + button type="submit" class="btn-secondary" disabled { (label) } + } @else { + button type="submit" class="btn-secondary" { (label) } + } + } + } +} + +/// Entity card + fetch control (target `#entity-section` for Idiomorph / SSE). +pub fn entity_section(item: &ItemId, node: &NodeState, fetching: bool) -> Markup { + let has_data = node.data.is_some(); + html! { + section id="entity-section" class="demo-panel" { + (entity_panel(node)) + (fetch_entity_panel(item, has_data, fetching)) + } + } +} diff --git a/server/src/fetch/mod.rs b/server/src/fetch/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2290f9d3a0f1cbf1806c6339f82a4515c11cc3d3 --- /dev/null +++ b/server/src/fetch/mod.rs @@ -0,0 +1,115 @@ +//! Entity import over `POST /ui` as SSE (Reddit worker in [`crate::reddit`]). + +pub mod html; + +use std::convert::Infallible; +use std::time::Duration; + +use async_stream::stream; +use axum::response::sse::{Event, KeepAlive, Sse}; +use futures_util::Stream; +use serde::Serialize; +use tokio::sync::oneshot; + +use crate::{ + path_types::ItemId, + reddit::FetchJobResult, + reducer::NodeState, + state::AppState, +}; + +pub fn now_ms() -> i64 { + let t = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default(); + t.as_millis() as i64 +} + +#[derive(Serialize)] +struct SseMorphPayload { + selector: &'static str, + html: String, +} + +fn morph_complete_event(html: maud::Markup) -> Event { + let payload = SseMorphPayload { + selector: "#entity-section", + html: html.into_string(), + }; + let data = serde_json::to_string(&payload).unwrap_or_else(|_| "{}".into()); + Event::default().event("complete").data(data) +} + +/// Stream `fetching` → `complete` / `error` for [`crate::ui_action::HtmlUiAction::FetchEntity`]. +pub fn fetch_entity_stream( + state: AppState, + id: ItemId, +) -> Sse>> { + tracing::debug!(item = %id, "fetch entity stream opened"); + + let stream = stream! { + if id.is_root() { + yield Ok(Event::default().event("error").data("{\"message\":\"nothing to fetch for the root\"}")); + return; + } + + if !crate::reddit::is_fetchable(&id) { + tracing::debug!(item = %id, "fetch stream: not fetchable"); + yield Ok(Event::default().event("error").data("{\"message\":\"this page cannot be fetched from Reddit\"}")); + return; + } + + let fetching_html = { + let tree = state.tree.read().await; + let empty = NodeState::default(); + let node = tree.get(&id).unwrap_or(&empty); + html::entity_section(&id, node, true).into_string() + }; + let fetching_payload = serde_json::json!({ + "selector": "#entity-section", + "html": fetching_html, + }); + yield Ok(Event::default().event("fetching").data(fetching_payload.to_string())); + + let (tx, rx) = oneshot::channel(); + state.reddit.request_fetch(id.clone(), true, Some(tx)); + tracing::debug!(item = %id, "fetch stream: queued reddit job"); + + let result = match rx.await { + Ok(r) => r, + Err(_) => { + tracing::warn!(item = %id, "fetch stream: worker dropped oneshot"); + FetchJobResult::Failed("reddit worker stopped".into()) + } + }; + + tracing::debug!(item = %id, ?result, "fetch stream: job finished"); + + match result { + FetchJobResult::Imported | FetchJobResult::NotFound => { + let tree = state.tree.read().await; + let empty = NodeState::default(); + let node = tree.get(&id).unwrap_or(&empty); + yield Ok(morph_complete_event(html::entity_section(&id, node, false))); + } + FetchJobResult::SkippedCached | FetchJobResult::SkippedDuplicate => { + let tree = state.tree.read().await; + let empty = NodeState::default(); + let node = tree.get(&id).unwrap_or(&empty); + yield Ok(morph_complete_event(html::entity_section(&id, node, false))); + } + FetchJobResult::RateLimited { reset_secs } => { + yield Ok(Event::default().event("error").data( + serde_json::json!({"message": format!("Reddit rate limit — retry in {reset_secs}s")}).to_string(), + )); + } + FetchJobResult::Failed(msg) => { + yield Ok(Event::default().event("error").data( + serde_json::json!({"message": msg}).to_string(), + )); + } + } + }; + + Sse::new(stream).keep_alive(KeepAlive::new().interval(Duration::from_secs(15))) +} diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index db5b4c7f06b0be64603981166835cde268234f67..9314a7556306ddab969b896dbf4126b542a46722 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -7,10 +7,10 @@ use axum::{ use maud::{html, Markup, DOCTYPE}; use crate::{ + fetch::html::entity_section, form_template::template_json_compact, path_types::ItemId, ranking::{top_bottom, RankedItem}, - reddit::is_fetchable, reducer::{GroupState, NodeState}, state::AppState, ui_action::UI_RPC_FIELD, @@ -149,62 +149,6 @@ pub fn breadcrumb_path(item: &ItemId) -> Markup { } } -fn entity_panel(node: &NodeState) -> Markup { - html! { - @if let Some(data) = &node.data { - div id="entity-panel" class="entity-card" { - h2 { (data.title) } - @if let Some(author) = &data.author { - p class="muted small" { "by " (author) } - } - @if let Some(body) = &data.body_html { - div class="entity-body" { (maud::PreEscaped(body)) } - } - } - } - } -} - -/// Reddit/API import control — only shown on fetchable pages; never auto-fires. -pub fn fetch_entity_panel(item: &ItemId, has_data: bool, fetching: bool) -> Markup { - if !is_fetchable(item) { - return html! {}; - } - let label = if fetching { - "Fetching…" - } else if has_data { - "Fetch more" - } else { - "Fetch from Reddit" - }; - let rpc = template_json_compact(&serde_json::json!({ - "action": "fetch_entity", - "item": item.as_str(), - })) - .expect("fetch_entity rpc template"); - html! { - form method="post" action="/ui" id="fetch-entity-form" class="fetch-entity-form" { - input type="hidden" name=(UI_RPC_FIELD) value=(rpc); - @if fetching { - button type="submit" class="btn-secondary" disabled { (label) } - } @else { - button type="submit" class="btn-secondary" { (label) } - } - } - } -} - -/// Entity card + explicit fetch control (morphed as `#entity-section`). -pub fn entity_section(item: &ItemId, node: &NodeState, fetching: bool) -> Markup { - let has_data = node.data.is_some(); - html! { - section id="entity-section" class="demo-panel" { - (entity_panel(node)) - (fetch_entity_panel(item, has_data, fetching)) - } - } -} - fn rank_list(label: &str, items: &[RankedItem], start_rank: usize) -> Markup { html! { @if !items.is_empty() { diff --git a/server/src/lib.rs b/server/src/lib.rs index 79b173f391a96ae5d0d96fd656e1e8d2dd070d09..0677363e0ed21d244bfa065f7ec728549ddd9e50 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -1,6 +1,7 @@ pub mod api; pub mod event_log; pub mod events; +pub mod fetch; pub mod form_template; pub mod html; pub mod parser; diff --git a/server/src/reddit.rs b/server/src/reddit.rs index ff0f01e57b18af878eb5be3efc47204a7673589d..0e6ce32720951a58456852b67fb76a85dd9f4aad 100644 --- a/server/src/reddit.rs +++ b/server/src/reddit.rs @@ -7,12 +7,12 @@ use std::time::{Duration, Instant}; use reqwest::{header, Client, StatusCode}; use serde::Deserialize; use serde_json::Value; -use tokio::sync::{mpsc, RwLock}; +use tokio::sync::{mpsc, oneshot, RwLock}; use crate::{ event_log::EventLog, events::Event, - html::now_ms, + fetch::now_ms, path_types::ItemId, reducer::GlobalTree, }; @@ -22,10 +22,21 @@ pub fn ensure_partial_tree(tree: &mut GlobalTree, id: &ItemId) { tree.ensure_path(id); } +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum FetchJobResult { + Imported, + NotFound, + SkippedDuplicate, + SkippedCached, + RateLimited { reset_secs: u64 }, + Failed(String), +} + pub struct RedditCommand { pub id: ItemId, /// User-initiated fetch bypasses the in-memory "recently fetched" cache. pub force: bool, + pub done: Option>, } #[derive(Clone)] @@ -72,14 +83,29 @@ impl RedditBroker { .build() .expect("reqwest client"); + tracing::debug!( + api_base = %config.api_base, + oauth_base = %config.oauth_base, + oauth = config.creds.is_some(), + "reddit worker started" + ); + tokio::spawn(reddit_worker(rx, tree, event_log, client, config)); Self { tx } } /// Queue a fetch; drops when the channel is full (backpressure). - pub fn request_fetch(&self, id: ItemId, force: bool) { - let _ = self.tx.try_send(RedditCommand { id, force }); + pub fn request_fetch( + &self, + id: ItemId, + force: bool, + done: Option>, + ) { + match self.tx.try_send(RedditCommand { id: id.clone(), force, done }) { + Ok(()) => tracing::debug!(item = %id, force, "reddit fetch queued"), + Err(_) => tracing::warn!(item = %id, "reddit fetch queue full, dropped"), + } } } @@ -95,8 +121,6 @@ impl RedditApiConfig { } impl RedditCredentials { - /// Reddit's OAuth docs call these "client id" and "client secret"; the app - /// registration UI often labels them "app id" / "app secret" — same values. fn from_env() -> Option { let client_id = std::env::var("REDDIT_CLIENT_ID") .or_else(|_| std::env::var("REDDIT_APP_ID")) @@ -128,12 +152,10 @@ pub fn default_user_agent() -> String { }) } -/// True when this node can be loaded from the Reddit JSON API. pub fn is_fetchable(id: &ItemId) -> bool { !map_item_to_reddit_api(id, "https://example.com").is_empty() } -/// Derive UI-facing fields from a stored payload (Reddit-specific when under reddit.com). pub fn entity_view_from_payload(id: &ItemId, payload: &Value) -> Option { if id.as_str().starts_with("reddit.com") { return parse_reddit_view(id, payload); @@ -141,12 +163,17 @@ pub fn entity_view_from_payload(id: &ItemId, payload: &Value) -> Option>, result: FetchJobResult) { + if let Some(tx) = done { + let _ = tx.send(result); + } +} + async fn reddit_worker( mut rx: mpsc::Receiver, tree: Arc>, @@ -168,15 +195,25 @@ async fn reddit_worker( recently_fetched.retain(|_, t| now.duration_since(*t) < cache_ttl); if in_flight.contains(&cmd.id) { + tracing::debug!(item = %cmd.id, "reddit fetch skipped: already in flight"); + notify(cmd.done, FetchJobResult::SkippedDuplicate); continue; } if !cmd.force && recently_fetched.contains_key(&cmd.id) { + tracing::debug!(item = %cmd.id, "reddit fetch skipped: recently fetched cache"); + notify(cmd.done, FetchJobResult::SkippedCached); continue; } in_flight.insert(cmd.id.clone()); let fetch_id = cmd.id.clone(); + let done = cmd.done; + tracing::debug!( + item = %fetch_id, + delay_ms = current_delay.as_millis(), + "reddit fetch starting after delay" + ); tokio::time::sleep(current_delay).await; if let Some(c) = &creds { @@ -184,8 +221,18 @@ async fn reddit_worker( } let token = oauth.as_ref().map(|t| t.access_token.as_str()); + if token.is_some() { + tracing::debug!(item = %fetch_id, "reddit fetch using OAuth bearer"); + } + + let fetch_base = if token.is_some() { + &oauth_base + } else { + &api_base + }; + let outcome = do_fetch(&client, fetch_base, &fetch_id, token).await; - match do_fetch(&client, &api_base, &fetch_id, token).await { + match outcome { Ok(FetchOutcome::Payload(payload)) => { let ts = now_ms(); let event = Event::EntityImported { @@ -193,30 +240,49 @@ async fn reddit_worker( ts, payload: payload.clone(), }; - if let Err(e) = event_log.append(&event).await { - tracing::warn!("event log append failed for {}: {}", fetch_id, e); - } else { - apply_entity_import(&mut *tree.write().await, &fetch_id, payload); - recently_fetched.insert(fetch_id.clone(), Instant::now()); - current_delay = Duration::from_millis(600); + tracing::debug!( + item = %fetch_id, + ts, + payload_keys = ?payload.as_object().map(|o| o.len()), + "reddit fetch got JSON payload, appending event" + ); + match event_log.append(&event).await { + Err(e) => { + tracing::warn!( + item = %fetch_id, + err = %e, + "reddit event log append failed" + ); + notify(done, FetchJobResult::Failed(e.to_string())); + } + Ok(()) => { + apply_entity_import(&mut *tree.write().await, &fetch_id, payload); + recently_fetched.insert(fetch_id.clone(), Instant::now()); + current_delay = Duration::from_millis(600); + tracing::info!(item = %fetch_id, "reddit entity imported"); + notify(done, FetchJobResult::Imported); + } } } Ok(FetchOutcome::NotFound) => { + tracing::debug!(item = %fetch_id, "reddit fetch: not found (no event written)"); recently_fetched.insert(fetch_id.clone(), Instant::now()); + notify(done, FetchJobResult::NotFound); } Ok(FetchOutcome::RateLimited { reset_secs }) => { - let wait = Duration::from_secs(reset_secs.max(1)); tracing::warn!( - "Reddit rate limit for {}; sleeping {}s", - fetch_id, - wait.as_secs() + item = %fetch_id, + reset_secs, + "reddit rate limited" ); - tokio::time::sleep(wait).await; + tokio::time::sleep(Duration::from_secs(reset_secs.max(1))).await; current_delay = (current_delay * 2).min(Duration::from_secs(60)); + notify(done, FetchJobResult::RateLimited { reset_secs }); } Err(e) => { - tracing::warn!("Reddit fetch failed for {}: {}", fetch_id, e); + tracing::warn!(item = %fetch_id, err = %e, "reddit fetch failed"); current_delay = (current_delay * 2).min(Duration::from_secs(60)); + notify(done, FetchJobResult::Failed(e)); } } @@ -238,6 +304,7 @@ async fn ensure_oauth_token( ) -> Option { if let Some(t) = existing { if Instant::now() < t.expires_at - Duration::from_secs(60) { + tracing::debug!("reddit OAuth token still valid"); return Some(t); } } @@ -246,6 +313,7 @@ async fn ensure_oauth_token( "{}/api/v1/access_token", oauth_base.trim_end_matches('/') ); + tracing::debug!(%url, "reddit OAuth token request"); let resp = client .post(&url) @@ -257,13 +325,13 @@ async fn ensure_oauth_token( let resp = match resp { Ok(r) => r, Err(e) => { - tracing::warn!("Reddit OAuth token request failed: {e}"); + tracing::warn!("reddit OAuth token request failed: {e}"); return None; } }; if !resp.status().is_success() { - tracing::warn!("Reddit OAuth token HTTP {}", resp.status()); + tracing::warn!("reddit OAuth token HTTP {}", resp.status()); return None; } @@ -276,11 +344,12 @@ async fn ensure_oauth_token( let body: TokenResponse = match resp.json().await { Ok(b) => b, Err(e) => { - tracing::warn!("Reddit OAuth token parse failed: {e}"); + tracing::warn!("reddit OAuth token parse failed: {e}"); return None; } }; + tracing::debug!(expires_in = body.expires_in, "reddit OAuth token acquired"); Some(OAuthToken { access_token: body.access_token, expires_at: Instant::now() + Duration::from_secs(body.expires_in), @@ -295,35 +364,72 @@ async fn do_fetch( ) -> Result { let url = map_item_to_reddit_api(id, api_base); if url.is_empty() { + tracing::debug!(item = %id, "reddit do_fetch: no API URL for item"); return Ok(FetchOutcome::NotFound); } + tracing::debug!(item = %id, %url, bearer = bearer.is_some(), "reddit HTTP GET"); + let mut req = client.get(&url); if let Some(token) = bearer { req = req.bearer_auth(token); } - let resp = req.send().await.map_err(|e| e.to_string())?; + let resp = req.send().await.map_err(|e| { + tracing::debug!(item = %id, %url, err = %e, "reddit HTTP transport error"); + e.to_string() + })?; + + let status = resp.status(); + tracing::debug!( + item = %id, + %url, + %status, + remaining = ?rate_limit_remaining(&resp), + reset = ?rate_limit_reset_secs(&resp), + "reddit HTTP response" + ); - if resp.status() == StatusCode::TOO_MANY_REQUESTS { + if status == StatusCode::TOO_MANY_REQUESTS { let reset = rate_limit_reset_secs(&resp); return Ok(FetchOutcome::RateLimited { reset_secs: reset }); } - if resp.status() == StatusCode::SERVICE_UNAVAILABLE { - return Err("Reddit unavailable (503)".to_string()); + if status == StatusCode::SERVICE_UNAVAILABLE { + return Err("Reddit unavailable (503)".into()); } - if !resp.status().is_success() { + if !status.is_success() { + let body = resp.text().await.unwrap_or_default(); + tracing::debug!( + item = %id, + %status, + body_len = body.len(), + body_prefix = %body.chars().take(240).collect::(), + "reddit non-success body" + ); return Ok(FetchOutcome::NotFound); } if rate_limit_remaining(&resp) == Some(0) { let reset = rate_limit_reset_secs(&resp); + tracing::debug!(item = %id, reset_secs = reset, "reddit headers: rate limit exhausted"); return Ok(FetchOutcome::RateLimited { reset_secs: reset }); } - let payload: Value = resp.json().await.map_err(|e| e.to_string())?; + let text = resp.text().await.map_err(|e| e.to_string())?; + tracing::debug!(item = %id, bytes = text.len(), "reddit response body received"); + + let payload: Value = serde_json::from_str(&text).map_err(|e| { + tracing::debug!( + item = %id, + err = %e, + body_prefix = %text.chars().take(240).collect::(), + "reddit JSON parse failed" + ); + format!("invalid JSON: {e}") + })?; + Ok(FetchOutcome::Payload(payload)) } @@ -344,7 +450,6 @@ fn rate_limit_reset_secs(resp: &reqwest::Response) -> u64 { .unwrap_or(5) } -/// Map canonical item id to a Reddit JSON API URL under `api_base`. pub fn map_item_to_reddit_api(id: &ItemId, api_base: &str) -> String { let path = id.as_str(); if !path.starts_with("reddit.com/") && path != "reddit.com" { @@ -445,26 +550,6 @@ mod tests { map_item_to_reddit_api(&id, "https://www.reddit.com"), "https://www.reddit.com/r/rust/about.json?raw_json=1" ); - assert_eq!( - map_item_to_reddit_api(&id, "http://127.0.0.1:9999"), - "http://127.0.0.1:9999/r/rust/about.json?raw_json=1" - ); - } - - #[test] - fn map_post_url() { - let id = ItemId::parse("reddit.com/r/amitheasshole/comments/1trnvdl").unwrap(); - assert_eq!( - map_item_to_reddit_api(&id, "https://www.reddit.com"), - "https://www.reddit.com/r/amitheasshole/comments/1trnvdl.json?raw_json=1" - ); - } - - #[test] - fn is_fetchable_reddit_sub() { - let id = ItemId::parse("reddit.com/r/rust").unwrap(); - assert!(is_fetchable(&id)); - assert!(!is_fetchable(&ItemId::opaque("example.com/x"))); } #[test] @@ -477,19 +562,5 @@ mod tests { ) .unwrap(); assert_eq!(entity.title, "The Rust Programming Language"); - assert!(entity.body_html.as_ref().is_some_and(|b| b.contains("Rust"))); - } - - #[test] - fn parse_post_fixture() { - let json = r#"[{"kind":"Listing","data":{"children":[{"kind":"t3","data":{"title":"AITA","author":"op","selftext_html":"<p>hi</p>","thumbnail":"https://b.thumbs.redditmedia.com/x.jpg"}}]}}]"#; - let v: Value = serde_json::from_str(json).unwrap(); - let entity = entity_view_from_payload( - &ItemId::parse("reddit.com/r/x/comments/abc").unwrap(), - &v, - ) - .unwrap(); - assert_eq!(entity.title, "AITA"); - assert_eq!(entity.author.as_deref(), Some("op")); } } diff --git a/server/src/state.rs b/server/src/state.rs index d71d1079a8f486cdab15795384aef0b81b32544d..e7ff9f663e45b5e168d6a3869948e3bd890966d4 100644 --- a/server/src/state.rs +++ b/server/src/state.rs @@ -143,9 +143,9 @@ impl AppState { Ok(()) } - /// User-initiated Reddit/API import (via "Fetch more" — never on paste or navigate). - pub fn queue_entity_fetch(&self, id: ItemId) { - self.reddit.request_fetch(id, true); + /// User-initiated Reddit/API import (SSE / fetch module only). + pub fn queue_entity_fetch(&self, id: ItemId, done: Option>) { + self.reddit.request_fetch(id, true, done); } pub async fn record_vote( diff --git a/server/src/ui_action.rs b/server/src/ui_action.rs index 3d6a49a2a3fb950752827efe1f5a049308f09baf..ef9ac873fc0442e0b960f144309c8e91124d7884 100644 --- a/server/src/ui_action.rs +++ b/server/src/ui_action.rs @@ -26,7 +26,7 @@ pub enum HtmlUiAction { ParseQuery { query: String, }, - /// Fetch upstream entity data for the current page (explicit user action only). + /// Import entity data; `POST /ui` responds with `text/event-stream` (not JS). FetchEntity { item: String, }, diff --git a/server/static/sorter_ui.js b/server/static/sorter_ui.js index d9b016f197547f37ca4b2bcdd7ee6b673d0fb3f0..fe7bfc657c0fccae5c596d005b0e807abefec677 100644 --- a/server/static/sorter_ui.js +++ b/server/static/sorter_ui.js @@ -1,5 +1,5 @@ /** - * sorter2 web UI: fetch/eval for POST /ui. No product logic here. + * sorter2 web UI: POST /ui returns JS (morph) or SSE (entity fetch). */ (function () { function evalJs(js) { @@ -8,15 +8,98 @@ } } + function morphSelector(selector, html) { + var el = document.querySelector(selector); + if (el && typeof Idiomorph !== 'undefined') { + Idiomorph.morph(el, html); + } + } + + function handleSseEvent(eventType, data, form) { + if (eventType === 'fetching' || eventType === 'complete') { + try { + var msg = JSON.parse(data); + morphSelector(msg.selector || '#entity-section', msg.html); + } catch (err) { + console.warn('fetch morph parse', err); + } + } + if (eventType === 'complete' || eventType === 'error') { + var btn = form && form.querySelector('button[type="submit"]'); + if (btn) btn.disabled = false; + } + if (eventType === 'error') { + try { + var err = JSON.parse(data); + console.warn('fetch error:', err.message || data); + } catch (_e) { + console.warn('fetch error:', data); + } + } + } + + function consumeSseStream(response, form) { + var reader = response.body.getReader(); + var decoder = new TextDecoder(); + var buffer = ''; + var eventType = ''; + var dataLines = []; + + function dispatch() { + if (!eventType && dataLines.length === 0) return; + handleSseEvent(eventType || 'message', dataLines.join('\n'), form); + eventType = ''; + dataLines = []; + } + + function pump() { + return reader.read().then(function (chunk) { + if (chunk.done) { + dispatch(); + return; + } + buffer += decoder.decode(chunk.value, { stream: true }); + var parts = buffer.split('\n'); + buffer = parts.pop() || ''; + for (var i = 0; i < parts.length; i++) { + var line = parts[i].replace(/\r$/, ''); + if (line === '') { + dispatch(); + } else if (line.indexOf('event:') === 0) { + eventType = line.slice(6).trim(); + } else if (line.indexOf('data:') === 0) { + dataLines.push(line.slice(5).trim()); + } + } + return pump(); + }); + } + + return pump(); + } + function postUiForm(form) { + var btn = form.querySelector('button[type="submit"]'); + if (form.id === 'fetch-entity-form' && btn) { + btn.disabled = true; + } return fetch(form.action, { method: 'POST', body: new URLSearchParams(new FormData(form)), headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, credentials: 'same-origin', }).then(function (resp) { - return resp.text(); - }).then(evalJs); + var ct = resp.headers.get('content-type') || ''; + if (ct.indexOf('text/event-stream') !== -1) { + return consumeSseStream(resp, form); + } + return resp.text().then(evalJs); + }).catch(function (err) { + if (form.id === 'fetch-entity-form' && btn) { + btn.disabled = false; + } + console.warn('POST /ui failed', err); + }); } function initSorterUi() { diff --git a/test/reddit_import.clj b/test/reddit_import.clj index 54edaedeef08718c8f184d6aa468d8e6415068c7..17f2ee39e1498b0b6bb6a9d8a7e35608b0bd1b32 100644 --- a/test/reddit_import.clj +++ b/test/reddit_import.clj @@ -44,10 +44,12 @@ (do (Thread/sleep 200) (recur)) false)))))) -(defn- curl-post-ui [base rpc-json] +(defn- curl-fetch-ui-sse [base item] (process/shell {:out :string :err :string} - "curl" "-sf" "-X" "POST" (str base "/ui") - "--data-urlencode" (str "__rpc__=" rpc-json))) + "curl" "-sfN" "--max-time" "20" + "-X" "POST" (str base "/ui") + "--data-urlencode" + (str "__rpc__={\"action\":\"fetch_entity\",\"item\":\"" item "\"}"))) (defn- wait-event-log [path ms] (let [deadline (+ (System/currentTimeMillis) ms)] @@ -98,11 +100,12 @@ "curl" "-sf" browse-url))] (is (str/includes? before "Fetch from Reddit")) (is (not (str/includes? before "The Rust Programming Language"))) - (let [rpc "{\"action\":\"fetch_entity\",\"item\":\"reddit.com/r/rust\"}" - post (curl-post-ui app-base rpc) - log-path (str data-dir "/events.jsonl")] - (is (zero? (:exit post)) "fetch_entity POST succeeds") - (is (wait-event-log log-path 10000) "event log written") + (let [log-path (str data-dir "/events.jsonl") + sse (curl-fetch-ui-sse app-base "reddit.com/r/rust")] + (is (zero? (:exit sse)) "POST /ui fetch_entity SSE succeeds") + (is (str/includes? (:out sse) "event: complete")) + (is (str/includes? (:out sse) "The Rust Programming Language")) + (is (wait-event-log log-path 2000) "event log written") (let [after (:out (process/shell {:out :string :err :string} "curl" "-sf" browse-url)) log (slurp (io/file log-path))]