1use crate::ids::WorkspaceId;
2use anyhow::{Result, bail};
3use serde_json::json;
4use sqlx::{Row, SqliteConnection};
5
6use crate::db::{Database, begin_immediate, insert_change};
7use crate::ids::now;
8use crate::projects::normalize_key;
9
10pub const DEFAULT_WORKSPACE_ID: &str = "0000000000000000";
11
12pub fn default_workspace_id() -> WorkspaceId {
13 DEFAULT_WORKSPACE_ID
14 .parse()
15 .expect("valid default workspace ID")
16}
17
18#[derive(Debug, Clone, PartialEq, Eq)]
19pub struct Workspace {
20 pub id: WorkspaceId,
21 pub key: String,
22 pub name: String,
23}
24
25impl Default for Workspace {
26 fn default() -> Self {
27 Self {
28 id: DEFAULT_WORKSPACE_ID
29 .parse()
30 .expect("valid default workspace ID"),
31 key: "default".to_string(),
32 name: "default".to_string(),
33 }
34 }
35}
36
37impl Database {
38 pub async fn list_workspaces(&self) -> Result<Vec<Workspace>> {
39 let mut conn = self.acquire().await?;
40 list_workspaces(&mut conn).await
41 }
42
43 pub async fn find_workspace(&self, name_or_key: &str) -> Result<Option<Workspace>> {
44 let mut conn = self.acquire().await?;
45 find_workspace(&mut conn, name_or_key).await
46 }
47
48 pub async fn workspace_for_id(&self, workspace_id: &WorkspaceId) -> Result<Workspace> {
49 let mut conn = self.acquire().await?;
50 workspace_for_id(&mut conn, workspace_id).await
51 }
52
53 pub async fn resolve_workspace(&self, name_or_key: &str) -> Result<Workspace> {
54 self.resolve_required_workspace(name_or_key, "workspace")
55 .await
56 }
57
58 pub async fn resolve_required_workspace(
59 &self,
60 name_or_key: &str,
61 source: &str,
62 ) -> Result<Workspace> {
63 let mut conn = self.acquire().await?;
64 resolve_required_workspace(&mut conn, name_or_key, source).await
65 }
66
67 pub async fn create_workspace(&self, name: &str) -> Result<Workspace> {
68 let mut conn = self.acquire().await?;
69 let mut tx = begin_immediate(&mut conn).await?;
70 let workspace = create_workspace(&mut tx, name).await?;
71 tx.commit().await?;
72 Ok(workspace)
73 }
74
75 pub async fn rename_workspace(&self, workspace_ref: &str, new_name: &str) -> Result<Workspace> {
76 let mut conn = self.acquire().await?;
77 let mut tx = begin_immediate(&mut conn).await?;
78 let workspace = rename_workspace(&mut tx, workspace_ref, new_name).await?;
79 tx.commit().await?;
80 Ok(workspace)
81 }
82}
83
84pub(crate) async fn ensure_default_workspace(conn: &mut SqliteConnection) -> Result<Workspace> {
85 if let Some(row) = sqlx::query("SELECT id, key, name FROM workspaces WHERE id = ?")
86 .bind(DEFAULT_WORKSPACE_ID)
87 .fetch_optional(&mut *conn)
88 .await?
89 {
90 return Ok(Workspace {
91 id: row.get("id"),
92 key: row.get("key"),
93 name: row.get("name"),
94 });
95 }
96 let id: WorkspaceId = DEFAULT_WORKSPACE_ID
97 .parse()
98 .expect("valid default workspace ID");
99 let ts = now();
100 sqlx::query("INSERT INTO workspaces(id, name, key, created_at, updated_at) VALUES (?, 'default', 'default', ?, ?)")
101 .bind(&id)
102 .bind(&ts)
103 .bind(&ts)
104 .execute(&mut *conn)
105 .await?;
106 Ok(Workspace {
107 id,
108 key: "default".to_string(),
109 name: "default".to_string(),
110 })
111}
112
113pub(crate) async fn list_workspaces(conn: &mut SqliteConnection) -> Result<Vec<Workspace>> {
114 let rows = sqlx::query("SELECT id, key, name FROM workspaces WHERE archived = 0 ORDER BY key")
115 .fetch_all(&mut *conn)
116 .await?;
117 Ok(rows
118 .into_iter()
119 .map(|row| Workspace {
120 id: row.get("id"),
121 key: row.get("key"),
122 name: row.get("name"),
123 })
124 .collect())
125}
126
127pub(crate) async fn find_workspace(
128 conn: &mut SqliteConnection,
129 name_or_key: &str,
130) -> Result<Option<Workspace>> {
131 let key = normalize_key(name_or_key);
132 let row = sqlx::query(
133 "SELECT id, key, name FROM workspaces
134 WHERE archived = 0 AND (key = ? OR lower(name) = lower(?))",
135 )
136 .bind(key)
137 .bind(name_or_key)
138 .fetch_optional(&mut *conn)
139 .await?;
140 Ok(row.map(workspace_from_row))
141}
142
143pub(crate) async fn workspace_for_id(
144 conn: &mut SqliteConnection,
145 workspace_id: &WorkspaceId,
146) -> Result<Workspace> {
147 let row = sqlx::query("SELECT id, key, name FROM workspaces WHERE id = ? AND archived = 0")
148 .bind(workspace_id)
149 .fetch_optional(&mut *conn)
150 .await?;
151 match row {
152 Some(row) => Ok(workspace_from_row(row)),
153 None => bail!("error unknown-workspace-id id={workspace_id}"),
154 }
155}
156
157pub(crate) async fn workspace_key_for_id(
158 conn: &mut SqliteConnection,
159 workspace_id: &WorkspaceId,
160) -> Result<String> {
161 Ok(workspace_for_id(conn, workspace_id).await?.key)
162}
163
164fn workspace_from_row(row: sqlx::sqlite::SqliteRow) -> Workspace {
165 Workspace {
166 id: row.get("id"),
167 key: row.get("key"),
168 name: row.get("name"),
169 }
170}
171
172pub(crate) async fn resolve_workspace(
173 conn: &mut SqliteConnection,
174 name_or_key: &str,
175) -> Result<Workspace> {
176 resolve_required_workspace(conn, name_or_key, "workspace").await
177}
178
179pub(crate) async fn resolve_required_workspace(
180 conn: &mut SqliteConnection,
181 name_or_key: &str,
182 source: &str,
183) -> Result<Workspace> {
184 if let Some(workspace) = find_workspace(conn, name_or_key).await? {
185 return Ok(workspace);
186 }
187 bail!(
188 "error unknown-workspace input={} source={} hint=\"create the workspace with aven workspace create\"",
189 name_or_key,
190 source
191 );
192}
193
194pub(crate) async fn create_workspace(conn: &mut SqliteConnection, name: &str) -> Result<Workspace> {
195 let key = normalize_key(name);
196 if key.is_empty() {
197 bail!("error invalid-workspace input={name}");
198 }
199 if find_workspace(conn, &key).await?.is_some() {
200 bail!("error workspace-exists key={key}");
201 }
202 let id = WorkspaceId::new();
203 let ts = now();
204 sqlx::query(
205 "INSERT INTO workspaces(id, name, key, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
206 )
207 .bind(&id)
208 .bind(name)
209 .bind(&key)
210 .bind(&ts)
211 .bind(&ts)
212 .execute(&mut *conn)
213 .await?;
214 insert_change(
215 conn,
216 "workspace",
217 id.as_str(),
218 None,
219 "create_workspace",
220 json!({ "key": key, "name": name, "created_at": ts }),
221 None,
222 )
223 .await?;
224 Ok(Workspace {
225 id,
226 key,
227 name: name.to_string(),
228 })
229}
230
231pub(crate) async fn rename_workspace(
232 conn: &mut SqliteConnection,
233 workspace_ref: &str,
234 new_name: &str,
235) -> Result<Workspace> {
236 let workspace = resolve_workspace(conn, workspace_ref).await?;
237 let new_key = normalize_key(new_name);
238 if new_key.is_empty() {
239 bail!("error invalid-workspace input={new_name}");
240 }
241 if new_key != workspace.key && find_workspace(conn, &new_key).await?.is_some() {
242 bail!("error workspace-exists key={new_key}");
243 }
244 let ts = now();
245 sqlx::query("UPDATE workspaces SET name = ?, key = ?, updated_at = ? WHERE id = ?")
246 .bind(new_name)
247 .bind(&new_key)
248 .bind(&ts)
249 .bind(&workspace.id)
250 .execute(&mut *conn)
251 .await?;
252 if workspace.name != new_name {
253 insert_change(
254 conn,
255 "workspace",
256 workspace.id.as_str(),
257 Some("name"),
258 "set_workspace_field",
259 json!({ "value": new_name }),
260 None,
261 )
262 .await?;
263 }
264 if workspace.key != new_key {
265 insert_change(
266 conn,
267 "workspace",
268 workspace.id.as_str(),
269 Some("key"),
270 "set_workspace_field",
271 json!({ "value": new_key }),
272 None,
273 )
274 .await?;
275 }
276 Ok(Workspace {
277 id: workspace.id,
278 key: new_key,
279 name: new_name.to_string(),
280 })
281}
282
283#[cfg(test)]
284mod tests {
285 use super::*;
286 use crate::db::open_db;
287
288 #[tokio::test]
289 async fn fresh_database_has_default_workspace() {
290 let dir = tempfile::tempdir().unwrap();
291 let pool = open_db(&dir.path().join("test.db")).await.unwrap();
292 let mut conn = pool.acquire().await.unwrap();
293 let workspaces = list_workspaces(&mut conn).await.unwrap();
294 assert_eq!(workspaces.len(), 1);
295 assert_eq!(workspaces[0].key, "default");
296 }
297}