Add horoscope-api, synastry, and backend services

- horoscope-api: Swiss Ephemeris natal charts, timezone/place resolution,
  POST /v1/natal and POST /v1/synastry
- backend: users with roles, email/password and Google login, saved charts,
  synastries and invites, analyses with credit ledger, public shares, admin
- shared crates: astro-engine, db (migrations), horoscope-client, service-kit
- docker-compose with postgres, legacy Java project for reference

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
feco
2026-11-15 10:25:35 +00:00
co-authored by Claude Opus 5.5
parent 0b5416df45
commit 3a84110565
148 changed files with 95803 additions and 0 deletions
+431
View File
@@ -0,0 +1,431 @@
//! Synastries (two charts compared) and "how compatible are we?" invitations.
//!
//! A synastry is visible to its owner and to the owners of both charts: when
//! an invitation is accepted, the inviter owns the synastry and the invitee
//! sees it through their own chart. Birth data of a chart is shown only to
//! its owner; the other side gets the positions only.
use axum::Json;
use axum::extract::{Path, State};
use axum::http::StatusCode;
use axum_extra::extract::WithRejection;
use db::USER_COLUMNS;
use serde::Deserialize;
use serde_json::{Map, Value, json};
use sqlx::PgPool;
use time::OffsetDateTime;
use uuid::Uuid;
use super::charts::{ChartRow, find_chart, owned_chart, primary_chart};
use super::{Body, IdPath, St};
use crate::AppState;
use crate::auth::AuthUser;
use crate::error::{ApiError, ApiResult};
use crate::views::{public_chart, rfc3339, rfc3339_opt, synastry_hash};
const INVITE_TTL: time::Duration = time::Duration::days(14);
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct SynastryRow {
pub id: Uuid,
pub owner_id: Uuid,
pub chart1_id: Uuid,
pub chart2_id: Uuid,
pub result: Value,
pub synastry_hash: String,
pub created_at: OffsetDateTime,
}
const SYNASTRY_COLUMNS: &str = "id, owner_id, chart1_id, chart2_id, result, synastry_hash, created_at";
/// A synastry with its two charts.
pub struct VisibleSynastry {
pub synastry: SynastryRow,
pub chart1: ChartRow,
pub chart2: ChartRow,
}
impl VisibleSynastry {
pub fn is_member(&self, user: Uuid) -> bool {
self.synastry.owner_id == user || self.chart1.owner_id == user || self.chart2.owner_id == user
}
}
pub async fn load_synastry(db: &PgPool, id: Uuid) -> Result<Option<VisibleSynastry>, ApiError> {
let row: Option<SynastryRow> = sqlx::query_as(&format!("SELECT {SYNASTRY_COLUMNS} FROM synastries WHERE id = $1"))
.bind(id)
.fetch_optional(db)
.await?;
let Some(synastry) = row else { return Ok(None) };
let chart1 = find_chart(db, synastry.chart1_id).await?.ok_or(ApiError::NotFound("chart"))?;
let chart2 = find_chart(db, synastry.chart2_id).await?.ok_or(ApiError::NotFound("chart"))?;
Ok(Some(VisibleSynastry { synastry, chart1, chart2 }))
}
/// 404 unless `user` may see the synastry.
pub async fn visible_synastry(db: &PgPool, id: Uuid, user: Uuid) -> Result<VisibleSynastry, ApiError> {
load_synastry(db, id).await?.filter(|s| s.is_member(user)).ok_or(ApiError::NotFound("synastry"))
}
async fn display_name(db: &PgPool, user: Uuid) -> Result<Option<String>, ApiError> {
let row: Option<(Option<String>,)> =
sqlx::query_as("SELECT display_name FROM users WHERE id = $1").bind(user).fetch_optional(db).await?;
Ok(row.and_then(|(n,)| n))
}
/// A chart as seen by `viewer`: the owner gets everything, others the
/// positions without birth data, labelled with the owner's display name.
async fn chart_for_viewer(db: &PgPool, chart: &ChartRow, viewer: Uuid) -> Result<Value, ApiError> {
if chart.owner_id == viewer {
let mut v = chart.owner_view();
v["owned"] = Value::Bool(true);
return Ok(v);
}
let label = match display_name(db, chart.owner_id).await? {
Some(name) if chart.is_primary => name,
_ => chart.label.clone(),
};
Ok(json!({ "id": chart.id, "label": label, "owned": false, "chart": public_chart(&chart.result, false) }))
}
async fn synastry_view(db: &PgPool, s: &VisibleSynastry, viewer: Uuid) -> Result<Value, ApiError> {
Ok(json!({
"id": s.synastry.id,
"owned": s.synastry.owner_id == viewer,
"chart1": chart_for_viewer(db, &s.chart1, viewer).await?,
"chart2": chart_for_viewer(db, &s.chart2, viewer).await?,
"synastry": s.synastry.result,
"synastry_hash": s.synastry.synastry_hash,
"created_at": rfc3339(s.synastry.created_at),
}))
}
fn without(value: &Value, keys: &[&str]) -> Value {
let mut map: Map<String, Value> = value.as_object().cloned().unwrap_or_default();
for k in keys {
map.remove(*k);
}
Value::Object(map)
}
/// Returns the synastry of the two charts, calculating and storing it when
/// it does not exist yet (in either order). `bool` = newly created.
pub async fn compute_synastry(
state: &AppState,
owner: Uuid,
chart1: &ChartRow,
chart2: &ChartRow,
) -> Result<(SynastryRow, bool), ApiError> {
let existing = |a: Uuid, b: Uuid| async move {
sqlx::query_as::<_, SynastryRow>(&format!(
"SELECT {SYNASTRY_COLUMNS} FROM synastries \
WHERE (chart1_id = $1 AND chart2_id = $2) OR (chart1_id = $2 AND chart2_id = $1)"
))
.bind(a)
.bind(b)
.fetch_optional(&state.db)
.await
};
if let Some(row) = existing(chart1.id, chart2.id).await? {
return Ok((row, false));
}
let request = json!({
"person1": without(&chart1.birth_data, &["options"]),
"person2": without(&chart2.birth_data, &["options"]),
"options": chart1.birth_data.get("options").cloned().unwrap_or_else(|| json!({})),
});
let response = state.horoscope.synastry(&request).await?;
let result = without(&response, &["person1", "person2", "meta"]);
let hash = synastry_hash(&chart1.chart_hash, &chart2.chart_hash, &result["settings"]);
let inserted: Option<SynastryRow> = sqlx::query_as(&format!(
"INSERT INTO synastries (id, owner_id, chart1_id, chart2_id, result, synastry_hash) \
VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (chart1_id, chart2_id) DO NOTHING RETURNING {SYNASTRY_COLUMNS}"
))
.bind(Uuid::now_v7())
.bind(owner)
.bind(chart1.id)
.bind(chart2.id)
.bind(result)
.bind(hash)
.fetch_optional(&state.db)
.await?;
match inserted {
Some(row) => Ok((row, true)),
// Created concurrently.
None => Ok((existing(chart1.id, chart2.id).await?.ok_or(ApiError::NotFound("synastry"))?, false)),
}
}
pub async fn list(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
type Row = (Uuid, bool, Uuid, String, Uuid, Uuid, String, Uuid, Value, OffsetDateTime);
let rows: Vec<Row> = sqlx::query_as(
"SELECT s.id, s.owner_id = $1, c1.id, c1.label, c1.owner_id, c2.id, c2.label, c2.owner_id, \
s.result -> 'summary', s.created_at \
FROM synastries s JOIN charts c1 ON c1.id = s.chart1_id JOIN charts c2 ON c2.id = s.chart2_id \
WHERE s.owner_id = $1 OR c1.owner_id = $1 OR c2.owner_id = $1 ORDER BY s.created_at DESC",
)
.bind(auth.id())
.fetch_all(&state.db)
.await?;
let me = auth.id();
let list: Vec<Value> = rows
.into_iter()
.map(|(id, owned, c1, l1, o1, c2, l2, o2, summary, at)| {
json!({
"id": id, "owned": owned,
"chart1": { "id": c1, "label": l1, "owned": o1 == me },
"chart2": { "id": c2, "label": l2, "owned": o2 == me },
"summary": summary, "created_at": rfc3339(at),
})
})
.collect();
Ok(Json(json!({ "synastries": list })))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CreateSynastry {
chart1_id: Uuid,
chart2_id: Uuid,
}
/// Compares two of the user's own charts.
pub async fn create(
State(state): St,
auth: AuthUser,
WithRejection(Json(req), _): Body<CreateSynastry>,
) -> ApiResult<(StatusCode, Json<Value>)> {
if req.chart1_id == req.chart2_id {
return Err(ApiError::BadRequest("a chart cannot be compared with itself".into()));
}
let chart1 = owned_chart(&state.db, req.chart1_id, auth.id()).await?;
let chart2 = owned_chart(&state.db, req.chart2_id, auth.id()).await?;
let (row, created) = compute_synastry(&state, auth.id(), &chart1, &chart2).await?;
let s = visible_synastry(&state.db, row.id, auth.id()).await?;
let status = if created { StatusCode::CREATED } else { StatusCode::OK };
Ok((status, Json(synastry_view(&state.db, &s, auth.id()).await?)))
}
pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<Json<Value>> {
let s = visible_synastry(&state.db, id, auth.id()).await?;
Ok(Json(synastry_view(&state.db, &s, auth.id()).await?))
}
/// Either side may remove the synastry (and with it the link between them).
pub async fn remove(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<StatusCode> {
visible_synastry(&state.db, id, auth.id()).await?;
sqlx::query("DELETE FROM synastries WHERE id = $1").bind(id).execute(&state.db).await?;
Ok(StatusCode::NO_CONTENT)
}
// --- invitations -----------------------------------------------------------------------------
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CreateInvite {
/// Defaults to the user's primary chart.
chart_id: Option<Uuid>,
message: Option<String>,
}
async fn chart_or_primary(db: &PgPool, chart_id: Option<Uuid>, user: Uuid) -> Result<ChartRow, ApiError> {
match chart_id {
Some(id) => owned_chart(db, id, user).await,
None => primary_chart(db, user).await?.ok_or_else(|| {
ApiError::conflict("primary_chart_required", "create your own chart first (is_primary: true)")
}),
}
}
pub async fn create_invite(
State(state): St,
auth: AuthUser,
WithRejection(Json(req), _): Body<CreateInvite>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let chart = chart_or_primary(&state.db, req.chart_id, auth.id()).await?;
let message = req.message.map(|m| m.trim().chars().take(500).collect::<String>()).filter(|m| !m.is_empty());
let token = db::new_token();
let id = Uuid::now_v7();
let expires_at = OffsetDateTime::now_utc() + INVITE_TTL;
sqlx::query(
"INSERT INTO synastry_invites (id, inviter_id, inviter_chart_id, token_hash, message, expires_at) \
VALUES ($1, $2, $3, $4, $5, $6)",
)
.bind(id)
.bind(auth.id())
.bind(chart.id)
.bind(db::token_hash(&token))
.bind(&message)
.bind(expires_at)
.execute(&state.db)
.await?;
Ok((
StatusCode::CREATED,
Json(json!({
"id": id,
"token": token,
"url": format!("{}/invite/{token}", state.config.public_base_url),
"chart_id": chart.id,
"message": message,
"expires_at": rfc3339(expires_at),
})),
))
}
fn invite_status(accepted_at: Option<OffsetDateTime>, expires_at: OffsetDateTime) -> &'static str {
if accepted_at.is_some() {
"accepted"
} else if expires_at <= OffsetDateTime::now_utc() {
"expired"
} else {
"pending"
}
}
pub async fn list_invites(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
type Row = (
Uuid,
Uuid,
Option<String>,
OffsetDateTime,
OffsetDateTime,
Option<OffsetDateTime>,
Option<Uuid>,
Option<String>,
);
let rows: Vec<Row> = sqlx::query_as(
"SELECT i.id, i.inviter_chart_id, i.message, i.created_at, i.expires_at, i.accepted_at, i.synastry_id, \
u.display_name \
FROM synastry_invites i LEFT JOIN users u ON u.id = i.accepted_by \
WHERE i.inviter_id = $1 ORDER BY i.created_at DESC",
)
.bind(auth.id())
.fetch_all(&state.db)
.await?;
let list: Vec<Value> = rows
.into_iter()
.map(|(id, chart_id, message, created, expires, accepted, synastry_id, accepted_by)| {
json!({
"id": id, "chart_id": chart_id, "message": message,
"status": invite_status(accepted, expires),
"created_at": rfc3339(created), "expires_at": rfc3339(expires),
"accepted_at": rfc3339_opt(accepted), "accepted_by": accepted_by, "synastry_id": synastry_id,
})
})
.collect();
Ok(Json(json!({ "invites": list })))
}
pub async fn revoke_invite(
State(state): St,
auth: AuthUser,
WithRejection(Path(id), _): IdPath,
) -> ApiResult<StatusCode> {
let result = sqlx::query(
"UPDATE synastry_invites SET expires_at = now() \
WHERE id = $1 AND inviter_id = $2 AND accepted_at IS NULL AND expires_at > now()",
)
.bind(id)
.bind(auth.id())
.execute(&state.db)
.await?;
if result.rows_affected() == 0 {
return Err(ApiError::NotFound("pending invitation"));
}
Ok(StatusCode::NO_CONTENT)
}
#[derive(sqlx::FromRow)]
struct InviteRow {
id: Uuid,
inviter_id: Uuid,
inviter_chart_id: Uuid,
message: Option<String>,
expires_at: OffsetDateTime,
accepted_at: Option<OffsetDateTime>,
inviter_name: Option<String>,
}
async fn invite_by_token(db: &PgPool, token: &str) -> Result<InviteRow, ApiError> {
sqlx::query_as(
"SELECT i.id, i.inviter_id, i.inviter_chart_id, i.message, i.expires_at, i.accepted_at, \
u.display_name AS inviter_name \
FROM synastry_invites i JOIN users u ON u.id = i.inviter_id WHERE i.token_hash = $1",
)
.bind(db::token_hash(token.trim()))
.fetch_optional(db)
.await?
.ok_or(ApiError::NotFound("invitation"))
}
/// Public landing data of an invitation link (no login, no birth data).
pub async fn public_invite(State(state): St, Path(token): Path<String>) -> ApiResult<Json<Value>> {
let invite = invite_by_token(&state.db, &token).await?;
Ok(Json(json!({
"inviter_name": invite.inviter_name,
"message": invite.message,
"status": invite_status(invite.accepted_at, invite.expires_at),
"expires_at": rfc3339(invite.expires_at),
})))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AcceptInvite {
token: String,
/// Defaults to the invitee's primary chart.
chart_id: Option<Uuid>,
}
/// The invitee accepts: their chart is compared with the inviter's, and the
/// synastry becomes visible to both.
pub async fn accept_invite(
State(state): St,
auth: AuthUser,
WithRejection(Json(req), _): Body<AcceptInvite>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let invite = invite_by_token(&state.db, &req.token).await?;
match invite_status(invite.accepted_at, invite.expires_at) {
"accepted" => return Err(ApiError::Gone("this invitation has already been accepted".into())),
"expired" => return Err(ApiError::Gone("this invitation has expired".into())),
_ => {}
}
if invite.inviter_id == auth.id() {
return Err(ApiError::conflict("own_invitation", "you cannot accept your own invitation"));
}
let my_chart = chart_or_primary(&state.db, req.chart_id, auth.id()).await?;
let inviter_chart =
find_chart(&state.db, invite.inviter_chart_id).await?.ok_or(ApiError::NotFound("invitation"))?;
let (row, _) = compute_synastry(&state, invite.inviter_id, &inviter_chart, &my_chart).await?;
let mut tx = state.db.begin().await?;
sqlx::query(
"UPDATE synastry_invites SET accepted_at = now(), accepted_by = $1, synastry_id = $2 \
WHERE id = $3 AND accepted_at IS NULL",
)
.bind(auth.id())
.bind(row.id)
.bind(invite.id)
.execute(&mut *tx)
.await?;
let inviter: Option<db::User> = sqlx::query_as(&format!("SELECT {USER_COLUMNS} FROM users WHERE id = $1"))
.bind(invite.inviter_id)
.fetch_optional(&mut *tx)
.await?;
if let Some(inviter) = inviter {
let url = format!("{}/synastry/{}", state.config.public_base_url, row.id);
super::auth::queue_email(
&mut tx,
&inviter,
"invite_accepted",
json!({ "url": url, "invitee_name": auth.user.display_name }),
)
.await?;
}
tx.commit().await?;
let s = visible_synastry(&state.db, row.id, auth.id()).await?;
Ok((StatusCode::CREATED, Json(synastry_view(&state.db, &s, auth.id()).await?)))
}