GKaszewski/k-mood
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

spa hardening, offline logging, rate limit fixes

Browse Source 
server:
- backup exporter, auth extractors, error shapes, CONTEXT (prior work)
- spa assets served outside the rate limit via route_layer
- requests_per_second went to per_second(), which takes an interval not a
  rate: 50 meant one request per 50s once burst was spent. now converted
  properly. 15/s, burst 60

spa fixes:
- account delete cleared snake_case token keys that were never written
- refresh interceptor could retry forever
- date ranges used local day boundaries stamped +00:00
- "all" period trend plotted one page; calendar days fabricated mood 3
- chart grid invisible: hsl(var(--border)) against rgba tokens
- blob url leak, orphaned media on failed save, devtools in prod bundle
- pt-safe/safe-area-pb classes never existed

spa features:
- offline outbox: entries queue to IndexedDB, replay with backoff, only
  server refusals count against an entry
- drafts persist, quick-log sheet, diary infinite scroll + filters
- route error boundary, stale-chunk recovery, no service worker in dev

a11y + perf:
- mood picker is a radiogroup, activity picker keyboard-operable,
  text alternatives for colour/emoji, locale week start
- dark glass over the bright photo: worst case 1.4:1 -> 4.9-9.6:1
- initial payload 1095->769kB raw, 306->230kB gzip; 38 unused components
  and 5 deps dropped; fonts 218->133kB

53 tests added (43 spa, 10 server)
This commit is contained in:
Gabriel Kaszewski
2026-08-28 14:59:21 +02:00
parent 23d052278a
commit bf148902ab
395 changed files with 13972 additions and 10635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
crates/adapters/sqlite/src/db.rs
View File

