some fixes

src/api.rs

@@ -768,6 +768,7 @@ async fn serve_token_file(state: &SharedState, token: &str, filename: &str) -> R
         HeaderValue::from_str(mime.as_ref()).unwrap_or_else(|_| HeaderValue::from_static("application/octet-stream")),
     );
     response.headers_mut().insert(header::X_CONTENT_TYPE_OPTIONS, HeaderValue::from_static("nosniff"));
+    response.headers_mut().insert(header::CACHE_CONTROL, HeaderValue::from_static("public, max-age=600"));
     Ok(response)
 }
 

src/db.rs

@@ -404,6 +404,23 @@ struct PublishedPageRow {
     updated_at: String,
 }
 
+
+#[derive(Debug, Clone, FromRow)]
+struct PostgresPublishedPageRow {
+    token: String,
+    pad_id: Option<i64>,
+    note_id: Option<i64>,
+    allow_task_updates: bool,
+    title: String,
+    content: String,
+    updated_at: String,
+}
+
+impl From<PostgresPublishedPageRow> for PublishedPage {
+    fn from(value: PostgresPublishedPageRow) -> Self {
+        Self { token: value.token, pad_id: value.pad_id, note_id: value.note_id, allow_task_updates: value.allow_task_updates, title: value.title, content: value.content, updated_at: value.updated_at }
+    }
+}
 impl From<PublishedPageRow> for PublishedPage {
     fn from(value: PublishedPageRow) -> Self {
         Self {
@@ -453,40 +470,47 @@ pub async fn publish_note(pool: &Database, note_id: i64) -> Result<String, sqlx:
 }
 
 pub async fn find_published_page(pool: &Database, token: &str) -> Result<Option<PublishedPage>, sqlx::Error> {
+    if pool.kind() == DatabaseKind::Postgres {
+        return Ok(sqlx::query_as::<_, PostgresPublishedPageRow>(queries::Q021_POSTGRES)
+            .bind(token).fetch_optional(pool.pool()).await?.map(Into::into));
+    }
     Ok(sqlx::query_as::<_, PublishedPageRow>(queries::get(pool.kind(), queries::Q021))
-        .bind(token)
-        .fetch_optional(pool.pool())
-        .await?
-        .map(Into::into))
+        .bind(token).fetch_optional(pool.pool()).await?.map(Into::into))
 }
 
 pub async fn pad_public_task_updates(pool: &Database, pad_id: i64) -> Result<bool, sqlx::Error> {
+    if pool.kind() == DatabaseKind::Postgres {
+        return Ok(sqlx::query_scalar::<_, bool>(queries::Q044_POSTGRES)
+            .bind(pad_id).fetch_optional(pool.pool()).await?.unwrap_or(false));
+    }
     let value = sqlx::query_scalar::<_, i64>(queries::get(pool.kind(), queries::Q044))
-        .bind(pad_id)
-        .fetch_optional(pool.pool())
-        .await?
-        .unwrap_or(0);
+        .bind(pad_id).fetch_optional(pool.pool()).await?.unwrap_or(0);
     Ok(value != 0)
 }
 
 pub async fn note_public_task_updates(pool: &Database, note_id: i64) -> Result<bool, sqlx::Error> {
+    if pool.kind() == DatabaseKind::Postgres {
+        return Ok(sqlx::query_scalar::<_, bool>(queries::Q045_POSTGRES)
+            .bind(note_id).fetch_optional(pool.pool()).await?.unwrap_or(false));
+    }
     let value = sqlx::query_scalar::<_, i64>(queries::get(pool.kind(), queries::Q045))
-        .bind(note_id)
-        .fetch_optional(pool.pool())
-        .await?
-        .unwrap_or(0);
+        .bind(note_id).fetch_optional(pool.pool()).await?.unwrap_or(0);
     Ok(value != 0)
 }
 
 pub async fn set_pad_public_task_updates(pool: &Database, pad_id: i64, allow: bool) -> Result<(), sqlx::Error> {
     publish_pad(pool, pad_id).await?;
-    sqlx::query(queries::get(pool.kind(), queries::Q040)).bind(if allow { 1i64 } else { 0i64 }).bind(pad_id).execute(pool.pool()).await?;
+    let mut query = sqlx::query(queries::get(pool.kind(), queries::Q040));
+    query = if pool.kind() == DatabaseKind::Postgres { query.bind(allow) } else { query.bind(if allow { 1i64 } else { 0i64 }) };
+    query.bind(pad_id).execute(pool.pool()).await?;
     Ok(())
 }
 
 pub async fn set_note_public_task_updates(pool: &Database, note_id: i64, allow: bool) -> Result<(), sqlx::Error> {
     publish_note(pool, note_id).await?;
-    sqlx::query(queries::get(pool.kind(), queries::Q041)).bind(if allow { 1i64 } else { 0i64 }).bind(note_id).execute(pool.pool()).await?;
+    let mut query = sqlx::query(queries::get(pool.kind(), queries::Q041));
+    query = if pool.kind() == DatabaseKind::Postgres { query.bind(allow) } else { query.bind(if allow { 1i64 } else { 0i64 }) };
+    query.bind(note_id).execute(pool.pool()).await?;
     Ok(())
 }
 

src/queries.rs

@@ -73,3 +73,7 @@ pub const Q043: &str = "UPDATE notes SET content = ?, updated_at = CURRENT_TIMES
 
 pub const Q044: &str = "SELECT CASE WHEN allow_task_updates THEN 1 ELSE 0 END FROM published_pages WHERE pad_id = ?";
 pub const Q045: &str = "SELECT CASE WHEN allow_task_updates THEN 1 ELSE 0 END FROM published_pages WHERE note_id = ?";
+
+pub const Q021_POSTGRES: &str = "SELECT pp.token, pp.pad_id, pp.note_id, pp.allow_task_updates, COALESCE(p.title, n.title) AS title, COALESCE(p.content, n.content) AS content, COALESCE(p.updated_at, n.updated_at) AS updated_at FROM published_pages pp LEFT JOIN pads p ON p.id = pp.pad_id LEFT JOIN notes n ON n.id = pp.note_id WHERE pp.token = $1";
+pub const Q044_POSTGRES: &str = "SELECT allow_task_updates FROM published_pages WHERE pad_id = $1";
+pub const Q045_POSTGRES: &str = "SELECT allow_task_updates FROM published_pages WHERE note_id = $1";