feat: most API procedures now want UUIDs

this is an incomplete update: there are some protocol design flaws which
make it very complex or impossible to properly migrate to uuids. so this
commit makes it compile, but doesn't make it "work"

Author: alemidev

src/client.rs

@@ -20,7 +20,7 @@ use codemp_proto::{
 	auth::{LoginRequest, auth_client::AuthClient},
 	common::{Empty, Identifier, Token},
 	session::{
-		InviteRequest, OwnedWorkspaceRequest, WorkspaceRequest, session_client::SessionClient,
+		InviteRequest, OwnedWorkspaceRequest, session_client::SessionClient,
 	},
 };
 
@@ -110,28 +110,26 @@ impl Client {
 	}
 
 	/// Delete an existing workspace if possible.
-	pub async fn delete_workspace(&self, name: impl AsRef<str>) -> RemoteResult<()> {
+	pub async fn delete_workspace(&self, id: uuid::Uuid) -> RemoteResult<()> {
 		self.0
 			.session
 			.clone()
-			.delete_workspace(OwnedWorkspaceRequest {
-				name: name.as_ref().to_string(),
-			})
+			.delete_workspace(Identifier::from(id))
 			.await?;
 		Ok(())
 	}
 
 	/// Invite user with given username to the given workspace, if possible.
 	pub async fn invite_to_workspace(
 		&self,
-		workspace_name: impl AsRef<str>,
+		workspace_id: uuid::Uuid,
 		user_name: impl AsRef<str>,
 	) -> RemoteResult<()> {
 		self.0
 			.session
 			.clone()
 			.invite_to_workspace(InviteRequest {
-				workspace: workspace_name.as_ref().to_string(),
+				workspace: Identifier::from(workspace_id),
 				user: user_name.as_ref().to_string(),
 			})
 			.await?;
@@ -149,7 +147,7 @@ impl Client {
 			.into_inner()
 			.owned
 			.into_iter()
-			.map(|x| crate::api::WorkspaceInfo::from(x))
+			.map(crate::api::WorkspaceInfo::from)
 			.collect())
 	}
 
@@ -164,7 +162,7 @@ impl Client {
 			.into_inner()
 			.invited
 			.into_iter()
-			.map(|x| crate::api::WorkspaceInfo::from(x))
+			.map(crate::api::WorkspaceInfo::from)
 			.collect())
 	}
 
