Yearly forecast: solar return, transits, progressions, profection, eclipses
CI / test (push) Successful in 56s
CI / build (push) Successful in 4m41s
CI / deploy (push) Skipped

- astro-engine: forecast module (solar return moment, slow-planet transits
  with exact dates and periods, natal house ingresses, secondary
  progressions, annual profection, eclipses via Swiss Ephemeris)
- horoscope-api: POST /v1/forecast, solar return chart cast for the place
  of the birthday
- backend: forecasts table, /v1/charts/{id}/forecasts, /v1/forecasts/{id}
  and its analyses using a new 'forecast' unit; current year of life open,
  the next one 30 days before the birthday
- packages: Páros and Család include forecasts (6 000 / 11 000 Ft),
  +1 éves előrejelzés add-on 2 500 Ft; Egy elemzés unchanged
- worker and prompt: forecast kind with five sections and forecast rules
  (trends, no event predictions); no birth data, place or exact age sent
- frontend: /kepletek/{id}/elorejelzes with the solar return wheel, the
  keys of the year, a monthly timeline, transit list and detailed forecast
- data export: forecasts added, model name removed

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-18 08:19:13 +00:00
co-authored by Claude Opus 5.5
parent 829c33e52f
commit f1bd34c394
42 changed files with 4764 additions and 85 deletions
+12 -5
View File
@@ -1,6 +1,7 @@
//! Analysis units: a detailed natal analysis uses one `natal` unit, a
//! synastry analysis one `synastry` unit. Units come from purchases or an
//! admin; a failed analysis gives its unit back (the worker does that).
//! synastry analysis one `synastry` unit, a yearly forecast one `forecast`
//! unit. Units come from purchases or an admin; a failed analysis gives its
//! unit back (the worker does that).
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
@@ -14,6 +15,8 @@ use crate::error::ApiError;
pub enum Unit {
Natal,
Synastry,
/// A yearly forecast (see `routes::forecasts`).
Forecast,
/// A slot for adding a person (see [`crate::persons`]).
Person,
}
@@ -23,6 +26,7 @@ impl Unit {
match self {
Unit::Natal => "natal",
Unit::Synastry => "synastry",
Unit::Forecast => "forecast",
Unit::Person => "person",
}
}
@@ -33,6 +37,7 @@ impl Unit {
pub struct Balance {
pub natal: i64,
pub synastry: i64,
pub forecast: i64,
/// Bought person slots (not the slots left; see [`crate::persons::slots`]).
pub person: i64,
}
@@ -42,26 +47,28 @@ impl Balance {
match unit {
Unit::Natal => self.natal,
Unit::Synastry => self.synastry,
Unit::Forecast => self.forecast,
Unit::Person => self.person,
}
}
pub fn view(self) -> Value {
json!({ "natal": self.natal, "synastry": self.synastry })
json!({ "natal": self.natal, "synastry": self.synastry, "forecast": self.forecast })
}
}
pub async fn balance(conn: &mut PgConnection, user_id: Uuid) -> Result<Balance, ApiError> {
let (natal, synastry, person): (i64, i64, i64) = sqlx::query_as(
let (natal, synastry, forecast, person): (i64, i64, i64, i64) = sqlx::query_as(
"SELECT COALESCE(SUM(delta) FILTER (WHERE unit = 'natal'), 0)::bigint, \
COALESCE(SUM(delta) FILTER (WHERE unit = 'synastry'), 0)::bigint, \
COALESCE(SUM(delta) FILTER (WHERE unit = 'forecast'), 0)::bigint, \
COALESCE(SUM(delta) FILTER (WHERE unit = 'person' AND reason <> 'person'), 0)::bigint \
FROM credit_ledger WHERE user_id = $1",
)
.bind(user_id)
.fetch_one(conn)
.await?;
Ok(Balance { natal, synastry, person })
Ok(Balance { natal, synastry, forecast, person })
}
/// Spends one unit inside the caller's transaction. The user row is locked
+42 -11
View File
@@ -16,6 +16,8 @@ use crate::error::ApiError;
/// List prices of the single items, for showing what a package saves.
const NATAL_PRICE: i64 = 2_000;
const SYNASTRY_PRICE: i64 = 2_500;
/// A yearly forecast bought alone costs more than one in a package.
const FORECAST_PRICE: i64 = 2_500;
const PERSON_PRICE: i64 = 300; // 1 500 Ft for five
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -36,12 +38,13 @@ pub struct Package {
pub price_huf: i64,
pub natal: i64,
pub synastry: i64,
pub forecast: i64,
pub persons: i64,
/// Badge on the card ("Legnépszerűbb").
pub badge: Option<&'static str>,
}
pub const CATALOG: [Package; 5] = [
pub const CATALOG: [Package; 6] = [
Package {
id: "single",
name: "Egy elemzés",
@@ -50,28 +53,31 @@ pub const CATALOG: [Package; 5] = [
price_huf: 2_000,
natal: 1,
synastry: 0,
forecast: 0,
persons: 0,
badge: None,
},
Package {
id: "couple",
name: "Páros",
tagline: "Te és ő: mindkettőtök képlete és a kapcsolati elemzés.",
tagline: "Te és ő: mindkettőtök képlete, éves előrejelzése és a kapcsolati elemzés.",
tier: Tier::Main,
price_huf: 4_500,
price_huf: 6_000,
natal: 2,
synastry: 1,
forecast: 2,
persons: 1,
badge: None,
},
Package {
id: "family",
name: "Család",
tagline: "Az egész család: öt személy, mindenki képlete, és öt kapcsolat.",
tagline: "Az egész család: öt személy, mindenki képlete és éves előrejelzése, és öt kapcsolat.",
tier: Tier::Main,
price_huf: 8_000,
price_huf: 11_000,
natal: 6,
synastry: 5,
forecast: 6,
persons: 5,
badge: Some("Legnépszerűbb"),
},
@@ -83,6 +89,19 @@ pub const CATALOG: [Package; 5] = [
price_huf: 2_500,
natal: 0,
synastry: 1,
forecast: 0,
persons: 0,
badge: None,
},
Package {
id: "addon_forecast",
name: "+1 éves előrejelzés",
tagline: "Egy év születésnaptól születésnapig: szolár, tranzitok, progresszió.",
tier: Tier::Addon,
price_huf: FORECAST_PRICE,
natal: 0,
synastry: 0,
forecast: 1,
persons: 0,
badge: None,
},
@@ -94,6 +113,7 @@ pub const CATALOG: [Package; 5] = [
price_huf: 1_500,
natal: 0,
synastry: 0,
forecast: 0,
persons: 5,
badge: None,
},
@@ -106,11 +126,14 @@ pub fn find(id: &str) -> Option<&'static Package> {
impl Package {
/// What the contents would cost one by one.
fn list_price(&self) -> i64 {
self.natal * NATAL_PRICE + self.synastry * SYNASTRY_PRICE + self.persons * PERSON_PRICE
self.natal * NATAL_PRICE
+ self.synastry * SYNASTRY_PRICE
+ self.forecast * FORECAST_PRICE
+ self.persons * PERSON_PRICE
}
pub fn view(&self) -> Value {
let analyses = self.natal + self.synastry;
let analyses = self.natal + self.synastry + self.forecast;
let list = self.list_price();
let savings = (list > self.price_huf).then(|| ((list - self.price_huf) * 100 + list / 2) / list);
json!({
@@ -121,6 +144,7 @@ impl Package {
"price_huf": self.price_huf,
"natal": self.natal,
"synastry": self.synastry,
"forecast": self.forecast,
"persons": self.persons,
"badge": self.badge,
"list_price_huf": list,
@@ -173,8 +197,13 @@ pub async fn grant(
.bind(created_by)
.execute(&mut *tx)
.await?;
for (unit, n) in [(Unit::Natal, package.natal), (Unit::Synastry, package.synastry), (Unit::Person, package.persons)]
{
let contents = [
(Unit::Natal, package.natal),
(Unit::Synastry, package.synastry),
(Unit::Forecast, package.forecast),
(Unit::Person, package.persons),
];
for (unit, n) in contents {
if n == 0 {
continue;
}
@@ -218,8 +247,10 @@ mod tests {
fn bigger_packages_are_cheaper_per_analysis() {
let per = |id: &str| find(id).unwrap().view()["per_analysis_huf"].as_i64().unwrap();
assert!(per("single") > per("couple") && per("couple") > per("family"));
assert_eq!(find("family").unwrap().view()["savings_percent"], 69);
assert_eq!(find("couple").unwrap().view()["savings_percent"], 34);
assert_eq!(find("family").unwrap().view()["savings_percent"], 73);
assert_eq!(find("couple").unwrap().view()["savings_percent"], 49);
// Alone a forecast costs more than a natal analysis.
assert!(find("addon_forecast").unwrap().price_huf > find("single").unwrap().price_huf);
assert!(find("single").unwrap().view()["savings_percent"].is_null());
assert!(find("unlimited").is_none());
assert!(CATALOG.iter().all(|p| find(p.id).is_some()));
+2 -1
View File
@@ -156,7 +156,8 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1").await?,
"synastries": rows("SELECT json_build_object('id', s.id, 'owner_id', s.owner_id, 'chart1_id', s.chart1_id, 'chart2_id', s.chart2_id, 'result', s.result, 'created_at', 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").await?,
"invites": rows("SELECT json_build_object('id', id, 'chart_id', inviter_chart_id, 'message', message, 'created_at', created_at, 'expires_at', expires_at, 'accepted_at', accepted_at) FROM synastry_invites WHERE inviter_id = $1").await?,
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'language', a.language, 'model', a.model, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
"forecasts": rows("SELECT json_build_object('id', f.id, 'chart_id', f.chart_id, 'year', f.year, 'location', f.location, 'result', f.result, 'created_at', f.created_at) FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE c.owner_id = $1").await?,
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
"credit_ledger": rows("SELECT json_build_object('unit', unit, 'delta', delta, 'reason', reason, 'note', note, 'created_at', created_at) FROM credit_ledger WHERE user_id = $1 ORDER BY created_at").await?,
"shares": rows("SELECT json_build_object('slug', slug, 'kind', kind, 'title', title, 'show_birth_data', show_birth_data, 'view_count', view_count, 'created_at', created_at, 'revoked_at', revoked_at) FROM shares WHERE owner_id = $1").await?,
});
+6 -4
View File
@@ -33,12 +33,14 @@ pub async fn list_users(
let limit = query.limit.unwrap_or(50).clamp(1, 200);
let offset = query.offset.unwrap_or(0).max(0);
let pattern = query.q.as_deref().map(|q| format!("%{}%", q.trim().replace(['%', '_'], "")));
type Row = (Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64);
type Row =
(Uuid, String, Option<String>, Vec<String>, bool, OffsetDateTime, Option<OffsetDateTime>, i64, i64, i64, i64);
let rows: Vec<Row> = sqlx::query_as(
"SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry') \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast') \
FROM users u \
WHERE $1::text IS NULL OR u.email ILIKE $1 OR u.display_name ILIKE $1 \
ORDER BY u.created_at DESC LIMIT $2 OFFSET $3",
@@ -50,11 +52,11 @@ pub async fn list_users(
.await?;
let users: Vec<Value> = rows
.into_iter()
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry)| {
.map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, forecast)| {
json!({
"id": id, "email": email, "display_name": name, "roles": roles, "email_verified": verified,
"created_at": rfc3339(created), "last_login_at": rfc3339_opt(last_login),
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry},
"charts": charts, "analyses_left": {"natal": natal, "synastry": synastry, "forecast": forecast},
})
})
.collect();
+47 -11
View File
@@ -1,7 +1,7 @@
//! Text analyses (LLM) of charts and synastries.
//!
//! A request creates a `pending` analysis and spends one unit of its kind
//! (`natal` or `synastry`, see [`credits`]; admins pay nothing); the worker
//! (`natal`, `synastry` or `forecast`, see [`credits`]; admins pay nothing); the worker
//! writes the text later. A finished analysis with the same cache key (same
//! chart or synastry hash, prompt version, model and language) is copied
//! instead, free of charge, so the same chart is never paid for twice.
@@ -22,6 +22,7 @@ use uuid::Uuid;
use super::auth::validate_locale;
use super::charts::{ChartRow, find_chart, owned_chart};
use super::forecasts::{find_forecast, owned_forecast};
use super::synastries::{load_synastry, visible_synastry};
use super::{IdPath, St};
use crate::AppState;
@@ -38,6 +39,7 @@ pub struct AnalysisRow {
pub kind: String,
pub chart_id: Option<Uuid>,
pub synastry_id: Option<Uuid>,
pub forecast_id: Option<Uuid>,
pub language: String,
pub prompt_version: String,
pub status: String,
@@ -48,7 +50,8 @@ pub struct AnalysisRow {
pub completed_at: Option<OffsetDateTime>,
}
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, language, prompt_version, status, content, error, \
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
content, error, \
credits_charged, created_at, completed_at";
impl AnalysisRow {
@@ -58,6 +61,7 @@ impl AnalysisRow {
"kind": self.kind,
"chart_id": self.chart_id,
"synastry_id": self.synastry_id,
"forecast_id": self.forecast_id,
"language": self.language,
"prompt_version": self.prompt_version,
"status": self.status,
@@ -77,8 +81,8 @@ pub async fn find_analysis(db: &PgPool, id: Uuid) -> Result<Option<AnalysisRow>,
.await?)
}
/// Whether `user` may read the analysis: the chart's owner, or a member of
/// the synastry.
/// Whether `user` may read the analysis: the owner of the chart (or of the
/// forecast's chart), or a member of the synastry.
pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<bool, ApiError> {
if let Some(chart_id) = analysis.chart_id {
return Ok(find_chart(db, chart_id).await?.is_some_and(|c| c.owner_id == user));
@@ -86,6 +90,11 @@ pub async fn can_see(db: &PgPool, analysis: &AnalysisRow, user: Uuid) -> Result<
if let Some(synastry_id) = analysis.synastry_id {
return Ok(load_synastry(db, synastry_id).await?.is_some_and(|s| s.is_member(user)));
}
if let Some(forecast_id) = analysis.forecast_id
&& let Some(forecast) = find_forecast(db, forecast_id).await?
{
return Ok(find_chart(db, forecast.chart_id).await?.is_some_and(|c| c.owner_id == user));
}
Ok(false)
}
@@ -108,6 +117,7 @@ enum Target {
Natal { chart_id: Uuid, hash: String },
Summary { chart_id: Uuid, hash: String },
Synastry { synastry_id: Uuid, hash: String },
Forecast { forecast_id: Uuid, hash: String },
}
async fn request(
@@ -122,6 +132,7 @@ async fn request(
let unit = match target {
_ if admin => None,
Target::Synastry { .. } => Some(Unit::Synastry),
Target::Forecast { .. } => Some(Unit::Forecast),
_ => Some(Unit::Natal),
};
let model = state.config.analysis_model.clone();
@@ -140,10 +151,11 @@ async fn queue(
model: &str,
unit: Option<Unit>,
) -> Result<(StatusCode, AnalysisRow), ApiError> {
let (kind, hash, chart_id, synastry_id) = match target {
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None),
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None),
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)),
let (kind, hash, chart_id, synastry_id, forecast_id) = match target {
Target::Natal { chart_id, hash } => ("natal", hash, Some(*chart_id), None, None),
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None, None),
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id), None),
Target::Forecast { forecast_id, hash } => ("forecast", hash, None, None, Some(*forecast_id)),
};
// The cache key leaves out the admin-edited prompt revision, so a chart keeps
// its analysis when the prompt changes; copying from another chart needs the same revision.
@@ -157,12 +169,13 @@ async fn queue(
// Already requested for this chart/synastry: return it.
let existing: Option<AnalysisRow> = sqlx::query_as(&format!(
"SELECT {ANALYSIS_COLUMNS} FROM analyses \
WHERE (chart_id = $1 OR synastry_id = $2) AND cache_key = $3 AND status <> 'failed' \
WHERE (chart_id = $1 OR synastry_id = $2 OR forecast_id = $4) AND cache_key = $3 AND status <> 'failed' \
ORDER BY created_at DESC LIMIT 1"
))
.bind(chart_id)
.bind(synastry_id)
.bind(&cache_key)
.bind(forecast_id)
.fetch_optional(&state.db)
.await?;
if let Some(row) = existing {
@@ -171,8 +184,9 @@ async fn queue(
let insert = format!(
"INSERT INTO analyses (id, kind, chart_id, synastry_id, requested_by, language, model, prompt_version, \
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) RETURNING {ANALYSIS_COLUMNS}"
cache_key, status, content, input_tokens, output_tokens, credits_charged, completed_at, \
forecast_id) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16) RETURNING {ANALYSIS_COLUMNS}"
);
let id = Uuid::now_v7();
@@ -202,6 +216,7 @@ async fn queue(
.bind(output_tokens)
.bind(0)
.bind(OffsetDateTime::now_utc())
.bind(forecast_id)
.fetch_one(&state.db)
.await?;
return Ok((StatusCode::CREATED, row));
@@ -225,6 +240,7 @@ async fn queue(
.bind(None::<i32>)
.bind(i32::from(unit.is_some()))
.bind(None::<OffsetDateTime>)
.bind(forecast_id)
.fetch_one(&mut *tx)
.await?;
if let Some(unit) = unit {
@@ -309,3 +325,23 @@ pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _
}
Ok(Json(analysis.view()))
}
pub async fn list_for_forecast(
State(state): St,
auth: AuthUser,
WithRejection(Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
owned_forecast(&state.db, id, auth.id()).await?;
list_where(&state.db, "forecast_id", id).await
}
pub async fn request_for_forecast(
State(state): St,
auth: AuthUser,
WithRejection(Path(id), _): IdPath,
body: Bytes,
) -> ApiResult<(StatusCode, Json<Value>)> {
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
let req = optional_body(&body)?;
request(&state, &auth, Target::Forecast { forecast_id: forecast.id, hash: forecast.forecast_hash }, req).await
}
+303
View File
@@ -0,0 +1,303 @@
//! Yearly forecasts of a chart: one year of life from a solar return
//! (birthday) to the next, calculated by the horoscope service for where the
//! person is on the birthday. The calculation (solar return chart, transit
//! timeline, progressions, profection, eclipses) is free; its detailed text
//! analysis uses a `forecast` unit (see [`super::analyses`]).
//!
//! Users can calculate the year of life they are in, and the next one from
//! [`NEXT_YEAR_DAYS`] days before the birthday; admins any year.
use axum::Json;
use axum::extract::State;
use axum::http::StatusCode;
use axum_extra::extract::WithRejection;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use sqlx::PgPool;
use time::{Date, Month, OffsetDateTime};
use uuid::Uuid;
use super::charts::{ChartRow, find_chart, owned_chart};
use super::{Body, IdPath, St};
use crate::auth::AuthUser;
use crate::error::{ApiError, ApiResult};
use crate::views::{rfc3339, sha256_hex};
use db::Role;
/// The next year of life can be calculated this many days before the birthday.
pub const NEXT_YEAR_DAYS: i64 = 30;
/// At most this many forecasts (years and places) per chart.
const MAX_PER_CHART: i64 = 20;
#[derive(Debug, Clone, sqlx::FromRow)]
pub struct ForecastRow {
pub id: Uuid,
pub chart_id: Uuid,
pub year: i32,
pub location: Option<Value>,
pub result: Value,
pub forecast_hash: String,
pub created_at: OffsetDateTime,
}
const FORECAST_COLUMNS: &str = "id, chart_id, year, location, result, forecast_hash, created_at";
impl ForecastRow {
/// Where the year is reckoned, for lists: the place name or the coordinates.
fn place(&self) -> Value {
let sr = &self.result["solar_return"]["location"];
let loc = &self.result["location"];
sr.pointer("/place/name").or(loc.get("place")).cloned().unwrap_or(Value::Null)
}
pub fn summary_view(&self) -> Value {
let f = &self.result["forecast"];
json!({
"id": self.id,
"chart_id": self.chart_id,
"year": self.year,
"start": f["start"],
"end": f["end"],
"place": self.place(),
"birth_place": self.location.is_none(),
"created_at": rfc3339(self.created_at),
})
}
pub fn view(&self) -> Value {
let mut v = self.summary_view();
v["location"] = self.location.clone().unwrap_or(Value::Null);
v["result"] = self.result.clone();
v
}
}
pub async fn find_forecast(db: &PgPool, id: Uuid) -> Result<Option<ForecastRow>, ApiError> {
Ok(sqlx::query_as(&format!("SELECT {FORECAST_COLUMNS} FROM forecasts WHERE id = $1"))
.bind(id)
.fetch_optional(db)
.await?)
}
/// A forecast of a chart of `owner`; 404 otherwise.
pub async fn owned_forecast(db: &PgPool, id: Uuid, owner: Uuid) -> Result<(ForecastRow, ChartRow), ApiError> {
let forecast = find_forecast(db, id).await?.ok_or(ApiError::NotFound("forecast"))?;
let chart = find_chart(db, forecast.chart_id).await?.filter(|c| c.owner_id == owner);
chart.map(|c| (forecast, c)).ok_or(ApiError::NotFound("forecast"))
}
/// The Gregorian birth date of a calculated chart.
fn birth_date(chart: &ChartRow) -> Option<Date> {
let text = chart.result.pointer("/time/date")?.as_str()?;
let mut parts = text.split('-').map(str::parse::<i32>);
let (y, m, d) = (parts.next()?.ok()?, parts.next()?.ok()?, parts.next()?.ok()?);
Date::from_calendar_date(y, Month::try_from(m as u8).ok()?, d as u8).ok()
}
/// The birthday in a year (29 February is the 28th in common years).
fn birthday(birth: Date, year: i32) -> Option<Date> {
Date::from_calendar_date(year, birth.month(), birth.day())
.or_else(|_| Date::from_calendar_date(year, birth.month(), birth.day() - 1))
.ok()
}
/// The years (of the solar return starting them) a user can calculate on
/// `today`: the current year of life, and the next one close to the birthday.
pub fn open_years(birth: Date, today: Date) -> Vec<i32> {
let Some(this) = birthday(birth, today.year()) else { return Vec::new() };
let current = if today >= this { today.year() } else { today.year() - 1 };
let mut years = Vec::new();
if current > birth.year() {
years.push(current);
}
if birthday(birth, current + 1).is_some_and(|next| (next - today).whole_days() <= NEXT_YEAR_DAYS) {
years.push(current + 1);
}
years
}
/// Where the person is on the birthday, as the horoscope service takes it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Location {
country: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
place: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
region: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
geonames_id: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
latitude: Option<f64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
longitude: Option<f64>,
}
#[derive(Debug, Deserialize, Default)]
#[serde(deny_unknown_fields)]
pub struct CreateForecast {
/// Defaults to the current year of life.
year: Option<i32>,
/// Defaults to the birth place.
location: Option<Location>,
}
fn is_admin(auth: &AuthUser) -> bool {
auth.user.has_role(Role::Admin)
}
/// The years open to this user for a chart (admins: also every earlier one is allowed on request).
fn years_for(chart: &ChartRow) -> Vec<i32> {
birth_date(chart).map(|b| open_years(b, OffsetDateTime::now_utc().date())).unwrap_or_default()
}
fn current_forecasts_query() -> String {
format!(
"SELECT {FORECAST_COLUMNS} FROM forecasts WHERE chart_id = $1 AND chart_hash = $2 ORDER BY year DESC, created_at"
)
}
/// The forecasts of a chart (for its current birth data) and the years that can be calculated.
pub async fn list_for_chart(
State(state): St,
auth: AuthUser,
WithRejection(axum::extract::Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
let chart = owned_chart(&state.db, id, auth.id()).await?;
let rows: Vec<ForecastRow> =
sqlx::query_as(&current_forecasts_query()).bind(chart.id).bind(&chart.chart_hash).fetch_all(&state.db).await?;
Ok(Json(json!({
"years": years_for(&chart),
"birth_place": chart.result.pointer("/location/place/name"),
"time_known": chart.result.pointer("/time/time_known"),
"forecasts": rows.iter().map(ForecastRow::summary_view).collect::<Vec<_>>(),
})))
}
/// Calculates a year (or returns it when already calculated). 201 or 200.
pub async fn create(
State(state): St,
auth: AuthUser,
WithRejection(axum::extract::Path(id), _): IdPath,
WithRejection(Json(req), _): Body<CreateForecast>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let chart = owned_chart(&state.db, id, auth.id()).await?;
let open = years_for(&chart);
let year = match req.year {
Some(y) if open.contains(&y) || is_admin(&auth) => y,
Some(_) => {
return Err(ApiError::Refused {
code: "forecast_year_closed",
message: "Az aktuális évre, és a születésnap előtti 30 napban a következőre kérhetsz előrejelzést."
.into(),
});
}
None => *open.first().ok_or(ApiError::Refused {
code: "forecast_year_closed",
message: "Az első születésnap előtt még nincs éves előrejelzés.".into(),
})?,
};
let location = req.location.map(|l| serde_json::to_value(l).expect("serializable"));
let location_key = location.as_ref().map_or_else(|| "birth".to_string(), |l| sha256_hex(&l.to_string()));
let existing: Option<ForecastRow> = sqlx::query_as(&format!(
"SELECT {FORECAST_COLUMNS} FROM forecasts \
WHERE chart_id = $1 AND chart_hash = $2 AND year = $3 AND location_key = $4"
))
.bind(chart.id)
.bind(&chart.chart_hash)
.bind(year)
.bind(&location_key)
.fetch_optional(&state.db)
.await?;
if let Some(row) = existing {
return Ok((StatusCode::OK, Json(row.view())));
}
let (count,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts WHERE chart_id = $1")
.bind(chart.id)
.fetch_one(&state.db)
.await?;
if count >= MAX_PER_CHART && !is_admin(&auth) {
return Err(ApiError::conflict(
"forecast_limit_reached",
format!("at most {MAX_PER_CHART} forecasts can be saved for a chart"),
));
}
let mut request = json!({ "birth": chart.birth_data, "year": year });
if let Some(l) = &location {
request["location"] = l.clone();
}
let mut result = state.horoscope.forecast(&request).await?;
if let Some(obj) = result.as_object_mut() {
obj.remove("meta");
}
let forecast_hash = forecast_hash(&chart.chart_hash, year, &location_key, &result);
let row: ForecastRow = sqlx::query_as(&format!(
"INSERT INTO forecasts (id, chart_id, chart_hash, year, location, location_key, result, forecast_hash, created_by) \
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) \
ON CONFLICT (chart_id, chart_hash, year, location_key) DO UPDATE SET chart_id = EXCLUDED.chart_id \
RETURNING {FORECAST_COLUMNS}"
))
.bind(Uuid::now_v7())
.bind(chart.id)
.bind(&chart.chart_hash)
.bind(year)
.bind(&location)
.bind(&location_key)
.bind(&result)
.bind(&forecast_hash)
.bind(auth.id())
.fetch_one(&state.db)
.await?;
Ok((StatusCode::CREATED, Json(row.view())))
}
/// Identifies a forecast independently of how the place was entered: the
/// chart, the year and the resolved place and time zone of the solar return.
fn forecast_hash(chart_hash: &str, year: i32, location_key: &str, result: &Value) -> String {
let sr = &result["solar_return"];
let place = if sr.is_object() {
format!(
"{:.4}|{:.4}|{}",
sr["location"]["latitude"].as_f64().unwrap_or_default(),
sr["location"]["longitude"].as_f64().unwrap_or_default(),
sr["timezone"].as_str().unwrap_or_default()
)
} else {
location_key.to_string()
};
sha256_hex(&format!("forecast|{chart_hash}|{year}|{place}"))
}
pub async fn get_one(
State(state): St,
auth: AuthUser,
WithRejection(axum::extract::Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
let (forecast, _) = owned_forecast(&state.db, id, auth.id()).await?;
Ok(Json(forecast.view()))
}
#[cfg(test)]
mod tests {
use super::*;
fn date(y: i32, m: u8, d: u8) -> Date {
Date::from_calendar_date(y, Month::try_from(m).unwrap(), d).unwrap()
}
#[test]
fn years_open_around_the_birthday() {
let birth = date(1990, 3, 15);
assert_eq!(open_years(birth, date(2026, 11, 18)), vec![2026]);
assert_eq!(open_years(birth, date(2027, 3, 1)), vec![2026, 2027]);
assert_eq!(open_years(birth, date(2027, 3, 15)), vec![2027]);
assert_eq!(open_years(birth, date(2027, 2, 12)), vec![2026]);
// Before the first birthday: only the first year, close to it.
assert!(open_years(birth, date(1990, 6, 1)).is_empty());
assert_eq!(open_years(birth, date(1991, 3, 1)), vec![1991]);
// 29 February
assert_eq!(open_years(date(1992, 2, 29), date(2027, 2, 28)), vec![2027]);
}
}
+4
View File
@@ -10,6 +10,7 @@ mod admin;
mod analyses;
mod auth;
mod charts;
mod forecasts;
mod invitations;
mod payments;
mod prompts;
@@ -73,6 +74,9 @@ pub fn router(state: Arc<AppState>) -> Router {
.route("/v1/charts/{id}", get(charts::get_one).patch(charts::update).delete(charts::remove))
.route("/v1/charts/{id}/analyses", get(analyses::list_for_chart).post(analyses::request_for_chart))
.route("/v1/charts/{id}/summary", post(analyses::summary_for_chart))
.route("/v1/charts/{id}/forecasts", get(forecasts::list_for_chart).post(forecasts::create))
.route("/v1/forecasts/{id}", get(forecasts::get_one))
.route("/v1/forecasts/{id}/analyses", get(analyses::list_for_forecast).post(analyses::request_for_forecast))
// synastries and invitations
.route("/v1/synastries", get(synastries::list).post(synastries::create))
.route("/v1/synastries/{id}", get(synastries::get_one).delete(synastries::remove))
+1
View File
@@ -53,6 +53,7 @@ pub async fn mock(
(Some(id), None) => id,
(None, Some(Unit::Natal)) => "single",
(None, Some(Unit::Synastry)) => "addon_synastry",
(None, Some(Unit::Forecast)) => "addon_forecast",
(None, Some(Unit::Person)) => "addon_persons",
_ => return Err(ApiError::BadRequest("give either package or unit".into())),
};
+118 -14
View File
@@ -39,7 +39,7 @@ async fn fake_natal(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
Json(json!({
"input": body,
"location": {"country": {"name": "Hungary"}, "place": {"name": body["place"]}, "latitude": 47.0, "longitude": 19.0},
"time": {"local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
"time": {"date": date, "local": format!("{date}T{}:00", time.unwrap_or("12:00")), "utc": format!("{date}T11:00:00Z"), "time_known": time.is_some()},
"astronomy": {"julian_day_ut": 2451545.0},
"settings": body.get("options").cloned().unwrap_or(json!({"house_system": "placidus"})),
"points": [{"id": "sun", "sign": "cancer", "longitude": 90.4}, {"id": "moon", "sign": "pisces", "longitude": 338.2}],
@@ -72,6 +72,24 @@ async fn fake_synastry(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
)
}
async fn fake_forecast(Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
let year = body["year"].as_i64().unwrap_or(2026);
let loc = body.get("location").cloned().unwrap_or(json!({"country": "HU", "place": body["birth"]["place"]}));
(
StatusCode::OK,
Json(json!({
"year": year,
"solar_return": {
"location": {"place": {"name": loc["place"]}, "latitude": 47.0, "longitude": 19.0},
"timezone": "Europe/Budapest", "points": [], "input": {"date": format!("{year}-03-15")}
},
"location": loc,
"forecast": {"start": format!("{year}-03-15"), "end": format!("{}-03-15", year + 1), "transits": []},
"meta": {}
})),
)
}
async fn fake_jwks() -> Json<Value> {
Json(
json!({"keys": [{"kid": "test-key", "kty": "RSA", "alg": "RS256", "use": "sig", "n": GOOGLE_KEY_N.trim(), "e": "AQAB"}]}),
@@ -82,6 +100,7 @@ async fn fake_services() -> String {
let app = Router::new()
.route("/v1/natal", post(fake_natal))
.route("/v1/synastry", post(fake_synastry))
.route("/v1/forecast", post(fake_forecast))
.route("/jwks", get(fake_jwks));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
@@ -222,7 +241,7 @@ async fn register_login_verify_logout(pool: PgPool) {
let r = app.get("/v1/me", Some(&token)).await;
assert_eq!(r.status, StatusCode::OK);
assert_eq!(r.body["providers"], json!(["password"]));
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0}));
assert_eq!(r.body["analyses_left"], json!({"natal": 0, "synastry": 0, "forecast": 0}));
// e-mail verification through the queued e-mail's link
let url = app.outbox_url("anna@example.com", "verify_email").await;
@@ -343,11 +362,14 @@ async fn roles_and_admin_guard(pool: PgPool) {
let grant = |unit: &str, delta: i32| json!({"unit": unit, "delta": delta, "note": "bonus"});
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("natal", 5)).await;
assert_eq!((r.status, &r.body["analyses_left"]), (StatusCode::CREATED, &json!({"natal": 5, "synastry": 0})));
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::CREATED, &json!({"natal": 5, "synastry": 0, "forecast": 0}))
);
let r = app.post(&format!("/v1/admin/users/{anna}/credits"), Some(&admin), grant("chat", 5)).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST);
let credits = app.get("/v1/credits", Some(&user)).await.body;
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0}));
assert_eq!(credits["balance"], json!({"natal": 5, "synastry": 0, "forecast": 0}));
assert_eq!((credits["ledger"][0]["unit"].as_str(), &credits["ledger"][0]["delta"]), (Some("natal"), &json!(5)));
}
@@ -516,14 +538,20 @@ async fn analyses_spend_units_and_reuse_results(pool: PgPool) {
.await
.unwrap();
assert_eq!(model, "anthropic/claude-test");
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0}));
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
);
// same request again: the same analysis, no charge
let r = app.call("POST", &uri, Some(&anna), None).await;
assert_eq!((r.status, r.body["id"].as_str()), (StatusCode::OK, Some(first.as_str())));
let r = app.post(&uri, Some(&anna), json!({"language": "en"})).await;
assert_eq!(r.status, StatusCode::ACCEPTED);
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 0, "synastry": 0}));
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 0, "synastry": 0, "forecast": 0})
);
let r = app.post(&uri, Some(&anna), json!({"model": "anthropic/claude-other"})).await;
assert_eq!(r.status, StatusCode::BAD_REQUEST); // no model choice
@@ -711,7 +739,10 @@ async fn synastry_analyses_use_synastry_units(pool: PgPool) {
grant_units(&app, &anna, "synastry", 1).await;
let r = app.call("POST", &uri, Some(&anna), None).await;
assert_eq!((r.status, r.body["kind"].as_str()), (StatusCode::ACCEPTED, Some("synastry")));
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 1, "synastry": 0}));
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
);
}
#[sqlx::test(migrator = "db::MIGRATOR")]
@@ -797,14 +828,17 @@ async fn admins_get_free_analyses_and_mock_payments_add_units(pool: PgPool) {
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "natal"})).await;
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::OK, &json!({"natal": 1, "synastry": 0})),
(StatusCode::OK, &json!({"natal": 1, "synastry": 0, "forecast": 0})),
"{}",
r.body
);
let r =
app.call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&anna), None).await;
assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(1)), "{}", r.body);
assert_eq!(app.get("/v1/credits", Some(&anna)).await.body["balance"], json!({"natal": 0, "synastry": 0}));
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 0, "synastry": 0, "forecast": 0})
);
// without MOCK_PAYMENTS there is no such payment
let app = TestApp::with_config(app.pool.clone(), |c| c.mock_payments = false).await;
@@ -1064,10 +1098,10 @@ async fn packages_grant_units(pool: PgPool) {
// the catalog is public
let r = app.get("/v1/packages", None).await;
let ids: Vec<&str> = r.body["packages"].as_array().unwrap().iter().map(|p| p["id"].as_str().unwrap()).collect();
assert_eq!(ids, ["single", "couple", "family", "addon_synastry", "addon_persons"]);
assert_eq!(ids, ["single", "couple", "family", "addon_synastry", "addon_forecast", "addon_persons"]);
assert_eq!(
(&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]),
(&json!("Legnépszerűbb"), &json!(727))
(&json!("Legnépszerűbb"), &json!(647))
);
// an admin gives a package as a gift
@@ -1076,7 +1110,7 @@ async fn packages_grant_units(pool: PgPool) {
let r = grant_package(&app, &admin, &anna_id, "family").await;
assert_eq!(
(r.status, &r.body["analyses_left"]),
(StatusCode::CREATED, &json!({"natal": 6, "synastry": 5})),
(StatusCode::CREATED, &json!({"natal": 6, "synastry": 5, "forecast": 6})),
"{}",
r.body
);
@@ -1091,10 +1125,10 @@ async fn packages_grant_units(pool: PgPool) {
// a (mock) purchase adds to it and records the price
let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await;
assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6}), "{}", r.body);
assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6, "forecast": 8}), "{}", r.body);
let (price,): (i32,) =
sqlx::query_as("SELECT price_huf FROM package_orders WHERE package = 'couple'").fetch_one(&pool).await.unwrap();
assert_eq!(price, 4500);
assert_eq!(price, 6000);
// the header shows the latest main package; a top-up does not change it
app.post("/v1/payments/mock", Some(&anna), json!({"package": "addon_persons"})).await;
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["package"]["name"], "Páros");
@@ -1288,3 +1322,73 @@ async fn invitation_only_signup(pool: PgPool) {
assert!(r.body["html"].as_str().unwrap().contains("Szia!") && r.body["text"].as_str().unwrap().contains("> Szia!"));
assert_eq!(app.outbox_url("admin@example.com", "invitation").await, "https://sorsfonalak.test/meghivo/minta");
}
#[sqlx::test(migrator = "db::MIGRATOR")]
async fn forecasts_are_free_their_analysis_uses_a_forecast_unit(pool: PgPool) {
let app = TestApp::new(pool.clone()).await;
let anna = app.register("anna@example.com", "Anna").await;
let bob = app.register("bob@example.com", "Bob").await;
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
let chart_id = chart["id"].as_str().unwrap();
let uri = format!("/v1/charts/{chart_id}/forecasts");
// the year of life the user is in can be calculated (free, stored once)
let list = app.get(&uri, Some(&anna)).await.body;
let year = list["years"][0].as_i64().expect("an open year");
assert_eq!(list["forecasts"], json!([]));
let r = app.post(&uri, Some(&anna), json!({})).await;
assert_eq!((r.status, &r.body["year"]), (StatusCode::CREATED, &json!(year)), "{}", r.body);
assert_eq!(r.body["start"], format!("{year}-03-15"));
assert!(r.body["result"].get("meta").is_none());
let id = r.body["id"].as_str().unwrap().to_string();
let again = app.post(&uri, Some(&anna), json!({"year": year})).await;
assert_eq!((again.status, again.body["id"].as_str()), (StatusCode::OK, Some(id.as_str())));
// another place on the birthday is another forecast
let away = app
.post(&uri, Some(&anna), json!({"location": {"country": "JP", "geonames_id": 1850147, "place": "Tokió"}}))
.await;
assert_eq!((away.status, &away.body["place"]), (StatusCode::CREATED, &json!("Tokió")));
assert_eq!(app.get(&uri, Some(&anna)).await.body["forecasts"].as_array().unwrap().len(), 2);
// far years are closed to users; others cannot see it
let r = app.post(&uri, Some(&anna), json!({"year": 2000})).await;
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::FORBIDDEN, Some("forecast_year_closed")));
assert_eq!(app.post(&uri, Some(&anna), json!({"year": year, "oops": 1})).await.status, StatusCode::BAD_REQUEST);
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.get(&uri, Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.get(&format!("/v1/forecasts/{id}"), Some(&anna)).await.body["year"], json!(year));
// the detailed text uses a forecast unit, not a natal one
let analyses = format!("/v1/forecasts/{id}/analyses");
grant_units(&app, &anna, "natal", 1).await;
let r = app.call("POST", &analyses, Some(&anna), None).await;
assert_eq!(
(r.status, r.body["error"]["code"].as_str()),
(StatusCode::PAYMENT_REQUIRED, Some("insufficient_credits"))
);
let r = app.post("/v1/payments/mock", Some(&anna), json!({"unit": "forecast"})).await;
assert_eq!(r.body["analyses_left"], json!({"natal": 1, "synastry": 0, "forecast": 1}), "{}", r.body);
let r = app.call("POST", &analyses, Some(&anna), None).await;
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
assert_eq!((r.body["kind"].as_str(), r.body["forecast_id"].as_str()), (Some("forecast"), Some(id.as_str())));
let analysis = r.body["id"].as_str().unwrap().to_string();
assert_eq!(
app.get("/v1/credits", Some(&anna)).await.body["balance"],
json!({"natal": 1, "synastry": 0, "forecast": 0})
);
assert_eq!(app.call("POST", &analyses, Some(&anna), None).await.status, StatusCode::OK); // the same one, no charge
assert_eq!(app.get(&analyses, Some(&anna)).await.body["analyses"].as_array().unwrap().len(), 1);
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&anna)).await.status, StatusCode::OK);
assert_eq!(app.get(&format!("/v1/analyses/{analysis}"), Some(&bob)).await.status, StatusCode::NOT_FOUND);
assert_eq!(app.call("POST", &analyses, Some(&bob), None).await.status, StatusCode::NOT_FOUND);
// the natal analyses of the chart do not list it
let natal = app.get(&format!("/v1/charts/{chart_id}/analyses"), Some(&anna)).await.body;
assert!(natal["analyses"].as_array().unwrap().iter().all(|a| a["kind"] != "forecast"));
// deleting the chart deletes its forecasts
assert_eq!(
app.call("DELETE", &format!("/v1/charts/{chart_id}"), Some(&anna), None).await.status,
StatusCode::NO_CONTENT
);
let (n,): (i64,) = sqlx::query_as("SELECT count(*) FROM forecasts").fetch_one(&pool).await.unwrap();
assert_eq!(n, 0);
}