remote projects per user (#10594)

Release Notes:

- Made remote projects per-user instead of per-channel. If you'd like to
be part of the remote development alpha, please email hi@zed.dev.

---------

Co-authored-by: Bennet Bo Fenner <53836821+bennetbo@users.noreply.github.com>
Co-authored-by: Bennet <bennetbo@gmx.de>
Co-authored-by: Nate Butler <1714999+iamnbutler@users.noreply.github.com>
Co-authored-by: Nate Butler <iamnbutler@gmail.com>

crates/collab/src/db/queries/channels.rs

@@ -640,15 +640,10 @@ impl Database {
             .get_hosted_projects(&channel_ids, &roles_by_channel_id, tx)
             .await?;
 
-        let dev_servers = self.get_dev_servers(&channel_ids, tx).await?;
-        let remote_projects = self.get_remote_projects(&channel_ids, tx).await?;
-
         Ok(ChannelsForUser {
             channel_memberships,
             channels,
             hosted_projects,
-            dev_servers,
-            remote_projects,
             channel_participants,
             latest_buffer_versions,
             latest_channel_messages,

crates/collab/src/db/queries/dev_servers.rs

@@ -1,6 +1,9 @@
-use sea_orm::{ActiveValue, ColumnTrait, DatabaseTransaction, EntityTrait, QueryFilter};
+use rpc::proto;
+use sea_orm::{
+    ActiveValue, ColumnTrait, DatabaseTransaction, EntityTrait, IntoActiveModel, QueryFilter,
+};
 
-use super::{channel, dev_server, ChannelId, Database, DevServerId, UserId};
+use super::{dev_server, remote_project, Database, DevServerId, UserId};
 
 impl Database {
     pub async fn get_dev_server(
@@ -16,40 +19,105 @@ impl Database {
         .await
     }
 
-    pub async fn get_dev_servers(
+    pub async fn get_dev_servers(&self, user_id: UserId) -> crate::Result<Vec<dev_server::Model>> {
+        self.transaction(|tx| async move {
+            Ok(dev_server::Entity::find()
+                .filter(dev_server::Column::UserId.eq(user_id))
+                .all(&*tx)
+                .await?)
+        })
+        .await
+    }
+
+    pub async fn remote_projects_update(
         &self,
-        channel_ids: &Vec<ChannelId>,
+        user_id: UserId,
+    ) -> crate::Result<proto::RemoteProjectsUpdate> {
+        self.transaction(
+            |tx| async move { self.remote_projects_update_internal(user_id, &tx).await },
+        )
+        .await
+    }
+
+    pub async fn remote_projects_update_internal(
+        &self,
+        user_id: UserId,
         tx: &DatabaseTransaction,
-    ) -> crate::Result<Vec<dev_server::Model>> {
-        let servers = dev_server::Entity::find()
-            .filter(dev_server::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
+    ) -> crate::Result<proto::RemoteProjectsUpdate> {
+        let dev_servers = dev_server::Entity::find()
+            .filter(dev_server::Column::UserId.eq(user_id))
             .all(tx)
             .await?;
-        Ok(servers)
+
+        let remote_projects = remote_project::Entity::find()
+            .filter(
+                remote_project::Column::DevServerId
+                    .is_in(dev_servers.iter().map(|d| d.id).collect::<Vec<_>>()),
+            )
+            .find_also_related(super::project::Entity)
+            .all(tx)
+            .await?;
+
+        Ok(proto::RemoteProjectsUpdate {
+            dev_servers: dev_servers
+                .into_iter()
+                .map(|d| d.to_proto(proto::DevServerStatus::Offline))
+                .collect(),
+            remote_projects: remote_projects
+                .into_iter()
+                .map(|(remote_project, project)| remote_project.to_proto(project))
+                .collect(),
+        })
     }
 
     pub async fn create_dev_server(
         &self,
-        channel_id: ChannelId,
         name: &str,
         hashed_access_token: &str,
         user_id: UserId,
-    ) -> crate::Result<(channel::Model, dev_server::Model)> {
+    ) -> crate::Result<(dev_server::Model, proto::RemoteProjectsUpdate)> {
         self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_admin(&channel, user_id, &tx)
-                .await?;
-
             let dev_server = dev_server::Entity::insert(dev_server::ActiveModel {
                 id: ActiveValue::NotSet,
                 hashed_token: ActiveValue::Set(hashed_access_token.to_string()),
-                channel_id: ActiveValue::Set(channel_id),
                 name: ActiveValue::Set(name.to_string()),
+                user_id: ActiveValue::Set(user_id),
             })
             .exec_with_returning(&*tx)
             .await?;
 
-            Ok((channel, dev_server))
+            let remote_projects = self.remote_projects_update_internal(user_id, &tx).await?;
+
+            Ok((dev_server, remote_projects))
+        })
+        .await
+    }
+
+    pub async fn delete_dev_server(
+        &self,
+        id: DevServerId,
+        user_id: UserId,
+    ) -> crate::Result<proto::RemoteProjectsUpdate> {
+        self.transaction(|tx| async move {
+            let Some(dev_server) = dev_server::Entity::find_by_id(id).one(&*tx).await? else {
+                return Err(anyhow::anyhow!("no dev server with id {}", id))?;
+            };
+            if dev_server.user_id != user_id {
+                return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
+            }
+
+            remote_project::Entity::delete_many()
+                .filter(remote_project::Column::DevServerId.eq(id))
+                .exec(&*tx)
+                .await?;
+
+            dev_server::Entity::delete(dev_server.into_active_model())
+                .exec(&*tx)
+                .await?;
+
+            let remote_projects = self.remote_projects_update_internal(user_id, &tx).await?;
+
+            Ok(remote_projects)
         })
         .await
     }

crates/collab/src/db/queries/projects.rs

@@ -30,6 +30,7 @@ impl Database {
         room_id: RoomId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
+        remote_project_id: Option<RemoteProjectId>,
     ) -> Result<TransactionGuard<(ProjectId, proto::Room)>> {
         self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
@@ -58,6 +59,30 @@ impl Database {
                 return Err(anyhow!("guests cannot share projects"))?;
             }
 
+            if let Some(remote_project_id) = remote_project_id {
+                let project = project::Entity::find()
+                    .filter(project::Column::RemoteProjectId.eq(Some(remote_project_id)))
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("no remote project"))?;
+
+                if project.room_id.is_some() {
+                    return Err(anyhow!("project already shared"))?;
+                };
+
+                let project = project::Entity::update(project::ActiveModel {
+                    room_id: ActiveValue::Set(Some(room_id)),
+                    ..project.into_active_model()
+                })
+                .exec(&*tx)
+                .await?;
+
+                // todo! check user is a project-collaborator
+
+                let room = self.get_room(room_id, &tx).await?;
+                return Ok((project.id, room));
+            }
+
             let project = project::ActiveModel {
                 room_id: ActiveValue::set(Some(participant.room_id)),
                 host_user_id: ActiveValue::set(Some(participant.user_id)),
@@ -111,6 +136,7 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection: ConnectionId,
+        user_id: Option<UserId>,
     ) -> Result<TransactionGuard<(Option<proto::Room>, Vec<ConnectionId>)>> {
         self.project_transaction(project_id, |tx| async move {
             let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
@@ -118,19 +144,37 @@ impl Database {
                 .one(&*tx)
                 .await?
                 .ok_or_else(|| anyhow!("project not found"))?;
+            let room = if let Some(room_id) = project.room_id {
+                Some(self.get_room(room_id, &tx).await?)
+            } else {
+                None
+            };
             if project.host_connection()? == connection {
-                let room = if let Some(room_id) = project.room_id {
-                    Some(self.get_room(room_id, &tx).await?)
-                } else {
-                    None
-                };
                 project::Entity::delete(project.into_active_model())
                     .exec(&*tx)
                     .await?;
-                Ok((room, guest_connection_ids))
-            } else {
-                Err(anyhow!("cannot unshare a project hosted by another user"))?
+                return Ok((room, guest_connection_ids));
             }
+            if let Some(remote_project_id) = project.remote_project_id {
+                if let Some(user_id) = user_id {
+                    if user_id
+                        != self
+                            .owner_for_remote_project(remote_project_id, &tx)
+                            .await?
+                    {
+                        Err(anyhow!("cannot unshare a project hosted by another user"))?
+                    }
+                    project::Entity::update(project::ActiveModel {
+                        room_id: ActiveValue::Set(None),
+                        ..project.into_active_model()
+                    })
+                    .exec(&*tx)
+                    .await?;
+                    return Ok((room, guest_connection_ids));
+                }
+            }
+
+            Err(anyhow!("cannot unshare a project hosted by another user"))?
         })
         .await
     }
@@ -753,6 +797,7 @@ impl Database {
                     name: language_server.name,
                 })
                 .collect(),
+            remote_project_id: project.remote_project_id,
         };
         Ok((project, replica_id as ReplicaId))
     }
@@ -794,8 +839,7 @@ impl Database {
             Ok(LeftProject {
                 id: project.id,
                 connection_ids,
-                host_user_id: None,
-                host_connection_id: None,
+                should_unshare: false,
             })
         })
         .await
@@ -832,7 +876,7 @@ impl Database {
                 .find_related(project_collaborator::Entity)
                 .all(&*tx)
                 .await?;
-            let connection_ids = collaborators
+            let connection_ids: Vec<ConnectionId> = collaborators
                 .into_iter()
                 .map(|collaborator| collaborator.connection())
                 .collect();
@@ -870,8 +914,7 @@ impl Database {
 
             let left_project = LeftProject {
                 id: project_id,
-                host_user_id: project.host_user_id,
-                host_connection_id: Some(project.host_connection()?),
+                should_unshare: connection == project.host_connection()?,
                 connection_ids,
             };
             Ok((room, left_project))
@@ -914,7 +957,7 @@ impl Database {
         capability: Capability,
         tx: &DatabaseTransaction,
     ) -> Result<(project::Model, ChannelRole)> {
-        let (project, remote_project) = project::Entity::find_by_id(project_id)
+        let (mut project, remote_project) = project::Entity::find_by_id(project_id)
             .find_also_related(remote_project::Entity)
             .one(tx)
             .await?
@@ -933,27 +976,44 @@ impl Database {
             PrincipalId::UserId(user_id) => user_id,
         };
 
-        let role = if let Some(remote_project) = remote_project {
-            let channel = channel::Entity::find_by_id(remote_project.channel_id)
-                .one(tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such channel"))?;
-
-            self.check_user_is_channel_participant(&channel, user_id, &tx)
-                .await?
-        } else if let Some(room_id) = project.room_id {
-            // what's the users role?
-            let current_participant = room_participant::Entity::find()
+        let role_from_room = if let Some(room_id) = project.room_id {
+            room_participant::Entity::find()
                 .filter(room_participant::Column::RoomId.eq(room_id))
                 .filter(room_participant::Column::AnsweringConnectionId.eq(connection_id.id))
                 .one(tx)
                 .await?
-                .ok_or_else(|| anyhow!("no such room"))?;
-
-            current_participant.role.unwrap_or(ChannelRole::Guest)
+                .and_then(|participant| participant.role)
         } else {
-            return Err(anyhow!("not authorized to read projects"))?;
+            None
         };
+        let role_from_remote_project = if let Some(remote_project) = remote_project {
+            let dev_server = dev_server::Entity::find_by_id(remote_project.dev_server_id)
+                .one(tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such channel"))?;
+            if user_id == dev_server.user_id {
+                // If the user left the room "uncleanly" they may rejoin the
+                // remote project before leave_room runs. IN that case kick
+                // the project out of the room pre-emptively.
+                if role_from_room.is_none() {
+                    project = project::Entity::update(project::ActiveModel {
+                        room_id: ActiveValue::Set(None),
+                        ..project.into_active_model()
+                    })
+                    .exec(tx)
+                    .await?;
+                }
+                Some(ChannelRole::Admin)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        let role = role_from_remote_project
+            .or(role_from_room)
+            .unwrap_or(ChannelRole::Banned);
 
         match capability {
             Capability::ReadWrite => {

crates/collab/src/db/queries/remote_projects.rs

@@ -8,8 +8,8 @@ use sea_orm::{
 use crate::db::ProjectId;
 
 use super::{
-    channel, project, project_collaborator, remote_project, worktree, ChannelId, Database,
-    DevServerId, RejoinedProject, RemoteProjectId, ResharedProject, ServerId, UserId,
+    dev_server, project, project_collaborator, remote_project, worktree, Database, DevServerId,
+    RejoinedProject, RemoteProjectId, ResharedProject, ServerId, UserId,
 };
 
 impl Database {
@@ -26,29 +26,6 @@ impl Database {
         .await
     }
 
-    pub async fn get_remote_projects(
-        &self,
-        channel_ids: &Vec<ChannelId>,
-        tx: &DatabaseTransaction,
-    ) -> crate::Result<Vec<proto::RemoteProject>> {
-        let servers = remote_project::Entity::find()
-            .filter(remote_project::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
-            .find_also_related(project::Entity)
-            .all(tx)
-            .await?;
-        Ok(servers
-            .into_iter()
-            .map(|(remote_project, project)| proto::RemoteProject {
-                id: remote_project.id.to_proto(),
-                project_id: project.map(|p| p.id.to_proto()),
-                channel_id: remote_project.channel_id.to_proto(),
-                name: remote_project.name,
-                dev_server_id: remote_project.dev_server_id.to_proto(),
-                path: remote_project.path,
-            })
-            .collect())
-    }
-
     pub async fn get_remote_projects_for_dev_server(
         &self,
         dev_server_id: DevServerId,
@@ -64,8 +41,6 @@ impl Database {
                 .map(|(remote_project, project)| proto::RemoteProject {
                     id: remote_project.id.to_proto(),
                     project_id: project.map(|p| p.id.to_proto()),
-                    channel_id: remote_project.channel_id.to_proto(),
-                    name: remote_project.name,
                     dev_server_id: remote_project.dev_server_id.to_proto(),
                     path: remote_project.path,
                 })
@@ -74,6 +49,38 @@ impl Database {
         .await
     }
 
+    pub async fn remote_project_ids_for_user(
+        &self,
+        user_id: UserId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<RemoteProjectId>> {
+        let dev_servers = dev_server::Entity::find()
+            .filter(dev_server::Column::UserId.eq(user_id))
+            .find_with_related(remote_project::Entity)
+            .all(tx)
+            .await?;
+
+        Ok(dev_servers
+            .into_iter()
+            .flat_map(|(_, projects)| projects.into_iter().map(|p| p.id))
+            .collect())
+    }
+
+    pub async fn owner_for_remote_project(
+        &self,
+        remote_project_id: RemoteProjectId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<UserId> {
+        let dev_server = remote_project::Entity::find_by_id(remote_project_id)
+            .find_also_related(dev_server::Entity)
+            .one(tx)
+            .await?
+            .and_then(|(_, dev_server)| dev_server)
+            .ok_or_else(|| anyhow!("no remote project"))?;
+
+        Ok(dev_server.user_id)
+    }
+
     pub async fn get_stale_dev_server_projects(
         &self,
         connection: ConnectionId,
@@ -95,28 +102,30 @@ impl Database {
 
     pub async fn create_remote_project(
         &self,
-        channel_id: ChannelId,
         dev_server_id: DevServerId,
-        name: &str,
         path: &str,
         user_id: UserId,
-    ) -> crate::Result<(channel::Model, remote_project::Model)> {
+    ) -> crate::Result<(remote_project::Model, proto::RemoteProjectsUpdate)> {
         self.transaction(|tx| async move {
-            let channel = self.get_channel_internal(channel_id, &tx).await?;
-            self.check_user_is_channel_admin(&channel, user_id, &tx)
-                .await?;
+            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;
+            if dev_server.user_id != user_id {
+                return Err(anyhow!("not your dev server"))?;
+            }
 
             let project = remote_project::Entity::insert(remote_project::ActiveModel {
-                name: ActiveValue::Set(name.to_string()),
                 id: ActiveValue::NotSet,
-                channel_id: ActiveValue::Set(channel_id),
                 dev_server_id: ActiveValue::Set(dev_server_id),
                 path: ActiveValue::Set(path.to_string()),
             })
             .exec_with_returning(&*tx)
             .await?;
 
-            Ok((channel, project))
+            let status = self.remote_projects_update_internal(user_id, &tx).await?;
+
+            Ok((project, status))
         })
         .await
     }
@@ -127,8 +136,13 @@ impl Database {
         dev_server_id: DevServerId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
-    ) -> crate::Result<proto::RemoteProject> {
+    ) -> crate::Result<(proto::RemoteProject, UserId, proto::RemoteProjectsUpdate)> {
         self.transaction(|tx| async move {
+            let dev_server = dev_server::Entity::find_by_id(dev_server_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no dev server with id {}", dev_server_id))?;
+
             let remote_project = remote_project::Entity::find_by_id(remote_project_id)
                 .one(&*tx)
                 .await?
@@ -168,7 +182,15 @@ impl Database {
                 .await?;
             }
 
-            Ok(remote_project.to_proto(Some(project)))
+            let status = self
+                .remote_projects_update_internal(dev_server.user_id, &tx)
+                .await?;
+
+            Ok((
+                remote_project.to_proto(Some(project)),
+                dev_server.user_id,
+                status,
+            ))
         })
         .await
     }

crates/collab/src/db/queries/rooms.rs

@@ -849,11 +849,32 @@ impl Database {
                     .into_values::<_, QueryProjectIds>()
                     .all(&*tx)
                     .await?;
+
+                // if any project in the room has a remote-project-id that belongs to a dev server that this user owns.
+                let remote_projects_for_user = self
+                    .remote_project_ids_for_user(leaving_participant.user_id, &tx)
+                    .await?;
+
+                let remote_projects_to_unshare = project::Entity::find()
+                    .filter(
+                        Condition::all()
+                            .add(project::Column::RoomId.eq(room_id))
+                            .add(
+                                project::Column::RemoteProjectId
+                                    .is_in(remote_projects_for_user.clone()),
+                            ),
+                    )
+                    .all(&*tx)
+                    .await?
+                    .into_iter()
+                    .map(|project| project.id)
+                    .collect::<HashSet<_>>();
                 let mut left_projects = HashMap::default();
                 let mut collaborators = project_collaborator::Entity::find()
                     .filter(project_collaborator::Column::ProjectId.is_in(project_ids))
                     .stream(&*tx)
                     .await?;
+
                 while let Some(collaborator) = collaborators.next().await {
                     let collaborator = collaborator?;
                     let left_project =
@@ -861,9 +882,8 @@ impl Database {
                             .entry(collaborator.project_id)
                             .or_insert(LeftProject {
                                 id: collaborator.project_id,
-                                host_user_id: Default::default(),
                                 connection_ids: Default::default(),
-                                host_connection_id: None,
+                                should_unshare: false,
                             });
 
                     let collaborator_connection_id = collaborator.connection();
@@ -871,9 +891,10 @@ impl Database {
                         left_project.connection_ids.push(collaborator_connection_id);
                     }
 
-                    if collaborator.is_host {
-                        left_project.host_user_id = Some(collaborator.user_id);
-                        left_project.host_connection_id = Some(collaborator_connection_id);
+                    if (collaborator.is_host && collaborator.connection() == connection)
+                        || remote_projects_to_unshare.contains(&collaborator.project_id)
+                    {
+                        left_project.should_unshare = true;
                     }
                 }
                 drop(collaborators);
@@ -915,6 +936,17 @@ impl Database {
                     .exec(&*tx)
                     .await?;
 
+                if !remote_projects_to_unshare.is_empty() {
+                    project::Entity::update_many()
+                        .filter(project::Column::Id.is_in(remote_projects_to_unshare))
+                        .set(project::ActiveModel {
+                            room_id: ActiveValue::Set(None),
+                            ..Default::default()
+                        })
+                        .exec(&*tx)
+                        .await?;
+                }
+
                 let (channel, room) = self.get_channel_room(room_id, &tx).await?;
                 let deleted = if room.participants.is_empty() {
                     let result = room::Entity::delete_by_id(room_id).exec(&*tx).await?;
@@ -1264,38 +1296,46 @@ impl Database {
         }
         drop(db_participants);
 
-        let mut db_projects = db_room
+        let db_projects = db_room
             .find_related(project::Entity)
             .find_with_related(worktree::Entity)
-            .stream(tx)
+            .all(tx)
             .await?;
 
-        while let Some(row) = db_projects.next().await {
-            let (db_project, db_worktree) = row?;
+        for (db_project, db_worktrees) in db_projects {
             let host_connection = db_project.host_connection()?;
             if let Some(participant) = participants.get_mut(&host_connection) {
-                let project = if let Some(project) = participant
-                    .projects
-                    .iter_mut()
-                    .find(|project| project.id == db_project.id.to_proto())
-                {
-                    project
-                } else {
-                    participant.projects.push(proto::ParticipantProject {
-                        id: db_project.id.to_proto(),
-                        worktree_root_names: Default::default(),
-                    });
-                    participant.projects.last_mut().unwrap()
-                };
+                participant.projects.push(proto::ParticipantProject {
+                    id: db_project.id.to_proto(),
+                    worktree_root_names: Default::default(),
+                });
+                let project = participant.projects.last_mut().unwrap();
 
-                if let Some(db_worktree) = db_worktree {
+                for db_worktree in db_worktrees {
                     if db_worktree.visible {
                         project.worktree_root_names.push(db_worktree.root_name);
                     }
                 }
+            } else if let Some(remote_project_id) = db_project.remote_project_id {
+                let host = self.owner_for_remote_project(remote_project_id, tx).await?;
+                if let Some((_, participant)) = participants
+                    .iter_mut()
+                    .find(|(_, v)| v.user_id == host.to_proto())
+                {
+                    participant.projects.push(proto::ParticipantProject {
+                        id: db_project.id.to_proto(),
+                        worktree_root_names: Default::default(),
+                    });
+                    let project = participant.projects.last_mut().unwrap();
+
+                    for db_worktree in db_worktrees {
+                        if db_worktree.visible {
+                            project.worktree_root_names.push(db_worktree.root_name);
+                        }
+                    }
+                }
             }
         }
-        drop(db_projects);
 
         let mut db_followers = db_room.find_related(follower::Entity).stream(tx).await?;
         let mut followers = Vec::new();

crates/collab/src/db/tables/dev_server.rs

@@ -1,4 +1,4 @@
-use crate::db::{ChannelId, DevServerId};
+use crate::db::{DevServerId, UserId};
 use rpc::proto;
 use sea_orm::entity::prelude::*;
 
@@ -8,20 +8,28 @@ pub struct Model {
     #[sea_orm(primary_key)]
     pub id: DevServerId,
     pub name: String,
-    pub channel_id: ChannelId,
+    pub user_id: UserId,
     pub hashed_token: String,
 }
 
 impl ActiveModelBehavior for ActiveModel {}
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+pub enum Relation {
+    #[sea_orm(has_many = "super::remote_project::Entity")]
+    RemoteProject,
+}
+
+impl Related<super::remote_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::RemoteProject.def()
+    }
+}
 
 impl Model {
     pub fn to_proto(&self, status: proto::DevServerStatus) -> proto::DevServer {
         proto::DevServer {
             dev_server_id: self.id.to_proto(),
-            channel_id: self.channel_id.to_proto(),
             name: self.name.clone(),
             status: status as i32,
         }

crates/collab/src/db/tables/remote_project.rs

@@ -1,5 +1,5 @@
 use super::project;
-use crate::db::{ChannelId, DevServerId, RemoteProjectId};
+use crate::db::{DevServerId, RemoteProjectId};
 use rpc::proto;
 use sea_orm::entity::prelude::*;
 
@@ -8,9 +8,7 @@ use sea_orm::entity::prelude::*;
 pub struct Model {
     #[sea_orm(primary_key)]
     pub id: RemoteProjectId,
-    pub channel_id: ChannelId,
     pub dev_server_id: DevServerId,
-    pub name: String,
     pub path: String,
 }
 
@@ -20,6 +18,12 @@ impl ActiveModelBehavior for ActiveModel {}
 pub enum Relation {
     #[sea_orm(has_one = "super::project::Entity")]
     Project,
+    #[sea_orm(
+        belongs_to = "super::dev_server::Entity",
+        from = "Column::DevServerId",
+        to = "super::dev_server::Column::Id"
+    )]
+    DevServer,
 }
 
 impl Related<super::project::Entity> for Entity {
@@ -28,14 +32,18 @@ impl Related<super::project::Entity> for Entity {
     }
 }
 
+impl Related<super::dev_server::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::DevServer.def()
+    }
+}
+
 impl Model {
     pub fn to_proto(&self, project: Option<project::Model>) -> proto::RemoteProject {
         proto::RemoteProject {
             id: self.id.to_proto(),
             project_id: project.map(|p| p.id.to_proto()),
-            channel_id: self.channel_id.to_proto(),
             dev_server_id: self.dev_server_id.to_proto(),
-            name: self.name.clone(),
             path: self.path.clone(),
         }
     }

crates/collab/src/db/tests/db_tests.rs

@@ -535,18 +535,18 @@ async fn test_project_count(db: &Arc<Database>) {
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
 
-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 1);
 
-    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
+    db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[], None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
 
     // Projects shared by admins aren't counted.
-    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[])
+    db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[], None)
         .await
         .unwrap();
     assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);