@@ -173,9 +171,7 @@ impl Client {
 	pub async fn attach_workspace(&self, workspace: uuid::Uuid) -> ConnectionResult<Workspace> {
 		let mut session_client = self.0.session.clone();
 		let token = session_client
-			.get_workspace_token(WorkspaceRequest {
-				id: Identifier::from(workspace),
-			})
+			.get_workspace_token(Identifier::from(workspace))
 			.await?
 			.into_inner();
 
@@ -200,7 +196,7 @@ impl Client {
 					tokio::time::sleep(std::time::Duration::from_secs(240)).await;
 					if weak.upgrade().is_none() { break };
 					let new_credentials = session_client.get_workspace_token(
-						tonic::Request::new(WorkspaceRequest { id: Identifier::from(workspace) })
+						tonic::Request::new(Identifier::from(workspace))
 					)
 						.await?
 						.into_inner();

src/tests/fixtures.rs

@@ -77,47 +77,47 @@ impl ScopedFixture<crate::Client> for ClientFixture {
 pub struct WorkspaceFixture {
 	user: String,
 	invitee: Option<String>,
-	workspace: String,
+	workspace: uuid::Uuid,
 }
 
 impl WorkspaceFixture {
-	pub fn of(user: &str, invitee: &str, workspace: &str) -> Self {
+	pub fn of(user: &str, invitee: &str, workspace: uuid::Uuid) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: Some(invitee.to_string()),
-			workspace: workspace.to_string(),
+			workspace,
 		}
 	}
 
-	pub fn one(user: &str, ws: &str) -> Self {
+	pub fn one(user: &str) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: None,
-			workspace: format!("{ws}-{}", uuid::Uuid::new_v4()),
+			workspace: uuid::Uuid::new_v4(),
 		}
 	}
 
-	pub fn two(user: &str, invite: &str, ws: &str) -> Self {
+	pub fn two(user: &str, invite: &str) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: Some(invite.to_string()),
-			workspace: format!("{ws}-{}", uuid::Uuid::new_v4()),
+			workspace: uuid::Uuid::new_v4(),
 		}
 	}
 }
 
 impl ScopedFixture<(crate::Client, crate::Workspace)> for WorkspaceFixture {
 	async fn setup(&mut self) -> Result<(crate::Client, crate::Workspace), Box<dyn Error>> {
 		let client = ClientFixture::of(&self.user).setup().await?;
-		let ws_info = client.create_workspace(&self.workspace).await?;
+		let ws_info = client.create_workspace(self.workspace.to_string()).await?;
 		let workspace = client.attach_workspace(ws_info.id).await?;
 		Ok((client, workspace))
 	}
 
 	async fn cleanup(&mut self, resource: Option<(crate::Client, crate::Workspace)>) {
 		if let Some((client, workspace)) = resource {
 			client.leave_workspace(workspace.id());
-			if let Err(e) = client.delete_workspace(&self.workspace).await {
+			if let Err(e) = client.delete_workspace(self.workspace).await {
 				eprintln!("could not delete workspace: {e}");
 			}
 		}
@@ -152,9 +152,9 @@ impl
 		)
 		.setup()
 		.await?;
-		let ws_info = client.create_workspace(&self.workspace).await?;
+		let ws_info = client.create_workspace(self.workspace.to_string()).await?;
 		client
-			.invite_to_workspace(&self.workspace, invitee_client.current_user().name.clone())
+			.invite_to_workspace(self.workspace, invitee_client.current_user().name.clone())
 			.await?;
 		let workspace = client.attach_workspace(ws_info.id).await?;
 		let invitee_workspace = invitee_client.attach_workspace(ws_info.id).await?;
@@ -172,7 +172,7 @@ impl
 	) {
 		if let Some((client, ws, _, _)) = resource {
 			client.leave_workspace(ws.id());
-			if let Err(e) = client.delete_workspace(&self.workspace).await {
+			if let Err(e) = client.delete_workspace(self.workspace).await {
 				eprintln!("could not delete workspace: {e}");
 			}
 		}
@@ -182,35 +182,35 @@ impl
 pub struct BufferFixture {
 	user: String,
 	invitee: Option<String>,
-	workspace: String,
-	buffer: String,
+	workspace: uuid::Uuid,
+	buffer: uuid::Uuid,
 }
 
 impl BufferFixture {
-	pub fn of(user: &str, invitee: &str, workspace: &str, buffer: &str) -> Self {
+	pub fn of(user: &str, invitee: &str, workspace: uuid::Uuid, buffer: uuid::Uuid) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: Some(invitee.to_string()),
-			workspace: workspace.to_string(),
-			buffer: buffer.to_string(),
+			workspace,
+			buffer,
 		}
 	}
 
-	pub fn one(user: &str, ws: &str, buf: &str) -> Self {
+	pub fn one(user: &str, buf: uuid::Uuid) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: None,
-			workspace: format!("{ws}-{}", uuid::Uuid::new_v4()),
-			buffer: buf.to_string(),
+			workspace: uuid::Uuid::new_v4(),
+			buffer: buf,
 		}
 	}
 
-	pub fn two(user: &str, invite: &str, ws: &str, buf: &str) -> Self {
+	pub fn two(user: &str, invite: &str, buf: uuid::Uuid) -> Self {
 		Self {
 			user: user.to_string(),
 			invitee: Some(invite.to_string()),
-			workspace: format!("{ws}-{}", uuid::Uuid::new_v4()),
-			buffer: buf.to_string(),
+			workspace: uuid::Uuid::new_v4(),
+			buffer: buf,
 		}
 	}
 }
@@ -247,17 +247,17 @@ impl
 		)
 		.setup()
 		.await?;
-		let ws_info = client.create_workspace(&self.workspace).await?;
+		let ws_info = client.create_workspace(self.workspace.to_string()).await?;
 		client
-			.invite_to_workspace(&self.workspace, invitee_client.current_user().name.clone())
+			.invite_to_workspace(self.workspace, invitee_client.current_user().name.clone())
 			.await?;
 
 		let workspace = client.attach_workspace(ws_info.id).await?;
-		workspace.create_buffer(&self.buffer, false).await?;
-		let buffer = workspace.attach_buffer(self.buffer.clone()).await?;
+		workspace.create_buffer(&self.buffer.to_string(), false).await?;
+		let buffer = workspace.attach_buffer(self.buffer, &self.buffer.to_string()).await?;
 
 		let invitee_workspace = invitee_client.attach_workspace(ws_info.id).await?;
-		let invitee_buffer = invitee_workspace.attach_buffer(self.buffer.clone()).await?;
+		let invitee_buffer = invitee_workspace.attach_buffer(self.buffer, &self.buffer.to_string()).await?;
 
 		Ok((
 			client,
@@ -283,7 +283,7 @@ impl
 		if let Some((client, ws, _, _, _, _)) = resource {
 			// buffer deletion is implied in workspace deletion
 			client.leave_workspace(ws.id());
-			if let Err(e) = client.delete_workspace(&self.workspace).await {
+			if let Err(e) = client.delete_workspace(self.workspace).await {
 				eprintln!("could not delete workspace: {e}");
 			}
 		}

src/workspace.rs

@@ -15,12 +15,12 @@ use crate::{
 };
 
 use codemp_proto::{
-	common::Empty,
+	common::{Empty, Identifier},
 	files::{BufferNode, BufferRequest},
 	workspace::{
-		workspace_event::{
+		WorkspaceEvent, workspace_event::{
 			Event as WorkspaceEventInner, FileCreate, FileDelete, FileRename, UserJoinBuffer, UserJoinWorkspace, UserLeaveBuffer, UserLeaveWorkspace
-		}, WorkspaceEvent
+		}
 	},
 };
 
@@ -48,7 +48,7 @@ use napi_derive::napi;
 pub struct Workspace(pub(crate) Arc<WorkspaceInner>);
 
 #[derive(Debug)]
-struct WorkspaceInner {
+pub(crate) struct WorkspaceInner {
 	id: Uuid,
 	current_user: Arc<User>,
 	cursor: cursor::Controller,
@@ -140,7 +140,7 @@ impl Workspace {
 		});
 
 		ws.fetch_users().await?;
-		ws.fetch_buffers("".to_string()).await?;
+		ws.fetch_buffers().await?;
 
 		for buffer_ref in ws.0.buffers.iter() {
 			ws.fetch_buffer_users(buffer_ref.key().clone()).await?;
@@ -182,35 +182,30 @@ impl Workspace {
 
 	/// Attach to a buffer and return a handle to it.
 	#[tracing::instrument(skip(self))]
-	pub async fn attach_buffer(&self, path: String) -> ConnectionResult<buffer::Controller> {
+	pub async fn attach_buffer(&self, id: uuid::Uuid, path: &str) -> ConnectionResult<buffer::Controller> {
 		let mut workspace_client = self.0.services.ws();
 		let mut buffer_client = self.0.services.buf();
-		let request = tonic::Request::new(BufferRequest {
-			path: path.clone(),
-		});
-		let credentials = workspace_client.get_buffer_token(request).await?.into_inner();
+		let credentials = workspace_client.get_buffer_token(Identifier::from(id)).await?.into_inner();
 
 		let (tx, rx) = mpsc::channel(256);
 		let mut req = tonic::Request::new(tokio_stream::wrappers::ReceiverStream::new(rx));
 		req.metadata_mut().insert("buffer", crate::ext::token_to_metadata(credentials)?);
 		let stream = buffer_client.attach(req).await?.into_inner();
 
 		let controller =
-			buffer::Controller::spawn(self.0.current_user.id, &path, tx, stream, self.0.id);
+			buffer::Controller::spawn(self.0.current_user.id, path, tx, stream, self.0.id);
 
-		self.0.buffers.insert(path.clone(), controller.clone());
+		self.0.buffers.insert(path.to_string(), controller.clone());
 
+		let path = path.to_string();
 		let weak = Arc::downgrade(&controller.0);
 		tokio::spawn(async move {
-			let _p = path.clone();
 			let fut = async move {
 				loop {
 					// TODO either configurable token refresh time or calculate depending on token lifetime
 					tokio::time::sleep(std::time::Duration::from_secs(20)).await;
 					if weak.upgrade().is_none() { break };
-					let new_credentials = workspace_client.get_buffer_token(
-						tonic::Request::new(BufferRequest { path: path.clone() })
-					)
+					let new_credentials = workspace_client.get_buffer_token(Identifier::from(id))
 						.await?
 						.into_inner();
 					let mut request = tonic::Request::new(Empty {});
@@ -221,7 +216,7 @@ impl Workspace {
 			};
 
 			if let Err(e) = fut.await {
-				tracing::error!("error in keepalive task for buffer {_p}: {e}");
+				tracing::error!("error in keepalive task for buffer {path}: {e}");
 			}
 		});
 
@@ -248,10 +243,10 @@ impl Workspace {
 	}
 
 	/// Re-fetch the list of available buffers in the workspace.
-	pub async fn fetch_buffers(&self, path: String) -> RemoteResult<()> {
+	pub async fn fetch_buffers(&self) -> RemoteResult<()> {
 		let mut workspace_client = self.0.services.ws();
 		let resp = workspace_client
-			.fetch_buffers(tonic::Request::new(BufferRequest { path }))
+			.fetch_buffers(Empty {})
 			.await?
 			.into_inner();
 
@@ -303,14 +298,12 @@ impl Workspace {
 	}
 
 	/// Delete a buffer.
-	pub async fn delete_buffer(&self, path: &str) -> RemoteResult<()> {
+	pub async fn delete_buffer(&self, id: uuid::Uuid, path: &str) -> RemoteResult<()> {
 		self.detach_buffer(path); // just in case
 
 		let mut workspace_client = self.0.services.ws();
 		workspace_client
-			.delete_buffer(tonic::Request::new(BufferRequest {
-				path: path.to_string(),
-			}))
+			.delete_buffer(Identifier::from(id))
 			.await?;
 
 		self.0.filetree.remove(path);
@@ -369,7 +362,7 @@ impl Workspace {
 	}
 
 	/// Get the filetree as it is currently cached.
-	/// A filter may be applied, and it may be strict (equality check) or not (starts_with check).
+	/// A filter may be applied, and it works as a "starts_with" check.
 	// #[cfg_attr(feature = "js", napi)] // https://github.com/napi-rs/napi-rs/issues/1120
 	pub fn search_buffers(&self, filter: Option<&str>) -> Vec<String> {
 		let mut tree = self