From 1f44cd930cdff94bb8cf04f645a5b035507438d9 Mon Sep 17 00:00:00 2001
From: Owen Jacobson <owen@grimoire.ca>
Date: Fri, 24 Oct 2025 19:10:29 -0400
Subject: Add an endpoint for creating push subscriptions.

The semantics of this endpoint are somewhat complex, and are incompletely captured in the associated docs change. For posterity, the intended workflow is:

1. Obtain Pilcrow's current VAPID key by connecting (it's in the events, either from boot or from the event stream).
2. Use the browser push APIs to create a push subscription, using that VAPID key.
3. Send Pilcrow the push subscription endpoint and keys, plus the VAPID key the client used to create it so that the server can detect race conditions with key rotation.
4. Wait for messages to arrive.

This commit does not introduce any actual messages, just subscription management endpoints.

When the server's VAPID key is rotated, all existing subscriptions are discarded. Without the VAPID key, the server cannot service those subscriptions. We can't exactly notify the broker to stop processing messages on those subscriptions, so this is an incomplete solution to what to do if the key is being rotated due to a compromise, but it's better than nothing.

The shape of the API endpoint is heavily informed by the [JSON payload][web-push-json] provided by browser Web Push implementations, to ease client development in a browser-based context. The idea is that a client can take that JSON and send it to the server verbatim, without needing to transform it in any way, to submit the subscription to the server for use.

[web-push-json]: https://developer.mozilla.org/en-US/docs/Web/API/PushSubscription/toJSON

Push subscriptions are operationally associated with a specific _user agent_, and have no inherent relationship with a Pilcrow login or token (session). Taken as-is, a subscription created by user A could be reused by user B if they share a user agent, even if user A logs out before user B logs in. Pilcrow therefore _logically_ associates push subscriptions with specific tokens, and abandons those subscriptions when the token is invalidated by

* logging out,
* expiry, or
* changing passwords.

(There are no other token invalidation workflows at this time.)

Stored subscriptions are also abandoned when the server's VAPID key changes.
---
 src/push/repo.rs | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/push/repo.rs

(limited to 'src/push/repo.rs')

diff --git a/src/push/repo.rs b/src/push/repo.rs
new file mode 100644
index 0000000..6c18c6e
--- /dev/null
+++ b/src/push/repo.rs
@@ -0,0 +1,114 @@
+use sqlx::{Sqlite, SqliteConnection, Transaction};
+use web_push::SubscriptionInfo;
+
+use crate::{login::Login, token::Token};
+
+pub trait Provider {
+    fn push(&mut self) -> Push<'_>;
+}
+
+impl Provider for Transaction<'_, Sqlite> {
+    fn push(&mut self) -> Push<'_> {
+        Push(self)
+    }
+}
+
+pub struct Push<'t>(&'t mut SqliteConnection);
+
+impl Push<'_> {
+    pub async fn create(
+        &mut self,
+        token: &Token,
+        subscription: &SubscriptionInfo,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            r#"
+                insert into push_subscription (token, endpoint, p256dh, auth)
+                values ($1, $2, $3, $4)
+            "#,
+            token.id,
+            subscription.endpoint,
+            subscription.keys.p256dh,
+            subscription.keys.auth,
+        )
+        .execute(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn by_endpoint(
+        &mut self,
+        subscriber: &Login,
+        endpoint: &str,
+    ) -> Result<SubscriptionInfo, sqlx::Error> {
+        let row = sqlx::query!(
+            r#"
+                select
+                    subscription.endpoint,
+                    subscription.p256dh,
+                    subscription.auth
+                from push_subscription as subscription
+                    join token on subscription.token = token.id
+                    join login as subscriber on token.login = subscriber.id
+                where subscriber.id = $1
+                and subscription.endpoint = $2
+            "#,
+            subscriber.id,
+            endpoint,
+        )
+        .fetch_one(&mut *self.0)
+        .await?;
+
+        let info = SubscriptionInfo::new(row.endpoint, row.p256dh, row.auth);
+
+        Ok(info)
+    }
+
+    pub async fn unsubscribe_token(&mut self, token: &Token) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            r#"
+                delete from push_subscription
+                where token = $1
+            "#,
+            token.id,
+        )
+        .execute(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn unsubscribe_login(&mut self, login: &Login) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            r#"
+                with tokens as (
+                    select id from token
+                    where login = $1
+                )
+                delete from push_subscription
+                where token in tokens
+            "#,
+            login.id,
+        )
+        .execute(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+
+    // Unsubscribe logic for token expiry lives in the `tokens` repository, for maintenance reasons.
+
+    pub async fn clear(&mut self) -> Result<(), sqlx::Error> {
+        // We assume that _all_ stored subscriptions are for a VAPID key we're about to delete.
+        sqlx::query!(
+            r#"
+                delete from push_subscription
+            "#,
+        )
+        .execute(&mut *self.0)
+        .await?;
+
+        Ok(())
+    }
+}
-- 
cgit v1.2.3