use axum::response::{IntoResponse, Response};
use axum::Json;
use chrono::{DateTime, Utc};
use rustango::core::Column as _;
use rustango::extractors::{SessionUser, Tenant};
use rustango::sql::{CounterPool as _, FetcherPool as _};
use crate::media::Media;
use crate::navigation::{Menu, MenuItem};
use crate::page::{Page, PageStatus};
use crate::snippet::Snippet;
pub async fn changes(
tenant: Tenant,
SessionUser(session_user): SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
crate::api::auth::BearerMember(bearer): crate::api::auth::BearerMember,
) -> Response {
let viewer = member.as_ref().or(bearer.as_ref()).or(session_user.as_ref());
match changes_inner(tenant.pool(), viewer).await {
Ok(resp) => resp,
Err(e) => {
tracing::error!(target: "rustango_cms::api", error = %e, "changes failed");
crate::api::error::ApiError::internal().into_response()
}
}
}
fn entry(count: usize, latest: Option<DateTime<Utc>>) -> serde_json::Value {
serde_json::json!({
"count": count,
"latest": latest.map(|t| t.to_rfc3339()),
})
}
fn newest(times: impl Iterator<Item = Option<DateTime<Utc>>>) -> Option<DateTime<Utc>> {
times.flatten().max()
}
fn to_usize(n: i64) -> usize {
usize::try_from(n).unwrap_or(0)
}
async fn media_fingerprint(
pool: &rustango::sql::Pool,
denied: &[i64],
images: bool,
) -> Result<(usize, Option<DateTime<Utc>>), rustango::sql::ExecError> {
let listed = || {
let qs = Media::objects();
let qs = if images {
qs.where_(Media::kind.eq("image".to_owned()))
} else {
qs.where_(Media::kind.ne("image".to_owned()))
};
if denied.is_empty() {
qs
} else {
qs.where_(
Media::collection_id
.is_null()
.or(Media::collection_id.not_in(denied.iter().copied())),
)
}
};
let count = listed().count(pool).await?;
let latest = listed()
.order_by(&[("uploaded_at", true)])
.first(pool)
.await?
.and_then(|m| m.uploaded_at.get().copied());
Ok((to_usize(count), latest))
}
async fn page_fingerprint(
pool: &rustango::sql::Pool,
viewer: Option<&rustango::tenancy::auth::User>,
) -> Result<(usize, Option<DateTime<Utc>>), rustango::sql::ExecError> {
let listed = || {
Page::objects()
.where_(Page::status.is_in([
PageStatus::Published.as_str().to_owned(),
PageStatus::Archived.as_str().to_owned(),
]))
.where_(Page::locale_variant_of.is_null())
};
let access = crate::view_restriction::access_context(pool, viewer).await;
if access.is_unrestricted() {
let count = listed().count(pool).await?;
let latest = listed()
.order_by(&[("updated_at", true)])
.first(pool)
.await?
.and_then(|p| p.updated_at.get().copied());
return Ok((to_usize(count), latest));
}
let pages: Vec<Page> = listed().fetch(pool).await?;
let visible: Vec<&Page> = pages.iter().filter(|p| access.can_view(&p.path, p.page_type_id)).collect();
Ok((visible.len(), newest(visible.iter().map(|p| p.updated_at.get().copied()))))
}
pub async fn changes_inner(
pool: &rustango::sql::Pool,
viewer: Option<&rustango::tenancy::auth::User>,
) -> Result<Response, rustango::sql::ExecError> {
let pages = page_fingerprint(pool, viewer).await?;
let collection_ids: Vec<i64> = crate::media::MediaCollection::objects()
.fetch(pool)
.await?
.iter()
.filter_map(|c| c.id.get().copied())
.collect();
let denied: Vec<i64> =
crate::collection_view_restriction::denied_collection_ids(pool, viewer, &collection_ids)
.await
.into_iter()
.collect();
let (images, documents) = (
media_fingerprint(pool, &denied, true).await?,
media_fingerprint(pool, &denied, false).await?,
);
let snippets = (
Snippet::objects().count(pool).await?,
Snippet::objects()
.order_by(&[("updated_at", true)])
.first(pool)
.await?
.and_then(|s| s.updated_at.get().copied()),
);
let menus = Menu::objects().count(pool).await? + MenuItem::objects().count(pool).await?;
Ok(Json(serde_json::json!({
"meta": {
"checked_at": Utc::now().to_rfc3339(),
"usage": "Re-fetch a collection when its `count` or `latest` \
differs from the values you hold, passing the \
`latest` you held as `?updated_since=`.",
},
"collections": {
"pages": entry(pages.0, pages.1),
"images": entry(images.0, images.1),
"documents": entry(documents.0, documents.1),
"snippets": entry(to_usize(snippets.0), snippets.1),
"menus": entry(to_usize(menus), None),
},
}))
.into_response())
}
#[cfg(test)]
mod tests {
use super::*;
fn t(s: &str) -> Option<DateTime<Utc>> {
Some(DateTime::parse_from_rfc3339(s).unwrap().with_timezone(&Utc))
}
#[test]
fn newest_picks_the_latest_and_ignores_missing() {
let got = newest(
[t("2026-01-01T00:00:00Z"), None, t("2026-06-01T00:00:00Z")].into_iter(),
);
assert_eq!(got, t("2026-06-01T00:00:00Z"));
}
#[test]
fn newest_of_nothing_is_none() {
assert_eq!(newest(std::iter::empty()), None);
assert_eq!(newest([None, None].into_iter()), None);
}
#[test]
fn an_entry_carries_both_halves_of_the_signal() {
let e = entry(3, t("2026-01-01T00:00:00Z"));
assert_eq!(e["count"], 3);
assert!(e["latest"].is_string());
let empty = entry(0, None);
assert_eq!(empty["count"], 0);
assert!(empty["latest"].is_null());
}
}