use serde::Deserialize; use worker::*; use crate::claim::{SitesStore, utc_now_rfc3339}; #[derive(Clone, Debug, PartialEq)] pub struct RepoRow { pub repo_did: String, pub owner_did: String, pub name: String, pub rkey: String, pub knot: String, } #[derive(Clone, Debug, PartialEq)] pub struct SiteConfigRow { pub repo_did: String, pub branch: String, pub dir: String, pub is_index: bool, } #[derive(Clone, Debug, PartialEq)] pub struct DeployRow { pub status: String, pub trigger: String, pub branch: String, pub dir: String, pub commit_sha: String, pub error: String, pub created_at: String, } #[derive(Clone, Debug, PartialEq)] pub struct DeployContext { pub owner_did: String, pub domain: String, pub name: String, pub rkey: String, pub knot: String, pub branch: String, pub dir: String, pub is_index: bool, } pub fn normalize_dir(dir: &str) -> Option { let trimmed = dir.trim(); let mut parts: Vec<&str> = Vec::new(); for seg in trimmed.split('/') { match seg { "" | "." => continue, ".." => return None, s => parts.push(s), } } if parts.is_empty() { return Some("/".to_string()); } Some(format!("/{}", parts.join("/"))) } #[derive(Deserialize)] struct RepoRowD1 { repo_did: String, owner_did: String, name: String, rkey: String, knot: String, } #[derive(Deserialize)] struct SiteConfigRowD1 { repo_did: String, branch: String, dir: String, is_index: i64, } #[derive(Deserialize)] struct DeployRowD1 { status: String, trigger: String, branch: String, dir: String, commit_sha: String, error: String, created_at: String, } pub const ERR_NOT_OWNER: &str = "site config belongs to another owner"; pub const ERR_INDEX_TAKEN: &str = "another repository is the domain's index site"; // binds go in the order is_index, owner_did, repo_did const UNLESS_INDEX_TAKEN: &str = "WHERE NOT (? AND EXISTS (SELECT 1 FROM repo_sites rs \ JOIN site_repos sr ON sr.repo_did = rs.repo_did \ WHERE sr.owner_did = ? AND rs.is_index = 1 AND rs.repo_did != ?))"; impl SitesStore { pub async fn get_repo(&self, repo_did: &str) -> Result, String> { let db = self.d1_db()?; let stmt = db .prepare( "SELECT repo_did, owner_did, name, rkey, knot FROM site_repos WHERE repo_did = ?", ) .bind_refs(&[D1Type::Text(repo_did)]) .map_err(|e| e.to_string())?; Ok(stmt .first::(None) .await .map_err(|e| e.to_string())? .map(|r| RepoRow { repo_did: r.repo_did, owner_did: r.owner_did, name: r.name, rkey: r.rkey, knot: r.knot, })) } pub async fn get_site_config(&self, repo_did: &str) -> Result, String> { let db = self.d1_db()?; let stmt = db .prepare( "SELECT rs.repo_did, rs.branch, rs.dir, rs.is_index \ FROM repo_sites rs JOIN site_repos sr ON sr.repo_did = rs.repo_did \ WHERE rs.repo_did = ?", ) .bind_refs(&[D1Type::Text(repo_did)]) .map_err(|e| e.to_string())?; Ok(stmt .first::(None) .await .map_err(|e| e.to_string())? .map(|r| SiteConfigRow { repo_did: r.repo_did, branch: r.branch, dir: r.dir, is_index: r.is_index != 0, })) } pub async fn update_site_config( &self, repo_did: &str, owner_did: &str, name: &str, rkey: &str, knot: &str, branch: &str, dir: &str, is_index: bool, reclaim_disputed_owner: bool, ) -> Result<(), String> { let db = self.d1_db()?; if let Some(existing) = self.get_repo(repo_did).await? { if existing.owner_did != owner_did && !reclaim_disputed_owner { return Err(ERR_NOT_OWNER.to_string()); } } let now = utc_now_rfc3339(); let is_index_int = if is_index { 1 } else { 0 }; // the check sits in the writes so a racing save can't slip past it let stmts = vec![ db.prepare(format!( "INSERT INTO site_repos (repo_did, owner_did, name, rkey, knot) SELECT ?, ?, ?, ?, ? {} \ ON CONFLICT(repo_did) DO UPDATE SET owner_did = excluded.owner_did, \ name = excluded.name, rkey = excluded.rkey, knot = excluded.knot", UNLESS_INDEX_TAKEN )) .bind_refs(&[ D1Type::Text(repo_did), D1Type::Text(owner_did), D1Type::Text(name), D1Type::Text(rkey), D1Type::Text(knot), D1Type::Integer(is_index_int), D1Type::Text(owner_did), D1Type::Text(repo_did), ]) .map_err(|e| e.to_string())?, db.prepare(format!( "INSERT INTO repo_sites (repo_did, branch, dir, is_index, created, updated) SELECT ?, ?, ?, ?, ?, ? {} \ ON CONFLICT(repo_did) DO UPDATE SET branch = excluded.branch, dir = excluded.dir, \ is_index = excluded.is_index, updated = excluded.updated", UNLESS_INDEX_TAKEN )) .bind_refs(&[ D1Type::Text(repo_did), D1Type::Text(branch), D1Type::Text(dir), D1Type::Integer(is_index_int), D1Type::Text(&now), D1Type::Text(&now), D1Type::Integer(is_index_int), D1Type::Text(owner_did), D1Type::Text(repo_did), ]) .map_err(|e| e.to_string())?, ]; let results = db.batch(stmts).await.map_err(|e| e.to_string())?; let written = results .last() .and_then(|r| r.meta().ok().flatten()) .and_then(|m| m.changes) .unwrap_or(0); if is_index && written == 0 { return Err(ERR_INDEX_TAKEN.to_string()); } Ok(()) } pub async fn delete_repo_and_config(&self, repo_did: &str) -> Result, String> { let db = self.d1_db()?; let repo = self.get_repo(repo_did).await?; let stmts = vec![ db.prepare("DELETE FROM repo_sites WHERE repo_did = ?") .bind_refs(&[D1Type::Text(repo_did)]) .map_err(|e| e.to_string())?, db.prepare("DELETE FROM site_repos WHERE repo_did = ?") .bind_refs(&[D1Type::Text(repo_did)]) .map_err(|e| e.to_string())?, ]; db.batch(stmts).await.map_err(|e| e.to_string())?; Ok(repo) } pub async fn delete_repos_for_owner(&self, owner_did: &str) -> Result, String> { let db = self.d1_db()?; let stmt = db .prepare( "SELECT repo_did, owner_did, name, rkey, knot FROM site_repos WHERE owner_did = ?", ) .bind_refs(&[D1Type::Text(owner_did)]) .map_err(|e| e.to_string())?; let rows = stmt .all() .await .map_err(|e| e.to_string())? .results::() .map_err(|e| e.to_string())? .into_iter() .map(|r| RepoRow { repo_did: r.repo_did, owner_did: r.owner_did, name: r.name, rkey: r.rkey, knot: r.knot, }) .collect::>(); if !rows.is_empty() { let stmts = vec![ db.prepare( "DELETE FROM repo_sites \ WHERE repo_did IN (SELECT repo_did FROM site_repos WHERE owner_did = ?)", ) .bind_refs(&[D1Type::Text(owner_did)]) .map_err(|e| e.to_string())?, db.prepare("DELETE FROM site_repos WHERE owner_did = ?") .bind_refs(&[D1Type::Text(owner_did)]) .map_err(|e| e.to_string())?, ]; db.batch(stmts).await.map_err(|e| e.to_string())?; } Ok(rows) } pub async fn deploy_context(&self, repo_did: &str) -> Result, String> { let db = self.d1_db()?; #[derive(Deserialize)] struct Row { owner_did: String, domain: String, name: String, rkey: String, knot: String, branch: String, dir: String, is_index: i64, } let stmt = db .prepare( "SELECT sr.owner_did, dc.domain, sr.name, sr.rkey, sr.knot, rs.branch, rs.dir, rs.is_index \ FROM site_repos sr \ JOIN repo_sites rs ON rs.repo_did = sr.repo_did \ JOIN domain_claims dc ON dc.did = sr.owner_did AND dc.deleted IS NULL \ WHERE sr.repo_did = ?", ) .bind_refs(&[D1Type::Text(repo_did)]) .map_err(|e| e.to_string())?; Ok(stmt .first::(None) .await .map_err(|e| e.to_string())? .map(|r| DeployContext { owner_did: r.owner_did, domain: r.domain, name: r.name, rkey: r.rkey, knot: r.knot, branch: r.branch, dir: r.dir, is_index: r.is_index != 0, })) } pub async fn mapping_rows_for_domain( &self, domain: &str, ) -> Result)>, String> { let db = self.d1_db()?; #[derive(Deserialize)] struct Row { owner_did: String, name: String, rkey: String, is_index: i64, } let stmt = db .prepare( "SELECT sr.owner_did, sr.name, sr.rkey, rs.is_index \ FROM site_repos sr \ JOIN repo_sites rs ON rs.repo_did = sr.repo_did \ JOIN domain_claims dc ON dc.did = sr.owner_did AND dc.domain = ? AND dc.deleted IS NULL", ) .bind_refs(&[D1Type::Text(domain)]) .map_err(|e| e.to_string())?; let rows = stmt .all() .await .map_err(|e| e.to_string())? .results::() .map_err(|e| e.to_string())?; if rows.is_empty() { return Ok(None); } let owner_did = rows[0].owner_did.clone(); let mut sitelist = Vec::with_capacity(rows.len()); for r in rows { sitelist.push((r.name, r.rkey, r.is_index != 0)); } Ok(Some((owner_did, sitelist))) } /// newest first; created_at is RFC3339 UTC to the second, so text order is time order pub async fn deploy_history_for_repo( &self, repo_did: &str, limit: i32, ) -> Result, String> { let db = self.d1_db()?; let stmt = db .prepare( "SELECT status, trigger, branch, dir, commit_sha, error, created_at \ FROM site_deploys WHERE repo_did = ? ORDER BY created_at DESC, id DESC LIMIT ?", ) .bind_refs(&[D1Type::Text(repo_did), D1Type::Integer(limit)]) .map_err(|e| e.to_string())?; Ok(stmt .all() .await .map_err(|e| e.to_string())? .results::() .map_err(|e| e.to_string())? .into_iter() .map(|r| DeployRow { status: r.status, trigger: r.trigger, branch: r.branch, dir: r.dir, commit_sha: r.commit_sha, error: r.error, created_at: r.created_at, }) .collect()) } #[allow(clippy::too_many_arguments)] pub async fn insert_deploy( &self, repo_did: &str, branch: &str, dir: &str, commit_sha: &str, status: &str, trigger: &str, error: &str, ) -> Result<(), String> { let db = self.d1_db()?; let created_at = utc_now_rfc3339(); db.prepare( "INSERT INTO site_deploys (repo_did, branch, dir, commit_sha, status, trigger, error, created_at) \ VALUES (?, ?, ?, ?, ?, ?, ?, ?)", ) .bind_refs(&[ D1Type::Text(repo_did), D1Type::Text(branch), D1Type::Text(dir), D1Type::Text(commit_sha), D1Type::Text(status), D1Type::Text(trigger), D1Type::Text(error), D1Type::Text(&created_at), ]) .map_err(|e| e.to_string())? .run() .await .map_err(|e| e.to_string())?; Ok(()) } }