Rename RemoteProject -> DevServerProject (#11301)

Co-Authored-By: Mikayla <mikayla@zed.dev>

In a fit of ill-advisedness I called these things remote projects;
forgetting that remote project is also what we call collaboratively
shared projects.

Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
Co-authored-by: Bennet <bennetbo@gmx.de>

crates/collab/src/db/ids.rs

@@ -84,7 +84,7 @@ id_type!(NotificationId);
 id_type!(NotificationKindId);
 id_type!(ProjectCollaboratorId);
 id_type!(ProjectId);
-id_type!(RemoteProjectId);
+id_type!(DevServerProjectId);
 id_type!(ReplicaId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);

crates/collab/src/db/queries.rs

@@ -5,6 +5,7 @@ pub mod buffers;
 pub mod channels;
 pub mod contacts;
 pub mod contributors;
+pub mod dev_server_projects;
 pub mod dev_servers;
 pub mod embeddings;
 pub mod extensions;
@@ -13,7 +14,6 @@ pub mod messages;
 pub mod notifications;
 pub mod projects;
 pub mod rate_buckets;
-pub mod remote_projects;
 pub mod rooms;
 pub mod servers;
 pub mod users;

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

@@ -0,0 +1,295 @@
+use anyhow::anyhow;
+use rpc::{proto, ConnectionId};
+use sea_orm::{
+    ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
+    ModelTrait, QueryFilter,
+};
+
+use crate::db::ProjectId;
+
+use super::{
+    dev_server, dev_server_project, project, project_collaborator, worktree, Database, DevServerId,
+    DevServerProjectId, RejoinedProject, ResharedProject, ServerId, UserId,
+};
+
+impl Database {
+    pub async fn get_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+    ) -> crate::Result<dev_server_project::Model> {
+        self.transaction(|tx| async move {
+            Ok(
+                dev_server_project::Entity::find_by_id(dev_server_project_id)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| {
+                        anyhow!("no dev server project with id {}", dev_server_project_id)
+                    })?,
+            )
+        })
+        .await
+    }
+
+    pub async fn get_projects_for_dev_server(
+        &self,
+        dev_server_id: DevServerId,
+    ) -> crate::Result<Vec<proto::DevServerProject>> {
+        self.transaction(|tx| async move {
+            let servers = dev_server_project::Entity::find()
+                .filter(dev_server_project::Column::DevServerId.eq(dev_server_id))
+                .find_also_related(project::Entity)
+                .all(&*tx)
+                .await?;
+            Ok(servers
+                .into_iter()
+                .map(|(dev_server_project, project)| proto::DevServerProject {
+                    id: dev_server_project.id.to_proto(),
+                    project_id: project.map(|p| p.id.to_proto()),
+                    dev_server_id: dev_server_project.dev_server_id.to_proto(),
+                    path: dev_server_project.path,
+                })
+                .collect())
+        })
+        .await
+    }
+
+    pub async fn dev_server_project_ids_for_user(
+        &self,
+        user_id: UserId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<Vec<DevServerProjectId>> {
+        let dev_servers = dev_server::Entity::find()
+            .filter(dev_server::Column::UserId.eq(user_id))
+            .find_with_related(dev_server_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_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+        tx: &DatabaseTransaction,
+    ) -> crate::Result<UserId> {
+        let dev_server = dev_server_project::Entity::find_by_id(dev_server_project_id)
+            .find_also_related(dev_server::Entity)
+            .one(tx)
+            .await?
+            .and_then(|(_, dev_server)| dev_server)
+            .ok_or_else(|| anyhow!("no dev server project"))?;
+
+        Ok(dev_server.user_id)
+    }
+
+    pub async fn get_stale_dev_server_projects(
+        &self,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ProjectId>> {
+        self.transaction(|tx| async move {
+            let projects = project::Entity::find()
+                .filter(
+                    Condition::all()
+                        .add(project::Column::HostConnectionId.eq(connection.id))
+                        .add(project::Column::HostConnectionServerId.eq(connection.owner_id)),
+                )
+                .all(&*tx)
+                .await?;
+
+            Ok(projects.into_iter().map(|p| p.id).collect())
+        })
+        .await
+    }
+
+    pub async fn create_dev_server_project(
+        &self,
+        dev_server_id: DevServerId,
+        path: &str,
+        user_id: UserId,
+    ) -> crate::Result<(dev_server_project::Model, proto::DevServerProjectsUpdate)> {
+        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))?;
+            if dev_server.user_id != user_id {
+                return Err(anyhow!("not your dev server"))?;
+            }
+
+            let project = dev_server_project::Entity::insert(dev_server_project::ActiveModel {
+                id: ActiveValue::NotSet,
+                dev_server_id: ActiveValue::Set(dev_server_id),
+                path: ActiveValue::Set(path.to_string()),
+            })
+            .exec_with_returning(&*tx)
+            .await?;
+
+            let status = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
+
+            Ok((project, status))
+        })
+        .await
+    }
+
+    pub async fn share_dev_server_project(
+        &self,
+        dev_server_project_id: DevServerProjectId,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+        worktrees: &[proto::WorktreeMetadata],
+    ) -> crate::Result<(
+        proto::DevServerProject,
+        UserId,
+        proto::DevServerProjectsUpdate,
+    )> {
+        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 dev_server_project = dev_server_project::Entity::find_by_id(dev_server_project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| {
+                    anyhow!("no dev server project with id {}", dev_server_project_id)
+                })?;
+
+            if dev_server_project.dev_server_id != dev_server_id {
+                return Err(anyhow!("dev server project shared from wrong server"))?;
+            }
+
+            let project = project::ActiveModel {
+                room_id: ActiveValue::Set(None),
+                host_user_id: ActiveValue::Set(None),
+                host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                host_connection_server_id: ActiveValue::set(Some(ServerId(
+                    connection.owner_id as i32,
+                ))),
+                id: ActiveValue::NotSet,
+                hosted_project_id: ActiveValue::Set(None),
+                dev_server_project_id: ActiveValue::Set(Some(dev_server_project_id)),
+            }
+            .insert(&*tx)
+            .await?;
+
+            if !worktrees.is_empty() {
+                worktree::Entity::insert_many(worktrees.iter().map(|worktree| {
+                    worktree::ActiveModel {
+                        id: ActiveValue::set(worktree.id as i64),
+                        project_id: ActiveValue::set(project.id),
+                        abs_path: ActiveValue::set(worktree.abs_path.clone()),
+                        root_name: ActiveValue::set(worktree.root_name.clone()),
+                        visible: ActiveValue::set(worktree.visible),
+                        scan_id: ActiveValue::set(0),
+                        completed_scan_id: ActiveValue::set(0),
+                    }
+                }))
+                .exec(&*tx)
+                .await?;
+            }
+
+            let status = self
+                .dev_server_projects_update_internal(dev_server.user_id, &tx)
+                .await?;
+
+            Ok((
+                dev_server_project.to_proto(Some(project)),
+                dev_server.user_id,
+                status,
+            ))
+        })
+        .await
+    }
+
+    pub async fn reshare_dev_server_projects(
+        &self,
+        reshared_projects: &Vec<proto::UpdateProject>,
+        dev_server_id: DevServerId,
+        connection: ConnectionId,
+    ) -> crate::Result<Vec<ResharedProject>> {
+        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for reshared_project in reshared_projects {
+                let project_id = ProjectId::from_proto(reshared_project.project_id);
+                let (project, dev_server_project) = project::Entity::find_by_id(project_id)
+                    .find_also_related(dev_server_project::Entity)
+                    .one(&*tx)
+                    .await?
+                    .ok_or_else(|| anyhow!("project does not exist"))?;
+
+                if dev_server_project.map(|rp| rp.dev_server_id) != Some(dev_server_id) {
+                    return Err(anyhow!("dev server project reshared from wrong server"))?;
+                }
+
+                let Ok(old_connection_id) = project.host_connection() else {
+                    return Err(anyhow!("dev server project was not shared"))?;
+                };
+
+                project::Entity::update(project::ActiveModel {
+                    id: ActiveValue::set(project_id),
+                    host_connection_id: ActiveValue::set(Some(connection.id as i32)),
+                    host_connection_server_id: ActiveValue::set(Some(ServerId(
+                        connection.owner_id as i32,
+                    ))),
+                    ..Default::default()
+                })
+                .exec(&*tx)
+                .await?;
+
+                let collaborators = project
+                    .find_related(project_collaborator::Entity)
+                    .all(&*tx)
+                    .await?;
+
+                self.update_project_worktrees(project_id, &reshared_project.worktrees, &tx)
+                    .await?;
+
+                ret.push(super::ResharedProject {
+                    id: project_id,
+                    old_connection_id,
+                    collaborators: collaborators
+                        .iter()
+                        .map(|collaborator| super::ProjectCollaborator {
+                            connection_id: collaborator.connection(),
+                            user_id: collaborator.user_id,
+                            replica_id: collaborator.replica_id,
+                            is_host: collaborator.is_host,
+                        })
+                        .collect(),
+                    worktrees: reshared_project.worktrees.clone(),
+                });
+            }
+            Ok(ret)
+        })
+        .await
+    }
+
+    pub async fn rejoin_dev_server_projects(
+        &self,
+        rejoined_projects: &Vec<proto::RejoinProject>,
+        user_id: UserId,
+        connection_id: ConnectionId,
+    ) -> crate::Result<Vec<RejoinedProject>> {
+        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
+        self.transaction(|tx| async move {
+            let mut ret = Vec::new();
+            for rejoined_project in rejoined_projects {
+                if let Some(project) = self
+                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection_id)
+                    .await?
+                {
+                    ret.push(project);
+                }
+            }
+            Ok(ret)
+        })
+        .await
+    }
+}

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

