logaritmisk
7782bd764a
Also fix pre-existing clippy::explicit_auto_deref in all db test files (&mut *tx → &mut tx across authority.rs and vocab.rs).
120 lines
3.6 KiB
Rust
120 lines
3.6 KiB
Rust
//! Authority records (person / organisation / place).
|
|
|
|
use domain::{Authority, AuthorityId, AuthorityKind, AuthorityRef, LocalizedLabel, NewAuthority};
|
|
use sqlx::Row;
|
|
|
|
/// Labels aggregated per row as JSON, to read an authority and its labels in one query.
|
|
const LABELS_JSON: &str = "COALESCE(json_agg(json_build_object('lang', al.lang, 'label', al.label) \
|
|
ORDER BY al.lang) FILTER (WHERE al.authority_id IS NOT NULL), '[]'::json)";
|
|
|
|
/// Insert an authority and its labels. Multiple statements — pass a transaction
|
|
/// connection (`&mut *tx`) for atomicity.
|
|
pub async fn create_authority(
|
|
conn: &mut sqlx::PgConnection,
|
|
new: &NewAuthority,
|
|
) -> Result<AuthorityId, sqlx::Error> {
|
|
let id = AuthorityId::new();
|
|
|
|
sqlx::query("INSERT INTO authority (id, kind, external_uri) VALUES ($1, $2, $3)")
|
|
.bind(id.to_uuid())
|
|
.bind(new.kind.as_str())
|
|
.bind(new.external_uri.as_deref())
|
|
.execute(&mut *conn)
|
|
.await?;
|
|
|
|
for label in &new.labels {
|
|
sqlx::query("INSERT INTO authority_label (authority_id, lang, label) VALUES ($1, $2, $3)")
|
|
.bind(id.to_uuid())
|
|
.bind(&label.lang)
|
|
.bind(&label.label)
|
|
.execute(&mut *conn)
|
|
.await?;
|
|
}
|
|
|
|
Ok(id)
|
|
}
|
|
|
|
/// Fetch one authority (with its labels).
|
|
pub async fn authority_by_id<'e, E>(
|
|
executor: E,
|
|
id: AuthorityId,
|
|
) -> Result<Option<Authority>, sqlx::Error>
|
|
where
|
|
E: sqlx::PgExecutor<'e>,
|
|
{
|
|
let sql = format!(
|
|
"SELECT a.id, a.kind, a.external_uri, {LABELS_JSON} AS labels \
|
|
FROM authority a LEFT JOIN authority_label al ON al.authority_id = a.id \
|
|
WHERE a.id = $1 GROUP BY a.id"
|
|
);
|
|
|
|
let row = sqlx::query(&sql)
|
|
.bind(id.to_uuid())
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
row.map(map_authority).transpose()
|
|
}
|
|
|
|
/// List authorities of a given kind (with labels), ordered by id.
|
|
pub async fn list_by_kind<'e, E>(
|
|
executor: E,
|
|
kind: AuthorityKind,
|
|
) -> Result<Vec<Authority>, sqlx::Error>
|
|
where
|
|
E: sqlx::PgExecutor<'e>,
|
|
{
|
|
let sql = format!(
|
|
"SELECT a.id, a.kind, a.external_uri, {LABELS_JSON} AS labels \
|
|
FROM authority a LEFT JOIN authority_label al ON al.authority_id = a.id \
|
|
WHERE a.kind = $1 GROUP BY a.id ORDER BY a.id"
|
|
);
|
|
|
|
let rows = sqlx::query(&sql)
|
|
.bind(kind.as_str())
|
|
.fetch_all(executor)
|
|
.await?;
|
|
|
|
rows.into_iter().map(map_authority).collect()
|
|
}
|
|
|
|
/// Resolve an authority to an [`AuthorityRef`] (carrying its kind).
|
|
pub async fn resolve_authority<'e, E>(
|
|
executor: E,
|
|
id: AuthorityId,
|
|
) -> Result<Option<AuthorityRef>, sqlx::Error>
|
|
where
|
|
E: sqlx::PgExecutor<'e>,
|
|
{
|
|
let kind: Option<String> = sqlx::query_scalar("SELECT kind FROM authority WHERE id = $1")
|
|
.bind(id.to_uuid())
|
|
.fetch_optional(executor)
|
|
.await?;
|
|
|
|
match kind {
|
|
Some(k) => {
|
|
let kind = AuthorityKind::from_db(&k).ok_or_else(|| {
|
|
sqlx::Error::Decode(format!("unknown authority kind: {k}").into())
|
|
})?;
|
|
|
|
Ok(Some(AuthorityRef::new(id, kind)))
|
|
}
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
fn map_authority(row: sqlx::postgres::PgRow) -> Result<Authority, sqlx::Error> {
|
|
let kind_str: String = row.try_get("kind")?;
|
|
let kind = AuthorityKind::from_db(&kind_str)
|
|
.ok_or_else(|| sqlx::Error::Decode(format!("unknown authority kind: {kind_str}").into()))?;
|
|
|
|
let labels: sqlx::types::Json<Vec<LocalizedLabel>> = row.try_get("labels")?;
|
|
|
|
Ok(Authority {
|
|
id: AuthorityId::from_uuid(row.try_get("id")?),
|
|
kind,
|
|
external_uri: row.try_get("external_uri")?,
|
|
labels: labels.0,
|
|
})
|
|
}
|