Fix joining hosted projects (#9038)

Release Notes:

- N/A

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

@@ -9,20 +9,21 @@ impl Database {
         roles: &HashMap<ChannelId, ChannelRole>,
         tx: &DatabaseTransaction,
     ) -> Result<Vec<proto::HostedProject>> {
-        Ok(hosted_project::Entity::find()
+        let projects = hosted_project::Entity::find()
+            .find_also_related(project::Entity)
             .filter(hosted_project::Column::ChannelId.is_in(channel_ids.iter().map(|id| id.0)))
             .all(tx)
             .await?
             .into_iter()
-            .flat_map(|project| {
-                if project.deleted_at.is_some() {
+            .flat_map(|(hosted_project, project)| {
+                if hosted_project.deleted_at.is_some() {
                     return None;
                 }
-                match project.visibility {
+                match hosted_project.visibility {
                     ChannelVisibility::Public => {}
                     ChannelVisibility::Members => {
                         let is_visible = roles
-                            .get(&project.channel_id)
+                            .get(&hosted_project.channel_id)
                             .map(|role| role.can_see_all_descendants())
                             .unwrap_or(false);
                         if !is_visible {
@@ -31,13 +32,15 @@ impl Database {
                     }
                 };
                 Some(proto::HostedProject {
-                    id: project.id.to_proto(),
-                    channel_id: project.channel_id.to_proto(),
-                    name: project.name.clone(),
-                    visibility: project.visibility.into(),
+                    project_id: project?.id.to_proto(),
+                    channel_id: hosted_project.channel_id.to_proto(),
+                    name: hosted_project.name.clone(),
+                    visibility: hosted_project.visibility.into(),
                 })
             })
-            .collect())
+            .collect();
+
+        Ok(projects)
     }
 
     pub async fn get_hosted_project(

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

@@ -512,18 +512,30 @@ impl Database {
     /// Adds the given connection to the specified hosted project
     pub async fn join_hosted_project(
         &self,
-        id: HostedProjectId,
+        id: ProjectId,
         user_id: UserId,
         connection: ConnectionId,
     ) -> Result<(Project, ReplicaId)> {
         self.transaction(|tx| async move {
-            let (hosted_project, role) = self.get_hosted_project(id, user_id, &tx).await?;
-            let project = project::Entity::find()
-                .filter(project::Column::HostedProjectId.eq(hosted_project.id))
+            let (project, hosted_project) = project::Entity::find_by_id(id)
+                .find_also_related(hosted_project::Entity)
                 .one(&*tx)
                 .await?
                 .ok_or_else(|| anyhow!("hosted project is no longer shared"))?;
 
+            let Some(hosted_project) = hosted_project else {
+                return Err(anyhow!("project is not hosted"))?;
+            };
+
+            let channel = channel::Entity::find_by_id(hosted_project.channel_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such channel"))?;
+
+            let role = self
+                .check_user_is_channel_participant(&channel, user_id, &tx)
+                .await?;
+
             self.join_project_internal(project, user_id, connection, role, &tx)
                 .await
         })

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

@@ -15,4 +15,13 @@ pub struct Model {
 impl ActiveModelBehavior for ActiveModel {}
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
+pub enum Relation {
+    #[sea_orm(has_one = "super::project::Entity")]
+    Project,
+}
+
+impl Related<super::project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Project.def()
+    }
+}

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

@@ -50,6 +50,12 @@ pub enum Relation {
     Collaborators,
     #[sea_orm(has_many = "super::language_server::Entity")]
     LanguageServers,
+    #[sea_orm(
+        belongs_to = "super::hosted_project::Entity",
+        from = "Column::HostedProjectId",
+        to = "super::hosted_project::Column::Id"
+    )]
+    HostedProject,
 }
 
 impl Related<super::user::Entity> for Entity {
@@ -82,4 +88,10 @@ impl Related<super::language_server::Entity> for Entity {
     }
 }
 
+impl Related<super::hosted_project::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::HostedProject.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/rpc.rs

@@ -4,9 +4,9 @@ use crate::{
     auth::{self, Impersonator},
     db::{
         self, BufferId, ChannelId, ChannelRole, ChannelsForUser, CreatedChannelMessage, Database,
-        HostedProjectId, InviteMemberResult, MembershipUpdated, MessageId, NotificationId, Project,
-        ProjectId, RemoveChannelMemberResult, ReplicaId, RespondToChannelInvite, RoomId, ServerId,
-        User, UserId,
+        InviteMemberResult, MembershipUpdated, MessageId, NotificationId, Project, ProjectId,
+        RemoveChannelMemberResult, ReplicaId, RespondToChannelInvite, RoomId, ServerId, User,
+        UserId,
     },
     executor::Executor,
     AppState, Error, Result,
@@ -1770,7 +1770,7 @@ async fn join_hosted_project(
         .db()
         .await
         .join_hosted_project(
-            HostedProjectId(request.id as i32),
+            ProjectId(request.project_id as i32),
             session.user_id,
             session.connection_id,
         )