add: gemini routes

This commit is contained in:
wymiller committed 2026-11-09 18:45:34 -05:00
1 parent 5cb5dd8eb8
commit 1ff76d82f8
11 files changed
+537 -20

No files matched your search

+22
View File
@@ -18,3 +18,25 @@ For `public` to work properly, please make sure to first create the `.env` file,
- `DATABASE_URL` - needed for connecting to Postgres - `DATABASE_URL` - needed for connecting to Postgres
- `REDIS_URL` - needed for connecting to the cache (Redis or Valkey) - `REDIS_URL` - needed for connecting to the cache (Redis or Valkey)
- `BASE_URI_WEB` - needed for connecting to the frontend user interface of the system to this service - `BASE_URI_WEB` - needed for connecting to the frontend user interface of the system to this service
### Gemini
Set `SERVE_APP=gemini` to run the existing Gemini TLS server on port 1965.
It uses `dev-cert.der` and `dev-key.der` in the working directory; database and
cache configuration is shared with HTTP mode. `BASE_URI_WEB` supplies links back
to the web site for RSS, the sitemap, contact forms, and posts without Gemtext.
The capsule follows the web site's navigation and page sections:
- `/`, `/contact`, `/health`
- `/posts`, `/posts/all`, `/posts/{id}`
- `/posts/featured`, `/posts/recent`, `/posts/popular`, `/posts/hot`
- `/authors`, `/authors/{id}`, `/authors/{id}/posts`
- `/projects`
- `/comments/index`, `/comments/post/{id}`
Author and comment indexes accept `?page=1&limit=12` (maximum limit 100).
Author pages include a biography and paginated post links. Article pages render
`body_gemtext` as Gemtext, with author, publication date, and featured status;
articles without it link to the HTML version. Comments are read-only, with a
link to the web page for participation.
+1 -1
View File
@@ -15,7 +15,7 @@ impl AuthorsDatasource {
sqlx::query_as!( sqlx::query_as!(
Author, Author,
"SELECT author_id, first_name, last_name, bio, image FROM authors ORDER BY created_at DESC LIMIT $1 OFFSET $2", "SELECT author_id, first_name, last_name, bio, image FROM authors ORDER BY created_at DESC LIMIT $1 OFFSET $2",
pagination.page, pagination.limit,
offset, offset,
) )
.fetch_all(pool) .fetch_all(pool)
+1 -1
View File
@@ -29,7 +29,7 @@ impl CommentsDatasource {
pagination: Pagination, pagination: Pagination,
) -> Result<Vec<Comment>, sqlx::Error> { ) -> Result<Vec<Comment>, sqlx::Error> {
let offset: i64 = (pagination.page - 1) * pagination.limit; let offset: i64 = (pagination.page - 1) * pagination.limit;
sqlx::query_as!(Comment, "SELECT comment_id, name, body, created_at FROM comments ORDER BY created_at DESC LIMIT $1 OFFSET $2", pagination.page, offset) sqlx::query_as!(Comment, "SELECT comment_id, name, body, created_at FROM comments ORDER BY created_at DESC LIMIT $1 OFFSET $2", pagination.limit, offset)
.fetch_all(pool) .fetch_all(pool)
.await .await
} }
+2 -4
View File
@@ -1,5 +1,5 @@
use axum::Router; use axum::Router;
use gemi::{EndpointExt, GeminiConfig, GeminiResponse, GeminiRouter, GeminiServer}; use gemi::{EndpointExt, GeminiConfig, GeminiServer};
use cache::ClientLike; use cache::ClientLike;
use config::config; use config::config;
use sqlx::postgres::PgPoolOptions; use sqlx::postgres::PgPoolOptions;
@@ -154,9 +154,7 @@ async fn main() {
.expect("failed to install Rustls crypto provider"); .expect("failed to install Rustls crypto provider");
let gemini_state = app_state.clone(); let gemini_state = app_state.clone();
let mut router = GeminiRouter::default(); let router = routes::gemini::routes().expect("Failed to construct Gemini routes");
router.nest("/", routes::gemini::root::RootGeminiRoutes::routes().expect("Failed to construct Gemini root routes"));
router.nest("/posts", routes::gemini::posts::PostsGeminiRoutes::routes().expect("Failed to construct Gemini posts routes"));
let config = GeminiConfig::new("localhost"); let config = GeminiConfig::new("localhost");
let app = router.with_state(gemini_state); let app = router.with_state(gemini_state);
let server = GeminiServer::new(app, "dev-cert.der", "dev-key.der", config).unwrap(); let server = GeminiServer::new(app, "dev-cert.der", "dev-key.der", config).unwrap();
@@ -0,0 +1,93 @@
use super::format::{self, line, page};
use crate::{datasources::authors::AuthorsDatasource, state::AppState};
use gemi::{GeminiRequest, GeminiResponse, GeminiRouter, Params, State};
pub struct AuthorsGeminiRoutes;
impl AuthorsGeminiRoutes {
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default();
router.add_route("/", Self::all)?;
router.add_route("/{id}", Self::one)?;
router.add_route("/{id}/posts", Self::one)?;
Ok(router)
}
async fn all(State(state): State<AppState>, request: GeminiRequest) -> GeminiResponse {
let p = match format::pagination(&request) {
Ok(p) => p,
Err(e) => return e,
};
let pool = state.lock().await.database.clone();
let result = AuthorsDatasource::get_all(
&pool,
crate::utils::pagination::Pagination {
page: p.page,
limit: p.limit,
},
)
.await;
match result {
Ok(authors) => {
let mut body = String::new();
for author in &authors {
body += &format!(
"=> /authors/{} {} {}\n",
author.author_id,
line(&author.first_name),
line(&author.last_name)
);
}
if authors.is_empty() {
body += "No authors found.\n";
}
body += &format::navigation("/authors", &p, authors.len() as i64 == p.limit);
page("Authors", &body)
}
Err(e) => format::error(e),
}
}
async fn one(
State(state): State<AppState>,
params: Params,
request: GeminiRequest,
) -> GeminiResponse {
let id = match format::id(&params) {
Ok(id) => id,
Err(e) => return e,
};
let p = match format::pagination(&request) {
Ok(p) => p,
Err(e) => return e,
};
let pool = state.lock().await.database.clone();
let author = match AuthorsDatasource::get_one(&pool, id).await {
Ok(a) => a,
Err(e) => return format::error(e),
};
match AuthorsDatasource::get_authors_posts(
&pool,
id,
crate::utils::pagination::Pagination {
page: p.page,
limit: p.limit,
},
)
.await
{
Ok((posts, total)) => {
let body = format!(
"{}\n\n## Posts\n{}{}",
line(author.bio.as_deref().unwrap_or("")),
format::posts(&posts),
format::navigation(&format!("/authors/{id}"), &p, p.page * p.limit < total)
);
page(
&format!("{} {}", author.first_name, author.last_name),
&body,
)
}
Err(e) => format::error(e),
}
}
}
@@ -0,0 +1,80 @@
use super::format::{self, line, page};
use crate::{
datasources::comments::CommentsDatasource, models::comments::Comment, state::AppState,
};
use gemi::{GeminiRequest, GeminiResponse, GeminiRouter, Params, State};
pub struct CommentsGeminiRoutes;
impl CommentsGeminiRoutes {
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default();
router.add_route("/post/{id}", Self::post)?;
router.add_route("/index", Self::index)?;
Ok(router)
}
async fn post(State(state): State<AppState>, params: Params) -> GeminiResponse {
let id = match format::id(&params) {
Ok(id) => id,
Err(e) => return e,
};
let pool = state.lock().await.database.clone();
match CommentsDatasource::get_posts_comments(&pool, id).await {
Ok(comments) => page(
"Comments",
&format!(
"{}\n=> /posts/{id} Back to post\n=> {} Leave a comment on the web",
render(&comments),
format::web_url(&format!("/posts/{id}"))
),
),
Err(e) => format::error(e),
}
}
async fn index(State(state): State<AppState>, request: GeminiRequest) -> GeminiResponse {
let p = match format::pagination(&request) {
Ok(p) => p,
Err(e) => return e,
};
let pool = state.lock().await.database.clone();
let result = CommentsDatasource::get_index_comments(
&pool,
crate::utils::pagination::Pagination {
page: p.page,
limit: p.limit,
},
)
.await;
match result {
Ok(comments) => page(
"Recent comments",
&format!(
"{}{}",
render(&comments),
format::navigation("/comments/index", &p, comments.len() as i64 == p.limit)
),
),
Err(e) => format::error(e),
}
}
}
fn render(comments: &[Comment]) -> String {
if comments.is_empty() {
return "No comments yet.\n".into();
}
comments
.iter()
.map(|c| {
format!(
"## {}\n{}\n{}\n\n",
line(&c.name),
c.created_at
.map(|d| d.format("%B %d, %Y").to_string())
.unwrap_or_default(),
line(&c.body)
)
})
.collect()
}
+156
View File
@@ -0,0 +1,156 @@
use crate::{models::posts::Post, utils::pagination::Pagination};
use gemi::{GeminiRequest, GeminiResponse, Params};
pub fn line(text: &str) -> String {
text.split_whitespace().collect::<Vec<_>>().join(" ")
}
pub fn web_url(path: &str) -> String {
format!(
"{}{}",
std::env::var("BASE_URI_WEB")
.unwrap_or_else(|_| "https://wyattjmiller.com".into())
.trim_end_matches('/'),
path
)
}
pub fn page(title: &str, body: &str) -> GeminiResponse {
format!("# {}\n\n=> / Home\n=> /posts Blog\n=> /projects Projects\n=> /contact Contact\n\n{}\n\n## Elsewhere\n=> /authors Authors\n=> {} RSS\n=> {} Sitemap\n=> mailto:wjmiller2016@gmail.com Email me\n\n© {} Miller Web Solutions. All Rights Reserved. Hosted by Akamai.\n",
line(title), body, web_url("/rss"), web_url("/sitemap"), chrono::Utc::now().format("%Y")).into()
}
pub fn posts(posts: &[Post]) -> String {
if posts.is_empty() {
return "No posts yet.\n".into();
}
posts
.iter()
.map(|p| {
let date = p
.publish_date
.or(p.created_at)
.map(|d| d.format("%B %d, %Y").to_string())
.unwrap_or_default();
format!(
"=> /posts/{} {}\n{} · {} {}\n\n",
p.post_id,
line(&p.title),
date,
line(p.first_name.as_deref().unwrap_or("")),
line(p.last_name.as_deref().unwrap_or(""))
)
})
.collect()
}
pub fn id(params: &Params) -> Result<i32, GeminiResponse> {
params
.0
.get("id")
.and_then(|s| s.parse::<i32>().ok())
.filter(|id| *id > 0)
.ok_or_else(|| GeminiResponse::bad_request("Expected a positive numeric ID"))
}
pub fn pagination(request: &GeminiRequest) -> Result<Pagination, GeminiResponse> {
let mut result = Pagination { page: 1, limit: 12 };
for (key, value) in request.url.query_pairs() {
let target = match key.as_ref() {
"page" => &mut result.page,
"limit" => &mut result.limit,
_ => continue,
};
*target = value
.parse::<i64>()
.ok()
.filter(|n| *n > 0)
.ok_or_else(|| {
GeminiResponse::bad_request("page and limit must be positive integers")
})?;
}
if result.limit > 100 || result.page.checked_mul(result.limit).is_none() {
return Err(GeminiResponse::bad_request(
"Pagination out of range (maximum limit: 100)",
));
}
Ok(result)
}
pub fn navigation(path: &str, p: &Pagination, has_next: bool) -> String {
let mut result = format!("\nPage {}\n", p.page);
if p.page > 1 {
result += &format!(
"=> {path}?page={}&limit={} Previous page\n",
p.page - 1,
p.limit
);
}
if has_next {
result += &format!(
"=> {path}?page={}&limit={} Next page\n",
p.page + 1,
p.limit
);
}
result
}
pub fn error(error: sqlx::Error) -> GeminiResponse {
match error {
sqlx::Error::RowNotFound => GeminiResponse::not_found("Not found"),
error => {
tracing::error!(%error, "Gemini database request failed");
GeminiResponse::temporary_failure("Unable to load this page. Please try again later.")
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn request(query: &str) -> GeminiRequest {
let url = format!("gemini://localhost/authors?{query}")
.parse()
.unwrap();
GeminiRequest {
url,
path: "/authors".into(),
query: Some(query.into()),
}
}
#[test]
fn pagination_rejects_invalid_and_overflowing_values() {
for query in [
"page=0",
"page=-1",
"limit=101",
"limit=no",
"page=9223372036854775807&limit=100",
] {
assert!(pagination(&request(query)).is_err(), "{query}");
}
let p = pagination(&request("page=2&limit=10")).ok().unwrap();
assert_eq!((p.page, p.limit), (2, 10));
let links = navigation("/authors/1", &p, true);
assert!(links.contains("/authors/1?page=1&limit=10"));
assert!(links.contains("/authors/1?page=3&limit=10"));
}
#[test]
fn metadata_cannot_inject_gemtext_lines() {
assert_eq!(line("Title\r\n=> /evil link"), "Title => /evil link");
let response = page("Title\n# Injected", "Article body");
let body = String::from_utf8(response.body).unwrap();
assert!(body.starts_with("# Title # Injected\n"));
assert!(body.contains("=> /posts Blog\n"));
}
#[test]
fn missing_rows_and_database_failures_have_distinct_statuses() {
assert_eq!(error(sqlx::Error::RowNotFound).status_code.to_u8(), 51);
assert_eq!(error(sqlx::Error::PoolClosed).status_code.to_u8(), 40);
}
}
+25
View File
@@ -1,2 +1,27 @@
pub mod authors;
pub mod comments;
mod format;
pub mod posts; pub mod posts;
pub mod projects;
pub mod root; pub mod root;
use crate::state::AppState;
use gemi::GeminiRouter;
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default();
router.nest("/", root::RootGeminiRoutes::routes()?)?;
router.nest("/posts", posts::PostsGeminiRoutes::routes()?)?;
router.nest("/authors", authors::AuthorsGeminiRoutes::routes()?)?;
router.nest("/projects", projects::ProjectsGeminiRoutes::routes()?)?;
router.nest("/comments", comments::CommentsGeminiRoutes::routes()?)?;
Ok(router)
}
#[cfg(test)]
mod tests {
#[test]
fn routers_compose_without_conflicts() {
assert!(super::routes().is_ok());
}
}
+98 -11
View File
@@ -1,23 +1,110 @@
use crate::state::AppState; use super::format::{self, page, posts};
use gemi::{GeminiResponse, GeminiRouter}; use crate::{datasources::posts::PostsDatasource, state::AppState};
use gemi::{GeminiResponse, GeminiRouter, Params, State};
pub struct PostsGeminiRoutes; pub struct PostsGeminiRoutes;
impl PostsGeminiRoutes { impl PostsGeminiRoutes {
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> { pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default(); let mut router = GeminiRouter::default();
router.add_route("/", Self::root)?; router.add_route("/", Self::index)?;
router.add_route("/{id}", Self::get_one)?;
router.add_route("/all", Self::all)?;
router.add_route("/recent", Self::recent)?;
router.add_route("/featured", Self::featured)?;
router.add_route("/popular", Self::popular)?;
router.add_route("/hot", Self::hot)?;
Ok(router) Ok(router)
} }
async fn root() -> impl Into<GeminiResponse> { async fn index(State(state): State<AppState>) -> GeminiResponse {
"Hello, Gemini!" let pool = state.lock().await.database.clone();
let result = tokio::try_join!(
PostsDatasource::get_featured(&pool),
PostsDatasource::get_recent(&pool),
PostsDatasource::get_popular(&pool)
);
match result {
Ok((featured, recent, popular)) => page("Blog", &format!("## Featured Posts\nIgnite the impossible\n\n{}## Recent Posts\nNow with 100% fresh perspective\n\n{}## Popular Posts\nContent may cause uncontrollable reading\n\n{}=> /posts/all All posts\n=> /posts/hot Hot posts", posts(&featured), posts(&recent), posts(&popular))),
Err(e) => format::error(e),
}
} }
async fn post_one() -> impl Into<GeminiResponse> { async fn get_one(State(state): State<AppState>, params: Params) -> GeminiResponse {
// make call to database let id = match format::id(&params) {
// format post to Gemtext Ok(id) => id,
// return response Err(e) => return e,
"" };
let pool = state.lock().await.database.clone();
match PostsDatasource::get_one(&pool, id).await {
Ok(post) => {
let name = format::line(&format!(
"{} {}",
post.first_name.as_deref().unwrap_or(""),
post.last_name.as_deref().unwrap_or("")
));
let mut body = String::new();
if let Some(author_id) = post.author_id {
body += &format!("=> /authors/{author_id} By {name}\n");
}
if let Some(date) = post.publish_date.or(post.created_at) {
body += &format!("Published {}\n", date.format("%B %d, %Y"));
}
if post.is_featured == Some(true) {
body += "Featured post\n";
}
body += "\n";
match post
.body_gemtext
.as_deref()
.filter(|s| !s.trim().is_empty())
{
Some(gemtext) => body += gemtext,
None => {
body += &format!(
"This post is available on the web.\n=> {} Read this post",
format::web_url(&format!("/posts/{id}"))
)
}
}
body += &format!("\n\n=> /comments/post/{id} Comments\n=> /posts Back to the blog");
page(&post.title, &body)
}
Err(e) => format::error(e),
}
}
async fn all(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match PostsDatasource::get_all(&pool).await {
Ok(items) => page("All posts", &posts(&items)),
Err(e) => format::error(e),
}
}
async fn recent(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match PostsDatasource::get_recent(&pool).await {
Ok(items) => page("Recent Posts", &posts(&items)),
Err(e) => format::error(e),
}
}
async fn featured(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match PostsDatasource::get_featured(&pool).await {
Ok(items) => page("Featured Posts", &posts(&items)),
Err(e) => format::error(e),
}
}
async fn popular(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match PostsDatasource::get_popular(&pool).await {
Ok(items) => page("Popular Posts", &posts(&items)),
Err(e) => format::error(e),
}
}
async fn hot(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match PostsDatasource::get_hot(&pool).await {
Ok(items) => page("Hot Posts", &posts(&items)),
Err(e) => format::error(e),
}
} }
} }
@@ -0,0 +1,46 @@
use super::format::{self, line, page};
use crate::{datasources::projects::ProjectsDatasource, state::AppState};
use gemi::{GeminiResponse, GeminiRouter, State};
pub struct ProjectsGeminiRoutes;
impl ProjectsGeminiRoutes {
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default();
router.add_route("/", Self::all)?;
Ok(router)
}
async fn all(State(state): State<AppState>) -> GeminiResponse {
let pool = state.lock().await.database.clone();
match ProjectsDatasource::get_all(&pool).await {
Ok(projects) => {
let mut body = String::from("Here's a collection of software and electronics projects I've been tinkering with during my free time - some are ongoing adventures, others are finished experiments!\n\n");
if projects.is_empty() {
body += "No projects yet.\n";
}
for project in projects {
body += &format!(
"## {}\n{}\nTechnology: {}\nStatus: {}\n",
line(&project.title),
line(&project.summary),
line(&project.tech),
if project.wip.unwrap_or(true) {
"Work in progress"
} else {
"Complete"
}
);
if let Some(repo) = project
.repo
.filter(|r| !r.is_empty() && !r.chars().any(char::is_whitespace))
{
body += &format!("=> {repo} Repository\n");
}
body += "\n";
}
page("Projects", &body)
}
Err(e) => format::error(e),
}
}
}
+13 -3
View File
@@ -1,3 +1,4 @@
use super::format::{page, web_url};
use crate::state::AppState; use crate::state::AppState;
use gemi::{GeminiResponse, GeminiRouter}; use gemi::{GeminiResponse, GeminiRouter};
@@ -6,11 +7,20 @@ impl RootGeminiRoutes {
pub fn routes() -> gemi::Result<GeminiRouter<AppState>> { pub fn routes() -> gemi::Result<GeminiRouter<AppState>> {
let mut router = GeminiRouter::default(); let mut router = GeminiRouter::default();
router.add_route("/", Self::root)?; router.add_route("/", Self::root)?;
router.add_route("/contact", Self::contact)?;
router.add_route("/health", Self::health)?;
Ok(router) Ok(router)
} }
async fn root() -> impl Into<GeminiResponse> { async fn root() -> GeminiResponse {
"Hello, Gemini!" page("Heya! I'm Wyatt", "## Thanks for checking out this corner of the Internet!\n\nI design and develop software for developers, for end users, and everyone in between")
}
async fn contact() -> GeminiResponse {
page("Contact", &format!("Got a question? Here to yell at me? Send me something!\n\n=> mailto:wjmiller2016@gmail.com Email me\n=> {} Contact form on the web", web_url("/contact")))
}
async fn health() -> GeminiResponse {
GeminiResponse::text("OK")
} }
} }