A mistyped address shows the not-found page (closes #294) 8ad8e656a3a6

- **A mistyped address shows the not-found page (#294):** an address the hub could not read, such as a project or issue number that is not a number, answered with a raw parse error ("Invalid URL: Cannot parse value …"); it now shows the site's not-found page, signed-in header and all.

        .layer(axum::middleware::from_fn_with_state(app.clone(), rejections_as_pages))

/// A page address the router matched but could not read (a number that is

/// not one, a malformed query): axum answers that in plain text before any

/// handler runs. For pages, that is the site's not-found page instead

/// (#294); the oxy protocol and anything not asked for with GET or HEAD keep

/// the plain answer.

async fn rejections_as_pages(

    axum::extract::State(app): axum::extract::State<Shared>,

    req: axum::extract::Request,

    next: axum::middleware::Next,

) -> Response {

    let page = matches!(*req.method(), axum::http::Method::GET | axum::http::Method::HEAD) && !req.uri().path().contains("/oxy/v1/");

    if !page {

        return next.run(req).await;

    }

    let (uri, headers) = (req.uri().clone(), req.headers().clone());

    let res = next.run(req).await;

    let plain = res.headers().get(header::CONTENT_TYPE).and_then(|v| v.to_str().ok()).is_some_and(|t| t.starts_with("text/plain"));

    if !(plain && matches!(res.status(), StatusCode::BAD_REQUEST | StatusCode::UNPROCESSABLE_ENTITY)) {

        return res;

    }

    // Only axum's own rejections: a handler's plain 400 (the live stream's

    // "unknown topic") is the handler's answer and stays.

    let (head, body) = res.into_parts();

    let Ok(bytes) = axum::body::to_bytes(body, 4096).await else { return StatusCode::BAD_REQUEST.into_response() };

    let rejected = [&b"Invalid URL"[..], b"Failed to deserialize query string", b"Failed to deserialize the query string"]

        .iter()

        .any(|p| bytes.starts_with(p));

    if !rejected {

        return Response::from_parts(head, axum::body::Body::from(bytes));

    }

    let mut probe = axum::http::Request::builder().uri(uri.clone()).body(()).expect("a request");

    *probe.headers_mut() = headers;

    let (mut parts, ()) = probe.into_parts();

    let viewer = match <Viewer as axum::extract::FromRequestParts<Shared>>::from_request_parts(&mut parts, &app).await {

        Ok(v) => v,

        Err(never) => match never {},

    };

    Error::not_found(Shell::new(&app, uri.path(), &viewer)).into_response()

}

    // #294: an address the router matches but cannot read (a project or

    // issue number that is not one) is the not-found page, not a parse error.

    for bad in ["/projects/andy/metalgear2", "/andy/demo/issue/abc", "/andy/demo/proposal/x1"] {

        let (status, body) = get(&h.app, bad).await;

        assert_eq!(status, StatusCode::NOT_FOUND, "{bad}");

        assert!(body.contains("There is nothing at this address.") && !body.contains("Cannot parse"), "{bad}: {body}");

    }