@@ -48,6 +48,22 @@ const MIGRATIONS: &[(&str, &str)] = &[
"012_entry_weather",
include_str!("migrations/012_entry_weather.sql"),
),
(
"013_reminder_last_sent",
include_str!("migrations/013_reminder_last_sent.sql"),
),
(
"014_media_ownership",
include_str!("migrations/014_media_ownership.sql"),
),
(
"015_logged_at_in_utc",
include_str!("migrations/015_logged_at_in_utc.sql"),
),
(
"016_api_token_scopes",
include_str!("migrations/016_api_token_scopes.sql"),
),
];
const TAKE_THE_WRITE_LOCK_UP_FRONT: &str = "BEGIN IMMEDIATE";
@@ -57,6 +73,13 @@ const SCHEMA_MIGRATIONS_TABLE: &str = "CREATE TABLE IF NOT EXISTS schema_migrati
applied_at TEXT NOT NULL
)";
pub fn migrations_before(name: &str) -> impl Iterator<Item = (&'static str, &'static str)> {
MIGRATIONS
.iter()
.take_while(move |(applied, _)| *applied != name)
.copied()
}
pub async fn create_pool(database_url: &str) -> Result<SqlitePool, sqlx::Error> {
let options: SqliteConnectOptions = database_url
.parse::<SqliteConnectOptions>()?

2
crates/adapters/sqlite/src/lib.rs
View File

@@ -1,4 +1,4 @@
mod db;
pub mod repositories;
pub use db::{create_pool, run_migrations};
pub use db::{create_pool, migrations_before, run_migrations};

1
crates/adapters/sqlite/src/migrations/013_reminder_last_sent.sql Normal file
View File

@@ -0,0 +1 @@
ALTER TABLE reminders ADD COLUMN last_sent_at TEXT;

19
crates/adapters/sqlite/src/migrations/014_media_ownership.sql Normal file
View File

@@ -0,0 +1,19 @@
CREATE TABLE IF NOT EXISTS media_owners (
kind TEXT NOT NULL,
media_id TEXT NOT NULL,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TEXT NOT NULL,
PRIMARY KEY (kind, media_id)
);
CREATE INDEX IF NOT EXISTS idx_media_owners_user_id ON media_owners(user_id);
INSERT OR IGNORE INTO media_owners (kind, media_id, user_id, created_at)
SELECT 'photo', ep.photo_id, me.user_id, me.created_at
FROM entry_photos ep
JOIN mood_entries me ON me.id = ep.entry_id;
INSERT OR IGNORE INTO media_owners (kind, media_id, user_id, created_at)
SELECT 'voice_memo', evm.voice_memo_id, me.user_id, me.created_at
FROM entry_voice_memos evm
JOIN mood_entries me ON me.id = evm.entry_id;

6
crates/adapters/sqlite/src/migrations/015_logged_at_in_utc.sql Normal file
View File

@@ -0,0 +1,6 @@
UPDATE mood_entries
SET logged_at = strftime('%Y-%m-%dT%H:%M:%S+00:00', logged_at)
WHERE logged_at NOT LIKE '%+00:00';
CREATE INDEX IF NOT EXISTS idx_mood_entries_user_logged_at
ON mood_entries(user_id, logged_at);

5
crates/adapters/sqlite/src/migrations/016_api_token_scopes.sql Normal file
View File

@@ -0,0 +1,5 @@
ALTER TABLE api_tokens ADD COLUMN scopes TEXT NOT NULL DEFAULT 'writeMetrics';
UPDATE api_tokens SET scopes = scope WHERE scope IS NOT NULL AND scope != '';
ALTER TABLE api_tokens DROP COLUMN scope;

4
crates/adapters/sqlite/src/repositories/api_token/command.rs
View File

@@ -35,14 +35,14 @@ impl domain::ports::ApiTokenCommandPort for SqliteApiTokenCommandRepository {
}
sqlx::query(
"INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at, last_used_at)
"INSERT INTO api_tokens (id, user_id, name, digest, scopes, created_at, last_used_at)
VALUES (?, ?, ?, ?, ?, ?, ?)",
)
.bind(token.id().value().to_string())
.bind(token.user_id().value().to_string())
.bind(token.name().value())
.bind(token.digest().value())
.bind(token.scope().name())
.bind(token.scopes().to_persistence())
.bind(token.created_at().to_rfc3339())
.bind(token.last_used_at().map(|used| used.to_rfc3339()))
.execute(&self.pool)

4
crates/adapters/sqlite/src/repositories/api_token/query.rs
View File

@@ -21,7 +21,7 @@ impl SqliteApiTokenQueryRepository {
impl domain::ports::ApiTokenQueryPort for SqliteApiTokenQueryRepository {
async fn find_by_digest(&self, digest: &TokenDigest) -> Result<Option<ApiToken>, DomainError> {
let row: Option<ApiTokenRow> = sqlx::query_as(
"SELECT id, user_id, name, digest, scope, created_at, last_used_at
"SELECT id, user_id, name, digest, scopes, created_at, last_used_at
FROM api_tokens WHERE digest = ?",
)
.bind(digest.value())
@@ -34,7 +34,7 @@ impl domain::ports::ApiTokenQueryPort for SqliteApiTokenQueryRepository {
async fn find_by_user(&self, user_id: &UserId) -> Result<Vec<ApiToken>, DomainError> {
let rows: Vec<ApiTokenRow> = sqlx::query_as(
"SELECT id, user_id, name, digest, scope, created_at, last_used_at
"SELECT id, user_id, name, digest, scopes, created_at, last_used_at
FROM api_tokens WHERE user_id = ? ORDER BY created_at DESC",
)
.bind(user_id.value().to_string())

8
crates/adapters/sqlite/src/repositories/api_token/rows.rs
View File

@@ -1,4 +1,4 @@
use domain::api_token::{ApiToken, ApiTokenData, ApiTokenId, TokenDigest, TokenScope};
use domain::api_token::{ApiToken, ApiTokenData, ApiTokenId, TokenDigest, TokenScopes};
use domain::provider::ProviderName;
use domain::user::UserId;
@@ -8,7 +8,7 @@ pub struct ApiTokenRow {
pub user_id: String,
pub name: String,
pub digest: String,
pub scope: String,
pub scopes: String,
pub created_at: String,
pub last_used_at: Option<String>,
}
@@ -24,7 +24,7 @@ pub fn row_to_token(row: &ApiTokenRow) -> Option<ApiToken> {
user_id: UserId::from_uuid(row.user_id.parse().ok()?),
name: ProviderName::from_persistence(row.name.clone()),
digest: TokenDigest::from_persistence(row.digest.clone()),
scope: TokenScope::from_name(&row.scope)?,
scopes: TokenScopes::from_persistence(&row.scopes)?,
created_at: row.created_at.parse().ok()?,
last_used_at,
}))
@@ -36,7 +36,7 @@ pub fn readable(row: &ApiTokenRow) -> Option<ApiToken> {
if token.is_none() {
tracing::warn!(
token_id = %row.id,
scope = %row.scope,
scopes = %row.scopes,
"skipped a stored api token this build cannot read"
);
}

50
crates/adapters/sqlite/src/repositories/cascade/mod.rs
View File

@@ -5,7 +5,17 @@ use domain::errors::DomainError;
use domain::user::UserId;
use super::entry::rows::{EntryRow, hydrate_batch};
use super::shared::db_err;
use super::shared::{db_err, sortable_instant};
const EVERY_TABLE_THAT_HOLDS_WHAT_A_USER_LOGGED: [&str; 7] = [
"mood_entries",
"activities",
"reminders",
"daily_metrics",
"cycle_starts",
"metric_rejections",
"media_owners",
];
pub struct SqliteCascadeDeleteRepository {
pool: SqlitePool,
@@ -23,29 +33,15 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
let uid = user_id.value().to_string();
let mut tx = self.pool.begin().await.map_err(db_err)?;
sqlx::query("DELETE FROM mood_entries WHERE user_id = ?")
.bind(&uid)
.execute(&mut *tx)
.await
.map_err(db_err)?;
sqlx::query("DELETE FROM activities WHERE user_id = ?")
.bind(&uid)
.execute(&mut *tx)
.await
.map_err(db_err)?;
sqlx::query("DELETE FROM reminders WHERE user_id = ?")
.bind(&uid)
.execute(&mut *tx)
.await
.map_err(db_err)?;
sqlx::query("DELETE FROM daily_metrics WHERE user_id = ?")
for table in EVERY_TABLE_THAT_HOLDS_WHAT_A_USER_LOGGED {
sqlx::query(sqlx::AssertSqlSafe(format!(
"DELETE FROM {table} WHERE user_id = ?"
)))
.bind(&uid)
.execute(&mut *tx)
.await
.map_err(db_err)?;
}
tx.commit().await.map_err(db_err)?;
Ok(())
@@ -85,6 +81,12 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
.await
.map_err(db_err)?;
sqlx::query("DELETE FROM media_owners WHERE user_id = ?")
.bind(&uid)
.execute(&mut *tx)
.await
.map_err(db_err)?;
sqlx::query("DELETE FROM users WHERE id = ?")
.bind(&uid)
.execute(&mut *tx)
@@ -106,8 +108,8 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
"SELECT * FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ? ORDER BY logged_at DESC",
)
.bind(&uid)
.bind(range.start().to_rfc3339())
.bind(range.end().to_rfc3339())
.bind(sortable_instant(range.start()))
.bind(sortable_instant(range.end()))
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
@@ -120,8 +122,8 @@ impl domain::ports::CascadeDeletePort for SqliteCascadeDeleteRepository {
"DELETE FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ?",
)
.bind(&uid)
.bind(range.start().to_rfc3339())
.bind(range.end().to_rfc3339())
.bind(sortable_instant(range.start()))
.bind(sortable_instant(range.end()))
.execute(&mut *tx)
.await
.map_err(db_err)?;

10
crates/adapters/sqlite/src/repositories/entry/command.rs
View File

@@ -5,7 +5,7 @@ use domain::entry::{DateRange, MoodEntry, MoodEntryId};
use domain::errors::DomainError;
use domain::user::UserId;
use super::super::shared::db_err;
use super::super::shared::{db_err, sortable_instant};
pub struct SqliteEntryCommandRepository {
pool: SqlitePool,
@@ -30,7 +30,7 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
.bind(entry.id().value().to_string())
.bind(entry.user_id().value().to_string())
.bind(entry.mood().value() as i32)
.bind(entry.logged_at().to_rfc3339())
.bind(sortable_instant(entry.logged_at()))
.bind(entry.created_at().to_rfc3339())
.bind(entry.updated_at().to_rfc3339())
.execute(&self.pool)
@@ -56,7 +56,7 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
.bind(&entry_id)
.bind(entry.user_id().value().to_string())
.bind(entry.mood().value() as i32)
.bind(entry.logged_at().to_rfc3339())
.bind(sortable_instant(entry.logged_at()))
.bind(entry.created_at().to_rfc3339())
.bind(entry.updated_at().to_rfc3339())
.execute(&mut *tx)
@@ -95,8 +95,8 @@ impl domain::ports::MoodEntryCommandPort for SqliteEntryCommandRepository {
"DELETE FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ?",
)
.bind(user_id.value().to_string())
.bind(range.start().to_rfc3339())
.bind(range.end().to_rfc3339())
.bind(sortable_instant(range.start()))
.bind(sortable_instant(range.end()))
.execute(&self.pool)
.await
.map_err(db_err)?;

163
crates/adapters/sqlite/src/repositories/entry/query.rs
View File

@@ -1,11 +1,11 @@
use sqlx::SqlitePool;
use domain::activity::ActivityId;
use domain::entry::{DateRange, Mood, MoodEntry, MoodEntryId};
use domain::entry::{DateRange, EntrySelection, MoodEntry, MoodEntryId, Pagination};
use domain::errors::DomainError;
use domain::user::UserId;
use super::super::shared::db_err;
use super::super::shared::{db_err, sortable_instant};
use super::rows::{EntryRow, hydrate_batch, hydrate_single};
pub struct SqliteEntryQueryRepository {
@@ -33,21 +33,11 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
}
}
async fn find_by_user(
&self,
user_id: &UserId,
limit: Option<i64>,
offset: Option<i64>,
) -> Result<Vec<MoodEntry>, DomainError> {
let limit = limit.unwrap_or(i64::MAX);
let offset = offset.unwrap_or(0);
async fn find_all_by_user(&self, user_id: &UserId) -> Result<Vec<MoodEntry>, DomainError> {
let rows = sqlx::query_as::<_, EntryRow>(
"SELECT * FROM mood_entries WHERE user_id = ? ORDER BY logged_at DESC LIMIT ? OFFSET ?",
"SELECT * FROM mood_entries WHERE user_id = ? ORDER BY logged_at DESC",
)
.bind(user_id.value().to_string())
.bind(limit)
.bind(offset)
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
@@ -55,6 +45,47 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
hydrate_batch(&self.pool, rows).await
}
async fn select(
&self,
selection: &EntrySelection,
page: Pagination,
) -> Result<Vec<MoodEntry>, DomainError> {
let narrowing = Narrowing::of(selection);
let sql = format!(
"SELECT me.* FROM mood_entries me{} WHERE {} ORDER BY me.logged_at DESC LIMIT ? OFFSET ?",
narrowing.join, narrowing.conditions
);
let mut query = sqlx::query_as::<_, EntryRow>(sqlx::AssertSqlSafe(sql));
query = narrowing.bind(query);
let rows = query
.bind(page.limit())
.bind(page.offset())
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
hydrate_batch(&self.pool, rows).await
}
async fn count(&self, selection: &EntrySelection) -> Result<u64, DomainError> {
let narrowing = Narrowing::of(selection);
let sql = format!(
"SELECT COUNT(*) FROM mood_entries me{} WHERE {}",
narrowing.join, narrowing.conditions
);
let mut query = sqlx::query_as::<_, (i64,)>(sqlx::AssertSqlSafe(sql));
query = narrowing.bind(query);
let (counted,) = query.fetch_one(&self.pool).await.map_err(db_err)?;
Ok(u64::try_from(counted).unwrap_or(0))
}
async fn find_by_date_range(
&self,
user_id: &UserId,
@@ -64,47 +95,79 @@ impl domain::ports::MoodEntryQueryPort for SqliteEntryQueryRepository {
"SELECT * FROM mood_entries WHERE user_id = ? AND logged_at >= ? AND logged_at <= ? ORDER BY logged_at DESC",
)
.bind(user_id.value().to_string())
.bind(range.start().to_rfc3339())
.bind(range.end().to_rfc3339())
.bind(sortable_instant(range.start()))
.bind(sortable_instant(range.end()))
.fetch_all(&self.pool).await.map_err(db_err)?;
hydrate_batch(&self.pool, rows).await
}
async fn find_by_mood(
&self,
user_id: &UserId,
mood: Mood,
) -> Result<Vec<MoodEntry>, DomainError> {
let rows = sqlx::query_as::<_, EntryRow>(
"SELECT * FROM mood_entries WHERE user_id = ? AND mood = ? ORDER BY logged_at DESC",
)
.bind(user_id.value().to_string())
.bind(mood.value() as i32)
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
async fn count_tagged_with(&self, activity_id: &ActivityId) -> Result<u64, DomainError> {
let (count,): (i64,) =
sqlx::query_as("SELECT COUNT(*) FROM entry_activities WHERE activity_id = ?")
.bind(activity_id.value().to_string())
.fetch_one(&self.pool)
.await
.map_err(db_err)?;
hydrate_batch(&self.pool, rows).await
}
async fn find_by_activity(
&self,
user_id: &UserId,
activity_id: &ActivityId,
) -> Result<Vec<MoodEntry>, DomainError> {
let rows = sqlx::query_as::<_, EntryRow>(
"SELECT me.* FROM mood_entries me
INNER JOIN entry_activities ea ON ea.entry_id = me.id
WHERE me.user_id = ? AND ea.activity_id = ?
ORDER BY me.logged_at DESC",
)
.bind(user_id.value().to_string())
.bind(activity_id.value().to_string())
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
hydrate_batch(&self.pool, rows).await
Ok(u64::try_from(count).unwrap_or(0))
}
}
struct Narrowing<'a> {
join: &'static str,
conditions: String,
selection: &'a EntrySelection,
}
impl<'a> Narrowing<'a> {
fn of(selection: &'a EntrySelection) -> Self {
let mut conditions = vec!["me.user_id = ?".to_string()];
if selection.range().is_some() {
conditions.push("me.logged_at >= ?".into());
conditions.push("me.logged_at <= ?".into());
}
if selection.mood().is_some() {
conditions.push("me.mood = ?".into());
}
if selection.activity().is_some() {
conditions.push("ea.activity_id = ?".into());
}
if selection.since().is_some() {
conditions.push("me.updated_at > ?".into());
}
Self {
join: match selection.activity() {
Some(_) => " INNER JOIN entry_activities ea ON ea.entry_id = me.id",
None => "",
},
conditions: conditions.join(" AND "),
selection,
}
}
fn bind<T>(
&self,
mut query: sqlx::query::QueryAs<'a, sqlx::Sqlite, T, sqlx::sqlite::SqliteArguments>,
) -> sqlx::query::QueryAs<'a, sqlx::Sqlite, T, sqlx::sqlite::SqliteArguments> {
query = query.bind(self.selection.user_id().value().to_string());
if let Some(range) = self.selection.range() {
query = query.bind(sortable_instant(range.start()));
query = query.bind(sortable_instant(range.end()));
}
if let Some(mood) = self.selection.mood() {
query = query.bind(i32::from(mood.value()));
}
if let Some(activity_id) = self.selection.activity() {
query = query.bind(activity_id.value().to_string());
}
if let Some(since) = self.selection.since() {
query = query.bind(since.to_rfc3339());
}
query
}
}

18
crates/adapters/sqlite/src/repositories/job/backfill.rs
View File

@@ -48,6 +48,24 @@ impl domain::ports::RecordingBackfillQueryPort for SqliteRecordingBackfillReposi
Ok(rows.iter().filter_map(readable).collect())
}
async fn find_song_without_a_recording(
&self,
entry_id: &MoodEntryId,
) -> Result<Option<UnidentifiedSong>, DomainError> {
let row: Option<UnidentifiedSongRow> = sqlx::query_as(
"SELECT s.entry_id, e.user_id, s.title, s.artist
FROM entry_song s
JOIN mood_entries e ON e.id = s.entry_id
WHERE s.recording_id IS NULL AND s.entry_id = ?",
)
.bind(entry_id.value().to_string())
.fetch_optional(&self.pool)
.await
.map_err(db_err)?;
Ok(row.as_ref().and_then(readable))
}
async fn record_identity(
&self,
entry_id: &MoodEntryId,

19
crates/adapters/sqlite/src/repositories/job/weather.rs
View File

@@ -47,6 +47,25 @@ impl domain::ports::WeatherBacklogQueryPort for SqliteWeatherBacklogRepository {
Ok(rows.iter().filter_map(readable).collect())
}
async fn find_place_without_weather(
&self,
entry_id: &MoodEntryId,
) -> Result<Option<UnwatchedPlace>, DomainError> {
let row: Option<UnwatchedPlaceRow> = sqlx::query_as(
"SELECT l.entry_id, l.latitude, l.longitude, e.logged_at
FROM entry_location l
JOIN mood_entries e ON e.id = l.entry_id
LEFT JOIN entry_weather w ON w.entry_id = l.entry_id
WHERE w.entry_id IS NULL AND l.entry_id = ?",
)
.bind(entry_id.value().to_string())
.fetch_optional(&self.pool)
.await
.map_err(db_err)?;
Ok(row.as_ref().and_then(readable))
}
}
fn readable(row: &UnwatchedPlaceRow) -> Option<UnwatchedPlace> {

3
crates/adapters/sqlite/src/repositories/media/mod.rs Normal file
View File

@@ -0,0 +1,3 @@
mod ownership;
pub use ownership::SqliteMediaOwnershipRepository;

95
crates/adapters/sqlite/src/repositories/media/ownership.rs Normal file
View File

@@ -0,0 +1,95 @@
use chrono::Utc;
use sqlx::SqlitePool;
use domain::attachment::{MediaKind, MediaRef, PhotoId, VoiceMemoId};
use domain::errors::DomainError;
use domain::user::UserId;
use super::super::shared::db_err;
pub struct SqliteMediaOwnershipRepository {
pool: SqlitePool,
}
impl SqliteMediaOwnershipRepository {
pub fn new(pool: SqlitePool) -> Self {
Self { pool }
}
}
#[async_trait::async_trait]
impl domain::ports::MediaOwnershipPort for SqliteMediaOwnershipRepository {
async fn remember(&self, owner: &UserId, media: MediaRef) -> Result<(), DomainError> {
sqlx::query(
"INSERT INTO media_owners (kind, media_id, user_id, created_at)
VALUES (?, ?, ?, ?)
ON CONFLICT(kind, media_id) DO UPDATE SET user_id = excluded.user_id",
)
.bind(media.kind().name())
.bind(media.id().to_string())
.bind(owner.value().to_string())
.bind(Utc::now().to_rfc3339())
.execute(&self.pool)
.await
.map_err(db_err)?;
Ok(())
}
async fn owner_of(&self, media: MediaRef) -> Result<Option<UserId>, DomainError> {
let found: Option<(String,)> =
sqlx::query_as("SELECT user_id FROM media_owners WHERE kind = ? AND media_id = ?")
.bind(media.kind().name())
.bind(media.id().to_string())
.fetch_optional(&self.pool)
.await
.map_err(db_err)?;
Ok(found
.and_then(|(user_id,)| user_id.parse().ok())
.map(UserId::from_uuid))
}
async fn owned_by(&self, owner: &UserId) -> Result<Vec<MediaRef>, DomainError> {
let rows: Vec<(String, String)> =
sqlx::query_as("SELECT kind, media_id FROM media_owners WHERE user_id = ?")
.bind(owner.value().to_string())
.fetch_all(&self.pool)
.await
.map_err(db_err)?;
Ok(rows.iter().filter_map(readable).collect())
}
async fn forget(&self, media: MediaRef) -> Result<(), DomainError> {
sqlx::query("DELETE FROM media_owners WHERE kind = ? AND media_id = ?")
.bind(media.kind().name())
.bind(media.id().to_string())
.execute(&self.pool)
.await
.map_err(db_err)?;
Ok(())
}
async fn forget_all_by_user(&self, owner: &UserId) -> Result<(), DomainError> {
sqlx::query("DELETE FROM media_owners WHERE user_id = ?")
.bind(owner.value().to_string())
.execute(&self.pool)
.await
.map_err(db_err)?;
Ok(())
}
}
fn readable(row: &(String, String)) -> Option<MediaRef> {
let (kind, media_id) = row;
match MediaKind::from_name(kind)? {
MediaKind::Photo => Some(MediaRef::from(&PhotoId::from_uuid(media_id.parse().ok()?))),
MediaKind::VoiceMemo => Some(MediaRef::from(&VoiceMemoId::from_uuid(
media_id.parse().ok()?,
))),
}
}

2
crates/adapters/sqlite/src/repositories/mod.rs
View File

@@ -8,6 +8,7 @@ mod daily_metric;
mod dimension;
mod entry;
mod job;
mod media;
mod provider_connection;
mod push_subscription;
mod refresh_session;
@@ -29,6 +30,7 @@ pub use entry::{SqliteEntryCommandRepository, SqliteEntryQueryRepository};
pub use job::{
SqliteJobQueueRepository, SqliteRecordingBackfillRepository, SqliteWeatherBacklogRepository,
};
pub use media::SqliteMediaOwnershipRepository;
pub use provider_connection::{
SqliteProviderConnectionCommandRepository, SqliteProviderConnectionQueryRepository,
};

9
crates/adapters/sqlite/src/repositories/push_subscription/command.rs
View File

@@ -48,8 +48,13 @@ impl domain::ports::PushSubscriptionCommandPort for SqlitePushSubscriptionComman
Ok(())
}
async fn delete_by_endpoint(&self, endpoint: &str) -> Result<(), DomainError> {
sqlx::query("DELETE FROM push_subscriptions WHERE endpoint = ?")
async fn delete_by_endpoint(
&self,
user_id: &UserId,
endpoint: &str,
) -> Result<(), DomainError> {
sqlx::query("DELETE FROM push_subscriptions WHERE user_id = ? AND endpoint = ?")
.bind(user_id.value().to_string())
.bind(endpoint)
.execute(&self.pool)
.await

8
crates/adapters/sqlite/src/repositories/reminder/command.rs
View File

@@ -22,13 +22,14 @@ impl SqliteReminderCommandRepository {
impl domain::ports::ReminderCommandPort for SqliteReminderCommandRepository {
async fn save(&self, reminder: &Reminder) -> Result<(), DomainError> {
sqlx::query(
"INSERT INTO reminders (id, user_id, monday, tuesday, wednesday, thursday, friday, saturday, sunday, enabled, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
"INSERT INTO reminders (id, user_id, monday, tuesday, wednesday, thursday, friday, saturday, sunday, enabled, created_at, last_sent_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(id) DO UPDATE SET
monday = excluded.monday, tuesday = excluded.tuesday,
wednesday = excluded.wednesday, thursday = excluded.thursday,
friday = excluded.friday, saturday = excluded.saturday,
sunday = excluded.sunday, enabled = excluded.enabled"
sunday = excluded.sunday, enabled = excluded.enabled,
last_sent_at = excluded.last_sent_at"
)
.bind(reminder.id().value().to_string())
.bind(reminder.user_id().value().to_string())
@@ -41,6 +42,7 @@ impl domain::ports::ReminderCommandPort for SqliteReminderCommandRepository {
.bind(reminder.schedule().time_for(Weekday::Sun).map(format_time))
.bind(reminder.is_enabled())
.bind(reminder.created_at().to_rfc3339())
.bind(reminder.last_sent_at().map(|sent| sent.to_rfc3339()))
.execute(&self.pool).await.map_err(db_err)?;
Ok(())
}

2
crates/adapters/sqlite/src/repositories/reminder/rows.rs
View File

@@ -16,6 +16,7 @@ pub struct ReminderRow {
pub sunday: Option<String>,
pub enabled: bool,
pub created_at: String,
pub last_sent_at: Option<String>,
}
impl ReminderRow {
@@ -36,6 +37,7 @@ impl ReminderRow {
schedule,
self.enabled,
self.created_at.parse().unwrap(),
self.last_sent_at.and_then(|sent| sent.parse().ok()),
)
}
}

8
crates/adapters/sqlite/src/repositories/shared.rs
View File

@@ -1,5 +1,13 @@
use chrono::{DateTime, FixedOffset, SecondsFormat, Utc};
use domain::errors::DomainError;
pub fn db_err(e: sqlx::Error) -> DomainError {
DomainError::InvalidInput(format!("database error: {e}"))
}
pub fn sortable_instant(instant: &DateTime<FixedOffset>) -> String {
instant
.with_timezone(&Utc)
.to_rfc3339_opts(SecondsFormat::Secs, false)
}

5
crates/adapters/sqlite/tests/api_token_test.rs
View File

@@ -1,6 +1,6 @@
use sqlx::sqlite::SqlitePoolOptions;
use domain::api_token::{ApiToken, TokenDigest};
use domain::api_token::{ApiToken, TokenDigest, TokenScope, TokenScopes};
use domain::ports::{ApiTokenCommandPort, ApiTokenQueryPort, CascadeDeletePort, UserCommandPort};
use domain::provider::ProviderName;
use domain::testing::test_user;
@@ -33,6 +33,7 @@ fn a_token(owner: &UserId, name: &str, digest: &str) -> ApiToken {
owner.clone(),
ProviderName::new(name).unwrap(),
TokenDigest::from_persistence(digest.into()),
TokenScopes::new([TokenScope::WriteMetrics]).unwrap(),
)
}
@@ -152,7 +153,7 @@ async fn a_row_with_a_scope_this_build_does_not_know_authenticates_nothing() {
let (pool, user) = a_pool_with_a_user().await;
sqlx::query(
"INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at, last_used_at)
"INSERT INTO api_tokens (id, user_id, name, digest, scopes, created_at, last_used_at)
VALUES (?, ?, ?, ?, ?, ?, NULL)",
)
.bind(uuid::Uuid::new_v4().to_string())

167
crates/adapters/sqlite/tests/cascade_test.rs
View File

@@ -283,3 +283,170 @@ fn remove(path: &str) {
let _ = std::fs::remove_file(format!("{path}-wal"));
let _ = std::fs::remove_file(format!("{path}-shm"));
}
const EVERY_TABLE_A_USER_FILLS: [&str; 7] = [
"mood_entries",
"activities",
"reminders",
"daily_metrics",
"cycle_starts",
"metric_rejections",
"media_owners",
];
async fn fill_every_table_for(pool: &SqlitePool, user: &User) {
let entry = MoodEntry::new(
user.id().clone(),
Mood::Good,
chrono::DateTime::parse_from_rfc3339("2026-08-20T12:00:00+02:00").unwrap(),
);
SqliteEntryCommandRepository::new(pool.clone())
.save(&entry)
.await
.unwrap();
domain::ports::ActivityCommandPort::save(
&sqlite::repositories::SqliteActivityCommandRepository::new(pool.clone()),
&domain::testing::test_activity(user.id().clone(), "gaming"),
)
.await
.unwrap();
domain::ports::ReminderCommandPort::save(
&sqlite::repositories::SqliteReminderCommandRepository::new(pool.clone()),
&domain::testing::test_reminder(user.id().clone()),
)
.await
.unwrap();
domain::ports::DailyMetricCommandPort::save(
&sqlite::repositories::SqliteDailyMetricCommandRepository::new(pool.clone()),
&[domain::metric::DailyMetric::new(
user.id().clone(),
a_date("2026-08-20"),
domain::metric::MetricValue::Steps(domain::metric::Steps::new(8_412).unwrap()),
domain::metric::Source::Manual,
)],
)
.await
.unwrap();
domain::ports::CycleStartCommandPort::record(
&sqlite::repositories::SqliteCycleStartRepository::new(pool.clone()),
user.id(),
&a_date("2026-08-01"),
)
.await
.unwrap();
domain::ports::RejectionCommandPort::record(
&sqlite::repositories::SqliteRejectionRepository::new(pool.clone(), 100),
&[domain::rejection::RejectedMetric::new(
user.id().clone(),
domain::rejection::RejectionOrigin::Import,
domain::rejection::RejectionDetail::new(
None,
Some(a_date("2026-08-19")),
"steps",
Some(-1),
),
String::from("steps cannot be negative"),
)],
)
.await
.unwrap();
domain::ports::MediaOwnershipPort::remember(
&sqlite::repositories::SqliteMediaOwnershipRepository::new(pool.clone()),
user.id(),
(&domain::attachment::PhotoId::generate()).into(),
)
.await
.unwrap();
}
fn a_date(day: &str) -> domain::entry::Date {
domain::entry::Date::from_persistence(day.parse().unwrap())
}
#[tokio::test]
async fn clearing_a_users_data_empties_every_table_they_fill() {
let path = a_file().await;
let pool = sqlite::create_pool(&format!("sqlite://{path}"))
.await
.unwrap();
sqlite::run_migrations(&pool).await.unwrap();
let user = test_user("alice");
SqliteUserCommandRepository::new(pool.clone())
.save(&user)
.await
.unwrap();
fill_every_table_for(&pool, &user).await;
for table in EVERY_TABLE_A_USER_FILLS {
assert_eq!(rows_in(&pool, table).await, 1, "{table} should be seeded");
}
domain::ports::CascadeDeletePort::delete_all_user_data(
&sqlite::repositories::SqliteCascadeDeleteRepository::new(pool.clone()),
user.id(),
)
.await
.unwrap();
for table in EVERY_TABLE_A_USER_FILLS {
assert_eq!(
rows_in(&pool, table).await,
0,
"{table} still holds data the user asked to be cleared"
);
}
let users: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(users.0, 1, "clearing data is not deleting the account");
remove(&path);
}
#[tokio::test]
async fn deleting_an_account_empties_every_table_they_fill() {
let path = a_file().await;
let pool = sqlite::create_pool(&format!("sqlite://{path}"))
.await
.unwrap();
sqlite::run_migrations(&pool).await.unwrap();
let user = test_user("alice");
SqliteUserCommandRepository::new(pool.clone())
.save(&user)
.await
.unwrap();
fill_every_table_for(&pool, &user).await;
domain::ports::CascadeDeletePort::delete_user_account(
&sqlite::repositories::SqliteCascadeDeleteRepository::new(pool.clone()),
user.id(),
)
.await
.unwrap();
for table in EVERY_TABLE_A_USER_FILLS {
assert_eq!(
rows_in(&pool, table).await,
0,
"{table} outlived the account it belonged to"
);
}
let users: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(users.0, 0);
remove(&path);
}

142
crates/adapters/sqlite/tests/entry_instant_test.rs Normal file
View File

@@ -0,0 +1,142 @@
use chrono::{DateTime, FixedOffset};
use sqlx::SqlitePool;
use domain::entry::{DateRange, Mood, MoodEntry};
use domain::ports::{MoodEntryCommandPort, MoodEntryQueryPort, UserCommandPort};
use domain::testing::test_user;
use domain::user::User;
use sqlite::repositories::{
SqliteEntryCommandRepository, SqliteEntryQueryRepository, SqliteUserCommandRepository,
};
fn a_file() -> String {
let name = format!("k-mood-instants-{}.sqlite", uuid::Uuid::new_v4());
std::env::temp_dir()
.join(name)
.to_string_lossy()
.to_string()
}
async fn a_pool_with_a_user() -> (SqlitePool, User) {
let path = a_file();
let pool = sqlite::create_pool(&format!("sqlite://{path}"))
.await
.unwrap();
sqlite::run_migrations(&pool).await.unwrap();
let user = test_user("alice");
SqliteUserCommandRepository::new(pool.clone())
.save(&user)
.await
.unwrap();
(pool, user)
}
fn instant(text: &str) -> DateTime<FixedOffset> {
DateTime::parse_from_rfc3339(text).unwrap()
}
async fn save(pool: &SqlitePool, user: &User, logged_at: &str) -> MoodEntry {
let entry = MoodEntry::new(user.id().clone(), Mood::Good, instant(logged_at));
SqliteEntryCommandRepository::new(pool.clone())
.save(&entry)
.await
.unwrap();
entry
}
async fn stored_text(pool: &SqlitePool, entry: &MoodEntry) -> String {
let (held,): (String,) = sqlx::query_as("SELECT logged_at FROM mood_entries WHERE id = ?")
.bind(entry.id().value().to_string())
.fetch_one(pool)
.await
.unwrap();
held
}
#[tokio::test]
async fn an_instant_is_held_in_utc_whatever_offset_it_arrived_in() {
let (pool, user) = a_pool_with_a_user().await;
let entry = save(&pool, &user, "2026-08-25T20:00:00+02:00").await;
assert_eq!(
stored_text(&pool, &entry).await,
"2026-08-25T18:00:00+00:00",
"one canonical form makes the column sortable"
);
}
#[tokio::test]
async fn an_instant_survives_the_round_trip_unchanged() {
let (pool, user) = a_pool_with_a_user().await;
let entry = save(&pool, &user, "2026-08-25T20:00:00+02:00").await;
let read = SqliteEntryQueryRepository::new(pool.clone())
.find_by_id(entry.id())
.await
.unwrap()
.unwrap();
assert_eq!(
read.logged_at(),
entry.logged_at(),
"the instant is the fact; the offset it was written in is not"
);
}
#[tokio::test]
async fn a_range_finds_entries_written_in_other_offsets() {
let (pool, user) = a_pool_with_a_user().await;
let eastern = save(&pool, &user, "2026-08-25T01:30:00+03:00").await;
let western = save(&pool, &user, "2026-08-24T21:30:00-04:00").await;
let whole_of_the_24th_utc = DateRange::new(
instant("2026-08-24T00:00:00+00:00"),
instant("2026-08-24T23:59:59+00:00"),
)
.unwrap();
let found = SqliteEntryQueryRepository::new(pool.clone())
.find_by_date_range(user.id(), &whole_of_the_24th_utc)
.await
.unwrap();
let ids: Vec<_> = found.iter().map(|entry| entry.id().clone()).collect();
assert!(
ids.contains(eastern.id()),
"01:30+03:00 is 22:30Z on the 24th and belongs in the range"
);
assert!(
!ids.contains(western.id()),
"21:30-04:00 is 01:30Z on the 25th, so it falls outside the range"
);
}
#[tokio::test]
async fn entries_come_back_newest_first_across_mixed_offsets() {
let (pool, user) = a_pool_with_a_user().await;
let earlier = save(&pool, &user, "2026-08-25T00:30:00+02:00").await;
let later = save(&pool, &user, "2026-08-25T00:00:00+00:00").await;
let found = SqliteEntryQueryRepository::new(pool.clone())
.find_all_by_user(user.id())
.await
.unwrap();
assert_eq!(
found[0].id(),
later.id(),
"22:30Z precedes 00:00Z, however the offsets sort as text"
);
assert_eq!(found[1].id(), earlier.id());
}

103
crates/adapters/sqlite/tests/migration_check.rs
View File

@@ -140,3 +140,106 @@ async fn a_process_joining_a_migrated_database_applies_nothing() {
forget(&path);
}
#[tokio::test]
async fn legacy_instants_are_rewritten_into_one_sortable_form() {
let pool = fresh_pool().await;
sqlite::run_migrations(&pool).await.unwrap();
let user = domain::testing::test_user("alice");
domain::ports::UserCommandPort::save(
&sqlite::repositories::SqliteUserCommandRepository::new(pool.clone()),
&user,
)
.await
.unwrap();
let legacy = [
("2026-08-25T20:00:00+02:00", "2026-08-25T18:00:00+00:00"),
("2026-08-24T21:30:00-04:00", "2026-08-25T01:30:00+00:00"),
("2026-08-23T09:00:00+00:00", "2026-08-23T09:00:00+00:00"),
];
for (index, (written, _)) in legacy.iter().enumerate() {
sqlx::query(
"INSERT INTO mood_entries (id, user_id, mood, logged_at, created_at, updated_at)
VALUES (?, ?, 3, ?, ?, ?)",
)
.bind(format!("00000000-0000-0000-0000-00000000000{index}"))
.bind(user.id().value().to_string())
.bind(written)
.bind(written)
.bind(written)
.execute(&pool)
.await
.unwrap();
}
sqlx::raw_sql(include_str!("../src/migrations/015_logged_at_in_utc.sql"))
.execute(&pool)
.await
.unwrap();
for (index, (written, expected)) in legacy.iter().enumerate() {
let (held,): (String,) = sqlx::query_as("SELECT logged_at FROM mood_entries WHERE id = ?")
.bind(format!("00000000-0000-0000-0000-00000000000{index}"))
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(held, *expected, "{written} should normalise to {expected}");
}
}
#[tokio::test]
async fn a_token_minted_before_scopes_existed_still_writes_metrics() {
let pool = fresh_pool().await;
for (name, sql) in sqlite::migrations_before("016_api_token_scopes") {
sqlx::raw_sql(sql)
.execute(&pool)
.await
.unwrap_or_else(|error| panic!("{name} failed: {error}"));
}
let user = domain::testing::test_user("alice");
domain::ports::UserCommandPort::save(
&sqlite::repositories::SqliteUserCommandRepository::new(pool.clone()),
&user,
)
.await
.unwrap();
sqlx::query(
"INSERT INTO api_tokens (id, user_id, name, digest, scope, created_at)
VALUES (?, ?, 'tasker', 'abc123', 'writeMetrics', ?)",
)
.bind(uuid::Uuid::new_v4().to_string())
.bind(user.id().value().to_string())
.bind(chrono::Utc::now().to_rfc3339())
.execute(&pool)
.await
.unwrap();
sqlx::raw_sql(include_str!("../src/migrations/016_api_token_scopes.sql"))
.execute(&pool)
.await
.unwrap();
let found = domain::ports::ApiTokenQueryPort::find_by_digest(
&sqlite::repositories::SqliteApiTokenQueryRepository::new(pool.clone()),
&domain::api_token::TokenDigest::from_persistence("abc123".into()),
)
.await
.unwrap()
.expect("the token should have survived the migration");
assert!(
found.allows(domain::api_token::TokenScope::WriteMetrics),
"a token minted before scopes existed keeps doing what it always did"
);
assert!(
!found.allows(domain::api_token::TokenScope::ReadJournal),
"and gains nothing it was never granted"
);
}