@@ -3,7 +3,7 @@ use sea_orm::{
     ActiveValue, ColumnTrait, DatabaseTransaction, EntityTrait, IntoActiveModel, QueryFilter,
 };
 
-use super::{dev_server, remote_project, Database, DevServerId, UserId};
+use super::{dev_server, dev_server_project, Database, DevServerId, UserId};
 
 impl Database {
     pub async fn get_dev_server(
@@ -29,43 +29,43 @@ impl Database {
         .await
     }
 
-    pub async fn remote_projects_update(
+    pub async fn dev_server_projects_update(
         &self,
         user_id: UserId,
-    ) -> crate::Result<proto::RemoteProjectsUpdate> {
-        self.transaction(
-            |tx| async move { self.remote_projects_update_internal(user_id, &tx).await },
-        )
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
+        self.transaction(|tx| async move {
+            self.dev_server_projects_update_internal(user_id, &tx).await
+        })
         .await
     }
 
-    pub async fn remote_projects_update_internal(
+    pub async fn dev_server_projects_update_internal(
         &self,
         user_id: UserId,
         tx: &DatabaseTransaction,
-    ) -> crate::Result<proto::RemoteProjectsUpdate> {
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
         let dev_servers = dev_server::Entity::find()
             .filter(dev_server::Column::UserId.eq(user_id))
             .all(tx)
             .await?;
 
-        let remote_projects = remote_project::Entity::find()
+        let dev_server_projects = dev_server_project::Entity::find()
             .filter(
-                remote_project::Column::DevServerId
+                dev_server_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 {
+        Ok(proto::DevServerProjectsUpdate {
             dev_servers: dev_servers
                 .into_iter()
                 .map(|d| d.to_proto(proto::DevServerStatus::Offline))
                 .collect(),
-            remote_projects: remote_projects
+            dev_server_projects: dev_server_projects
                 .into_iter()
-                .map(|(remote_project, project)| remote_project.to_proto(project))
+                .map(|(dev_server_project, project)| dev_server_project.to_proto(project))
                 .collect(),
         })
     }
@@ -75,7 +75,7 @@ impl Database {
         name: &str,
         hashed_access_token: &str,
         user_id: UserId,
-    ) -> crate::Result<(dev_server::Model, proto::RemoteProjectsUpdate)> {
+    ) -> crate::Result<(dev_server::Model, proto::DevServerProjectsUpdate)> {
         self.transaction(|tx| async move {
             let dev_server = dev_server::Entity::insert(dev_server::ActiveModel {
                 id: ActiveValue::NotSet,
@@ -86,9 +86,11 @@ impl Database {
             .exec_with_returning(&*tx)
             .await?;
 
-            let remote_projects = self.remote_projects_update_internal(user_id, &tx).await?;
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
 
-            Ok((dev_server, remote_projects))
+            Ok((dev_server, dev_server_projects))
         })
         .await
     }
@@ -97,7 +99,7 @@ impl Database {
         &self,
         id: DevServerId,
         user_id: UserId,
-    ) -> crate::Result<proto::RemoteProjectsUpdate> {
+    ) -> crate::Result<proto::DevServerProjectsUpdate> {
         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))?;
@@ -106,8 +108,8 @@ impl Database {
                 return Err(anyhow::anyhow!(proto::ErrorCode::Forbidden))?;
             }
 
-            remote_project::Entity::delete_many()
-                .filter(remote_project::Column::DevServerId.eq(id))
+            dev_server_project::Entity::delete_many()
+                .filter(dev_server_project::Column::DevServerId.eq(id))
                 .exec(&*tx)
                 .await?;
 
@@ -115,9 +117,11 @@ impl Database {
                 .exec(&*tx)
                 .await?;
 
-            let remote_projects = self.remote_projects_update_internal(user_id, &tx).await?;
+            let dev_server_projects = self
+                .dev_server_projects_update_internal(user_id, &tx)
+                .await?;
 
-            Ok(remote_projects)
+            Ok(dev_server_projects)
         })
         .await
     }

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

@@ -30,7 +30,7 @@ impl Database {
         room_id: RoomId,
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
-        remote_project_id: Option<RemoteProjectId>,
+        dev_server_project_id: Option<DevServerProjectId>,
     ) -> Result<TransactionGuard<(ProjectId, proto::Room)>> {
         self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
@@ -59,9 +59,9 @@ impl Database {
                 return Err(anyhow!("guests cannot share projects"))?;
             }
 
-            if let Some(remote_project_id) = remote_project_id {
+            if let Some(dev_server_project_id) = dev_server_project_id {
                 let project = project::Entity::find()
-                    .filter(project::Column::RemoteProjectId.eq(Some(remote_project_id)))
+                    .filter(project::Column::DevServerProjectId.eq(Some(dev_server_project_id)))
                     .one(&*tx)
                     .await?
                     .ok_or_else(|| anyhow!("no remote project"))?;
@@ -92,7 +92,7 @@ impl Database {
                 ))),
                 id: ActiveValue::NotSet,
                 hosted_project_id: ActiveValue::Set(None),
-                remote_project_id: ActiveValue::Set(None),
+                dev_server_project_id: ActiveValue::Set(None),
             }
             .insert(&*tx)
             .await?;
@@ -155,11 +155,11 @@ impl Database {
                     .await?;
                 return Ok((room, guest_connection_ids));
             }
-            if let Some(remote_project_id) = project.remote_project_id {
+            if let Some(dev_server_project_id) = project.dev_server_project_id {
                 if let Some(user_id) = user_id {
                     if user_id
                         != self
-                            .owner_for_remote_project(remote_project_id, &tx)
+                            .owner_for_dev_server_project(dev_server_project_id, &tx)
                             .await?
                     {
                         Err(anyhow!("cannot unshare a project hosted by another user"))?
@@ -797,7 +797,7 @@ impl Database {
                     name: language_server.name,
                 })
                 .collect(),
-            remote_project_id: project.remote_project_id,
+            dev_server_project_id: project.dev_server_project_id,
         };
         Ok((project, replica_id as ReplicaId))
     }
@@ -957,8 +957,8 @@ impl Database {
         capability: Capability,
         tx: &DatabaseTransaction,
     ) -> Result<(project::Model, ChannelRole)> {
-        let (mut project, remote_project) = project::Entity::find_by_id(project_id)
-            .find_also_related(remote_project::Entity)
+        let (mut project, dev_server_project) = project::Entity::find_by_id(project_id)
+            .find_also_related(dev_server_project::Entity)
             .one(tx)
             .await?
             .ok_or_else(|| anyhow!("no such project"))?;
@@ -986,8 +986,8 @@ impl Database {
         } else {
             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)
+        let role_from_dev_server = if let Some(dev_server_project) = dev_server_project {
+            let dev_server = dev_server::Entity::find_by_id(dev_server_project.dev_server_id)
                 .one(tx)
                 .await?
                 .ok_or_else(|| anyhow!("no such channel"))?;
@@ -1011,7 +1011,7 @@ impl Database {
             None
         };
 
-        let role = role_from_remote_project
+        let role = role_from_dev_server
             .or(role_from_room)
             .unwrap_or(ChannelRole::Banned);
 

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

@@ -1,283 +1 @@
-use anyhow::anyhow;
-use rpc::{proto, ConnectionId};
-use sea_orm::{
-    ActiveModelTrait, ActiveValue, ColumnTrait, Condition, DatabaseTransaction, EntityTrait,
-    ModelTrait, QueryFilter,
-};
 
-use crate::db::ProjectId;
-
-use super::{
-    dev_server, project, project_collaborator, remote_project, worktree, Database, DevServerId,
-    RejoinedProject, RemoteProjectId, ResharedProject, ServerId, UserId,
-};
-
-impl Database {
-    pub async fn get_remote_project(
-        &self,
-        remote_project_id: RemoteProjectId,
-    ) -> crate::Result<remote_project::Model> {
-        self.transaction(|tx| async move {
-            Ok(remote_project::Entity::find_by_id(remote_project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no remote project with id {}", remote_project_id))?)
-        })
-        .await
-    }
-
-    pub async fn get_remote_projects_for_dev_server(
-        &self,
-        dev_server_id: DevServerId,
-    ) -> crate::Result<Vec<proto::RemoteProject>> {
-        self.transaction(|tx| async move {
-            let servers = remote_project::Entity::find()
-                .filter(remote_project::Column::DevServerId.eq(dev_server_id))
-                .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()),
-                    dev_server_id: remote_project.dev_server_id.to_proto(),
-                    path: remote_project.path,
-                })
-                .collect())
-        })
-        .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,
-    ) -> crate::Result<Vec<ProjectId>> {
-        self.transaction(|tx| async move {
-            let projects = project::Entity::find()
-                .filter(
-                    Condition::all()
-                        .add(project::Column::HostConnectionId.eq(connection.id))
-                        .add(project::Column::HostConnectionServerId.eq(connection.owner_id)),
-                )
-                .all(&*tx)
-                .await?;
-
-            Ok(projects.into_iter().map(|p| p.id).collect())
-        })
-        .await
-    }
-
-    pub async fn create_remote_project(
-        &self,
-        dev_server_id: DevServerId,
-        path: &str,
-        user_id: UserId,
-    ) -> crate::Result<(remote_project::Model, 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))?;
-            if dev_server.user_id != user_id {
-                return Err(anyhow!("not your dev server"))?;
-            }
-
-            let project = remote_project::Entity::insert(remote_project::ActiveModel {
-                id: ActiveValue::NotSet,
-                dev_server_id: ActiveValue::Set(dev_server_id),
-                path: ActiveValue::Set(path.to_string()),
-            })
-            .exec_with_returning(&*tx)
-            .await?;
-
-            let status = self.remote_projects_update_internal(user_id, &tx).await?;
-
-            Ok((project, status))
-        })
-        .await
-    }
-
-    pub async fn share_remote_project(
-        &self,
-        remote_project_id: RemoteProjectId,
-        dev_server_id: DevServerId,
-        connection: ConnectionId,
-        worktrees: &[proto::WorktreeMetadata],
-    ) -> 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?
-                .ok_or_else(|| anyhow!("no remote project with id {}", remote_project_id))?;
-
-            if remote_project.dev_server_id != dev_server_id {
-                return Err(anyhow!("remote project shared from wrong server"))?;
-            }
-
-            let project = project::ActiveModel {
-                room_id: ActiveValue::Set(None),
-                host_user_id: ActiveValue::Set(None),
-                host_connection_id: ActiveValue::set(Some(connection.id as i32)),
-                host_connection_server_id: ActiveValue::set(Some(ServerId(
-                    connection.owner_id as i32,
-                ))),
-                id: ActiveValue::NotSet,
-                hosted_project_id: ActiveValue::Set(None),
-                remote_project_id: ActiveValue::Set(Some(remote_project_id)),
-            }
-            .insert(&*tx)
-            .await?;
-
-            if !worktrees.is_empty() {
-                worktree::Entity::insert_many(worktrees.iter().map(|worktree| {
-                    worktree::ActiveModel {
-                        id: ActiveValue::set(worktree.id as i64),
-                        project_id: ActiveValue::set(project.id),
-                        abs_path: ActiveValue::set(worktree.abs_path.clone()),
-                        root_name: ActiveValue::set(worktree.root_name.clone()),
-                        visible: ActiveValue::set(worktree.visible),
-                        scan_id: ActiveValue::set(0),
-                        completed_scan_id: ActiveValue::set(0),
-                    }
-                }))
-                .exec(&*tx)
-                .await?;
-            }
-
-            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
-    }
-
-    pub async fn reshare_remote_projects(
-        &self,
-        reshared_projects: &Vec<proto::UpdateProject>,
-        dev_server_id: DevServerId,
-        connection: ConnectionId,
-    ) -> crate::Result<Vec<ResharedProject>> {
-        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
-        self.transaction(|tx| async move {
-            let mut ret = Vec::new();
-            for reshared_project in reshared_projects {
-                let project_id = ProjectId::from_proto(reshared_project.project_id);
-                let (project, remote_project) = project::Entity::find_by_id(project_id)
-                    .find_also_related(remote_project::Entity)
-                    .one(&*tx)
-                    .await?
-                    .ok_or_else(|| anyhow!("project does not exist"))?;
-
-                if remote_project.map(|rp| rp.dev_server_id) != Some(dev_server_id) {
-                    return Err(anyhow!("remote project reshared from wrong server"))?;
-                }
-
-                let Ok(old_connection_id) = project.host_connection() else {
-                    return Err(anyhow!("remote project was not shared"))?;
-                };
-
-                project::Entity::update(project::ActiveModel {
-                    id: ActiveValue::set(project_id),
-                    host_connection_id: ActiveValue::set(Some(connection.id as i32)),
-                    host_connection_server_id: ActiveValue::set(Some(ServerId(
-                        connection.owner_id as i32,
-                    ))),
-                    ..Default::default()
-                })
-                .exec(&*tx)
-                .await?;
-
-                let collaborators = project
-                    .find_related(project_collaborator::Entity)
-                    .all(&*tx)
-                    .await?;
-
-                self.update_project_worktrees(project_id, &reshared_project.worktrees, &tx)
-                    .await?;
-
-                ret.push(super::ResharedProject {
-                    id: project_id,
-                    old_connection_id,
-                    collaborators: collaborators
-                        .iter()
-                        .map(|collaborator| super::ProjectCollaborator {
-                            connection_id: collaborator.connection(),
-                            user_id: collaborator.user_id,
-                            replica_id: collaborator.replica_id,
-                            is_host: collaborator.is_host,
-                        })
-                        .collect(),
-                    worktrees: reshared_project.worktrees.clone(),
-                });
-            }
-            Ok(ret)
-        })
-        .await
-    }
-
-    pub async fn rejoin_remote_projects(
-        &self,
-        rejoined_projects: &Vec<proto::RejoinProject>,
-        user_id: UserId,
-        connection_id: ConnectionId,
-    ) -> crate::Result<Vec<RejoinedProject>> {
-        // todo!() project_transaction? (maybe we can make the lock per-dev-server instead of per-project?)
-        self.transaction(|tx| async move {
-            let mut ret = Vec::new();
-            for rejoined_project in rejoined_projects {
-                if let Some(project) = self
-                    .rejoin_project_internal(&tx, rejoined_project, user_id, connection_id)
-                    .await?
-                {
-                    ret.push(project);
-                }
-            }
-            Ok(ret)
-        })
-        .await
-    }
-}

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

@@ -851,17 +851,17 @@ impl Database {
                     .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)
+                let dev_server_projects_for_user = self
+                    .dev_server_project_ids_for_user(leaving_participant.user_id, &tx)
                     .await?;
 
-                let remote_projects_to_unshare = project::Entity::find()
+                let dev_server_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()),
+                                project::Column::DevServerProjectId
+                                    .is_in(dev_server_projects_for_user.clone()),
                             ),
                     )
                     .all(&*tx)
