feat: add unlisted visibility

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

CHANGELOG.md

@@ -23,6 +23,7 @@ Since this is not a library, this changelog focuses on the changes that are rele
 - Added global and per-entity collection settings for visitor grouping, geolocation detail, session metrics, UTM parameters, and data retention
 - Added ingest drop rules to discard matching events before they are stored
 - Added project display settings to show or hide metrics and dimensions per project
+- Added unlisted project visibility
 - Added a pruning tool to apply retention and collection settings to historical data
 
 ### Bug Fixes

Cargo.lock

@@ -82,13 +82,14 @@ impl LiwanEntities {
     pub fn projects(&self, entity_id: &str) -> Result<Vec<models::Project>> {
         let conn = self.pool.get()?;
         let mut stmt = conn.prepare_cached(
-            "select p.id, p.display_name, p.public, p.secret from projects p join project_entities pe on p.id = pe.project_id where pe.entity_id = ?",
+            "select p.id, p.display_name, p.public, p.unlisted, p.secret from projects p join project_entities pe on p.id = pe.project_id where pe.entity_id = ?",
         )?;
         let projects = stmt.query_map(rusqlite::params![entity_id], |row| {
             Ok(models::Project {
                 id: row.get("id")?,
                 display_name: row.get("display_name")?,
                 public: row.get("public")?,
+                unlisted: row.get("unlisted")?,
                 secret: row.get("secret")?,
             })
         })?;

src/app/core/entities.rs

@@ -51,29 +51,30 @@ impl LiwanProjects {
     /// Get a project by ID
     pub fn get(&self, id: &str) -> Result<models::Project> {
         let conn = self.pool.get()?;
-        let project = conn.prepare("select id, display_name, public, secret from projects where id = ?")?.query_row(
-            rusqlite::params![id],
-            |row| {
+        let project = conn
+            .prepare("select id, display_name, public, unlisted, secret from projects where id = ?")?
+            .query_row(rusqlite::params![id], |row| {
                 Ok(models::Project {
                     id: row.get("id")?,
                     display_name: row.get("display_name")?,
                     public: row.get("public")?,
+                    unlisted: row.get("unlisted")?,
                     secret: row.get("secret")?,
                 })
-            },
-        )?;
+            })?;
         Ok(project)
     }
 
     /// Get all projects
     pub fn all(&self) -> Result<Vec<models::Project>> {
         let conn = self.pool.get()?;
-        let mut stmt = conn.prepare("select id, display_name, public, secret from projects")?;
+        let mut stmt = conn.prepare("select id, display_name, public, unlisted, secret from projects")?;
         let projects = stmt.query_map([], |row| {
             Ok(models::Project {
                 id: row.get("id")?,
                 display_name: row.get("display_name")?,
                 public: row.get("public")?,
+                unlisted: row.get("unlisted")?,
                 secret: row.get("secret")?,
             })
         })?;
@@ -89,11 +90,12 @@ impl LiwanProjects {
         let mut conn = self.pool.get()?;
         let tx = conn.transaction()?;
         tx.execute(
-            "insert into projects (id, display_name, public, secret) values (:id, :display_name, :public, :secret)",
+            "insert into projects (id, display_name, public, unlisted, secret) values (:id, :display_name, :public, :unlisted, :secret)",
             rusqlite::named_params! {
                 ":id": project.id,
                 ":display_name": project.display_name,
                 ":public": project.public,
+                ":unlisted": project.unlisted,
                 ":secret": project.secret,
             },
         )?;
@@ -111,11 +113,12 @@ impl LiwanProjects {
     pub fn update(&self, project: &models::Project) -> Result<models::Project> {
         let conn = self.pool.get()?;
         let mut stmt = conn.prepare_cached(
-            "update projects set display_name = :display_name, public = :public, secret = :secret where id = :id",
+            "update projects set display_name = :display_name, public = :public, unlisted = :unlisted, secret = :secret where id = :id",
         )?;
         stmt.execute(rusqlite::named_params! {
             ":display_name": project.display_name,
             ":public": project.public,
+            ":unlisted": project.unlisted,
             ":secret": project.secret,
             ":id": project.id,
         })?;

src/app/core/projects.rs

@@ -199,6 +199,7 @@ impl Liwan {
                     id: project_id.to_string(),
                     display_name: display_name.to_string(),
                     public,
+                    unlisted: false,
                     secret: None,
                 },
                 &[],

src/app/mod.rs

@@ -34,6 +34,7 @@ pub struct Project {
     pub id: String,
     pub display_name: String,
     pub public: bool,
+    pub unlisted: bool,
     pub secret: Option<String>, // currently unused
 }
 

src/app/models.rs

@@ -0,0 +1 @@
+alter table projects add column unlisted boolean not null default false;

src/migrations/app/V3__project_unlisted.sql

@@ -9,43 +9,70 @@ pub fn is_valid_username(name: &str) -> bool {
     name.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') && name.len() <= 64 && name.len() >= 3
 }
 
-pub fn can_access_project(project: &Project, user: Option<&User>) -> bool {
+pub fn can_view_project(project: &Project, user: Option<&User>) -> bool {
     project.public || user.is_some_and(|u| u.role == UserRole::Admin || u.projects.contains(&project.id))
 }
 
+pub fn can_enumerate_project(project: &Project, user: Option<&User>) -> bool {
+    can_view_project(project, user)
+        && (!project.unlisted || user.is_some_and(|u| u.role == UserRole::Admin || u.projects.contains(&project.id)))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::app::models::{Project, User};
 
     #[test]
-    fn test_can_access_project() {
+    fn test_project_visibility() {
         let project = Project {
             id: "public_project".to_string(),
             display_name: "Public Project".to_string(),
             secret: None,
             public: true,
+            unlisted: false,
         };
-        assert!(can_access_project(&project, None), "Public project should be accessible without a user.");
+        assert!(can_view_project(&project, None), "Public project should be accessible without a user.");
+        assert!(can_enumerate_project(&project, None), "Public listed project should be enumerable.");
 
         let user = User { username: "test".to_string(), role: UserRole::User, projects: vec!["other".to_string()] };
-        assert!(can_access_project(&project, Some(&user)), "Public project should be accessible with any user.");
+        assert!(can_view_project(&project, Some(&user)), "Public project should be accessible with any user.");
+
+        let project = Project { unlisted: true, ..project };
+        assert!(can_view_project(&project, None), "Unlisted project should be accessible by direct link.");
+        assert!(!can_enumerate_project(&project, None), "Unlisted project should not be enumerable anonymously.");
+        assert!(
+            !can_enumerate_project(&project, Some(&user)),
+            "Unlisted project should not be enumerable by unrelated users."
+        );
+
+        let assigned_user = User {
+            username: "assigned".to_string(),
+            role: UserRole::User,
+            projects: vec!["public_project".to_string()],
+        };
+        assert!(
+            can_enumerate_project(&project, Some(&assigned_user)),
+            "Assigned users can enumerate unlisted projects."
+        );
 
         let project = Project {
             id: "admin_test_project".to_string(),
             display_name: "Admin Test Project".to_string(),
             secret: None,
             public: false,
+            unlisted: false,
         };
         let admin_user = User { username: "admin".to_string(), role: UserRole::Admin, projects: vec![] };
-        assert!(can_access_project(&project, Some(&admin_user)), "Admin should have access to any project.");
+        assert!(can_view_project(&project, Some(&admin_user)), "Admin should have access to any project.");
 
         let project = Project {
             id: "private_project".to_string(),
             display_name: "Private Project".to_string(),
             secret: None,
             public: false,
+            unlisted: false,
         };
-        assert!(!can_access_project(&project, None), "Private project should not be accessible without a user.");
+        assert!(!can_view_project(&project, None), "Private project should not be accessible without a user.");
     }
 }

src/utils/validate.rs

@@ -19,7 +19,7 @@ use crate::{
         },
         reports::{Dimension, Metric},
     },
-    utils::validate::can_access_project,
+    utils::validate::{can_enumerate_project, can_view_project},
     web::{
         RouterState,
         session::{Auth, MaybeAuth},
@@ -91,6 +91,8 @@ struct UpdateProjectRequest {
 struct UpdateProjectInfo {
     display_name: String,
     public: bool,
+    #[serde(default)]
+    unlisted: bool,
     secret: Option<String>,
 }
 
@@ -104,6 +106,8 @@ struct UpdatePasswordRequest {
 struct CreateProjectRequest {
     display_name: String,
     public: bool,
+    #[serde(default)]
+    unlisted: bool,
     secret: Option<String>,
     entities: Vec<String>,
 }
@@ -115,6 +119,7 @@ pub struct ProjectResponse {
     pub display_name: String,
     pub entities: Vec<ProjectEntity>,
     pub public: bool,
+    pub unlisted: bool,
     pub hidden_metrics: Vec<Metric>,
     pub hidden_dimensions: Vec<Dimension>,
 }
@@ -144,6 +149,7 @@ impl ProjectResponse {
                 .map(|entity| ProjectEntity { id: entity.id, display_name: entity.display_name })
                 .collect(),
             public: project.public,
+            unlisted: project.unlisted,
             hidden_metrics: Metric::all()
                 .iter()
                 .copied()
@@ -172,6 +178,7 @@ struct EntityProject {
     id: String,
     display_name: String,
     public: bool,
+    unlisted: bool,
 }
 
 #[derive(Serialize, Deserialize, JsonSchema, Debug, Clone)]
@@ -343,6 +350,7 @@ async fn project_create_handler(
                 id: project_id,
                 display_name: project.display_name,
                 public: project.public,
+                unlisted: project.unlisted,
                 secret: project.secret,
             },
             project.entities.as_slice(),
@@ -368,6 +376,7 @@ async fn project_update_handler(
                 id: project_id.clone(),
                 display_name: project.display_name,
                 public: project.public,
+                unlisted: project.unlisted,
                 secret: project.secret,
             })
             .http_err("Failed to update project", StatusCode::INTERNAL_SERVER_ERROR)?;
@@ -387,7 +396,7 @@ async fn projects_handler(
     MaybeAuth(user): MaybeAuth,
 ) -> ApiResult<UseApi<impl IntoApiResponse, Json<ProjectsResponse>>> {
     let projects = app.projects.all().http_err("Failed to get projects", StatusCode::INTERNAL_SERVER_ERROR)?;
-    let projects: Vec<Project> = projects.into_iter().filter(|p| can_access_project(p, user.as_ref())).collect();
+    let projects: Vec<Project> = projects.into_iter().filter(|p| can_enumerate_project(p, user.as_ref())).collect();
 
     let mut resp = Vec::new();
     for project in projects {
@@ -405,7 +414,7 @@ async fn project_handler(
     Path(project_id): Path<String>,
 ) -> ApiResult<UseApi<impl IntoApiResponse, Json<ProjectResponse>>> {
     let project = app.projects.get(&project_id).http_status(StatusCode::NOT_FOUND)?;
-    if !can_access_project(&project, user.as_ref()) {
+    if !can_view_project(&project, user.as_ref()) {
         return Err(StatusCode::NOT_FOUND.into());
     }
 
@@ -595,6 +604,7 @@ async fn entities_handler(
                     id: project.id,
                     display_name: project.display_name,
                     public: project.public,
+                    unlisted: project.unlisted,
                 })
                 .collect(),
         });

src/web/routes/admin.rs

@@ -1,5 +1,5 @@
 use crate::app::reports::{self, DateRange, Dimension, DimensionFilter, GraphInterval, Metric, ReportStats};
-use crate::utils::validate::{self, can_access_project};
+use crate::utils::validate::{self, can_view_project};
 use crate::web::RouterState;
 use crate::web::session::MaybeAuth;
 use crate::web::webext::{ApiResult, AxumErrExt, http_bail};
@@ -97,7 +97,7 @@ async fn project_earliest_handler(
 ) -> ApiResult<Json<EarliestResponse>> {
     let project = app.projects.get(&project_id).http_status(StatusCode::NOT_FOUND)?;
 
-    if !can_access_project(&project, user.as_ref()) {
+    if !can_view_project(&project, user.as_ref()) {
         http_bail!(StatusCode::NOT_FOUND, "Project not found")
     }
 
@@ -117,7 +117,7 @@ async fn project_graph_handler(
     let project = app.projects.get(&project_id).http_status(StatusCode::IM_A_TEAPOT)?;
     let entities = app.projects.entity_ids(&project.id).http_status(StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    if !can_access_project(&project, user.as_ref()) {
+    if !can_view_project(&project, user.as_ref()) {
         http_bail!(StatusCode::NOT_FOUND, "Project not found")
     }
 
@@ -150,7 +150,7 @@ async fn project_stats_handler(
     Json(req): Json<StatsRequest>,
 ) -> ApiResult<Json<StatsResponse>> {
     let project = app.projects.get(&project_id).http_status(StatusCode::NOT_FOUND)?;
-    if !can_access_project(&project, user.as_ref()) {
+    if !can_view_project(&project, user.as_ref()) {
         http_bail!(StatusCode::NOT_FOUND, "Project not found")
     }
 
@@ -199,7 +199,7 @@ async fn project_detailed_handler(
     let project = app.projects.get(&project_id).http_status(StatusCode::NOT_FOUND)?;
     let entities = app.projects.entity_ids(&project.id).http_status(StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    if !can_access_project(&project, user.as_ref()) {
+    if !can_view_project(&project, user.as_ref()) {
         http_bail!(StatusCode::NOT_FOUND, "Project not found")
     }