@@ -892,7 +892,7 @@ impl Database {
                     }
 
                     if (collaborator.is_host && collaborator.connection() == connection)
-                        || remote_projects_to_unshare.contains(&collaborator.project_id)
+                        || dev_server_projects_to_unshare.contains(&collaborator.project_id)
                     {
                         left_project.should_unshare = true;
                     }
@@ -936,9 +936,9 @@ impl Database {
                     .exec(&*tx)
                     .await?;
 
-                if !remote_projects_to_unshare.is_empty() {
+                if !dev_server_projects_to_unshare.is_empty() {
                     project::Entity::update_many()
-                        .filter(project::Column::Id.is_in(remote_projects_to_unshare))
+                        .filter(project::Column::Id.is_in(dev_server_projects_to_unshare))
                         .set(project::ActiveModel {
                             room_id: ActiveValue::Set(None),
                             ..Default::default()
@@ -1316,8 +1316,10 @@ impl Database {
                         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?;
+            } else if let Some(dev_server_project_id) = db_project.dev_server_project_id {
+                let host = self
+                    .owner_for_dev_server_project(dev_server_project_id, tx)
+                    .await?;
                 if let Some((_, participant)) = participants
                     .iter_mut()
                     .find(|(_, v)| v.user_id == host.to_proto())

crates/collab/src/db/tables.rs

@@ -11,6 +11,7 @@ pub mod channel_message_mention;
 pub mod contact;
 pub mod contributor;
 pub mod dev_server;
+pub mod dev_server_project;
 pub mod embedding;
 pub mod extension;
 pub mod extension_version;
@@ -25,7 +26,6 @@ pub mod observed_channel_messages;
 pub mod project;
 pub mod project_collaborator;
 pub mod rate_buckets;
-pub mod remote_project;
 pub mod room;
 pub mod room_participant;
 pub mod server;

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

@@ -16,11 +16,11 @@ impl ActiveModelBehavior for ActiveModel {}
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
 pub enum Relation {
-    #[sea_orm(has_many = "super::remote_project::Entity")]
+    #[sea_orm(has_many = "super::dev_server_project::Entity")]
     RemoteProject,
 }
 
-impl Related<super::remote_project::Entity> for Entity {
+impl Related<super::dev_server_project::Entity> for Entity {
     fn to() -> RelationDef {
         Relation::RemoteProject.def()
     }

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

@@ -1,13 +1,13 @@
 use super::project;
-use crate::db::{DevServerId, RemoteProjectId};
+use crate::db::{DevServerId, DevServerProjectId};
 use rpc::proto;
 use sea_orm::entity::prelude::*;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
-#[sea_orm(table_name = "remote_projects")]
+#[sea_orm(table_name = "dev_server_projects")]
 pub struct Model {
     #[sea_orm(primary_key)]
-    pub id: RemoteProjectId,
+    pub id: DevServerProjectId,
     pub dev_server_id: DevServerId,
     pub path: String,
 }
@@ -39,8 +39,8 @@ impl Related<super::dev_server::Entity> for Entity {
 }
 
 impl Model {
-    pub fn to_proto(&self, project: Option<project::Model>) -> proto::RemoteProject {
-        proto::RemoteProject {
+    pub fn to_proto(&self, project: Option<project::Model>) -> proto::DevServerProject {
+        proto::DevServerProject {
             id: self.id.to_proto(),
             project_id: project.map(|p| p.id.to_proto()),
             dev_server_id: self.dev_server_id.to_proto(),

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

@@ -1,4 +1,4 @@
-use crate::db::{HostedProjectId, ProjectId, RemoteProjectId, Result, RoomId, ServerId, UserId};
+use crate::db::{DevServerProjectId, HostedProjectId, ProjectId, Result, RoomId, ServerId, UserId};
 use anyhow::anyhow;
 use rpc::ConnectionId;
 use sea_orm::entity::prelude::*;
@@ -13,7 +13,7 @@ pub struct Model {
     pub host_connection_id: Option<i32>,
     pub host_connection_server_id: Option<ServerId>,
     pub hosted_project_id: Option<HostedProjectId>,
-    pub remote_project_id: Option<RemoteProjectId>,
+    pub dev_server_project_id: Option<DevServerProjectId>,
 }
 
 impl Model {
@@ -58,9 +58,9 @@ pub enum Relation {
     )]
     HostedProject,
     #[sea_orm(
-        belongs_to = "super::remote_project::Entity",
-        from = "Column::RemoteProjectId",
-        to = "super::remote_project::Column::Id"
+        belongs_to = "super::dev_server_project::Entity",
+        from = "Column::DevServerProjectId",
+        to = "super::dev_server_project::Column::Id"
     )]
     RemoteProject,
 }
@@ -101,7 +101,7 @@ impl Related<super::hosted_project::Entity> for Entity {
     }
 }
 
-impl Related<super::remote_project::Entity> for Entity {
+impl Related<super::dev_server_project::Entity> for Entity {
     fn to() -> RelationDef {
         Relation::RemoteProject.def()
     }