[server] Change name to owner and db inernally #1392

.github/workflows/agdb_server.yaml

@@ -36,7 +36,7 @@ jobs:
       - uses: actions-rust-lang/setup-rust-toolchain@v1
       - uses: taiki-e/install-action@cargo-llvm-cov
       - run: rustup component add llvm-tools-preview
-      - run: cargo llvm-cov --package agdb_server --all-features --ignore-filename-regex "agdb(.|..)src|agdb_derive|agdb_api|api.rs" --fail-uncovered-functions 18 --show-missing-lines
+      - run: cargo llvm-cov --package agdb_server --all-features --ignore-filename-regex "agdb(.|..)src|agdb_derive|agdb_api|api.rs" --fail-uncovered-functions 21 --show-missing-lines
 
   agdb_server_test:
     runs-on: ubuntu-latest

agdb_server/src/action/db_add.rs

@@ -4,7 +4,6 @@ use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_db::Database;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbType;
 use serde::Deserialize;
@@ -19,19 +18,15 @@ pub(crate) struct DbAdd {
 
 impl Action for DbAdd {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
-
-        let backup = db_pool
-            .add_db(&self.owner, &self.db, &name, self.db_type)
-            .await?;
-
+        let backup = db_pool.add_db(&self.owner, &self.db, self.db_type).await?;
         let owner = db.user_id(&self.owner).await?;
 
         db.insert_db(
             owner,
             Database {
                 db_id: None,
-                name,
+                db: self.db,
+                owner: self.owner,
                 db_type: self.db_type,
                 backup,
             },

agdb_server/src/action/db_backup.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,11 +15,10 @@ pub(crate) struct DbBackup {
 
 impl Action for DbBackup {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let owner = db.user_id(&self.owner).await?;
-        let name = db_name(&self.owner, &self.db);
-        let mut database = db.user_db(owner, &name).await?;
+        let user = db.user_id(&self.owner).await?;
+        let mut database = db.user_db(user, &self.owner, &self.db).await?;
         database.backup = db_pool
-            .backup_db(&self.owner, &self.db, &name, database.db_type)
+            .backup_db(&self.owner, &self.db, database.db_type)
             .await?;
         db.save_db(&database).await?;
         Ok(ClusterActionResult::None)

agdb_server/src/action/db_clear.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbResource;
 use serde::Deserialize;
@@ -18,9 +17,8 @@ pub(crate) struct DbClear {
 
 impl Action for DbClear {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let owner = db.user_id(&self.owner).await?;
-        let name = db_name(&self.owner, &self.db);
-        let mut database = db.user_db(owner, &name).await?;
+        let user = db.user_id(&self.owner).await?;
+        let mut database = db.user_db(user, &self.owner, &self.db).await?;
         db_pool
             .clear_db(&self.owner, &self.db, &mut database, self.resource)
             .await?;

agdb_server/src/action/db_convert.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbType;
 use serde::Deserialize;
@@ -18,11 +17,10 @@ pub(crate) struct DbConvert {
 
 impl Action for DbConvert {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let owner = db.user_id(&self.owner).await?;
-        let name = db_name(&self.owner, &self.db);
-        let mut database = db.user_db(owner, &name).await?;
+        let user = db.user_id(&self.owner).await?;
+        let mut database = db.user_db(user, &self.owner, &self.db).await?;
         db_pool
-            .convert_db(&self.owner, &self.db, &name, database.db_type, self.db_type)
+            .convert_db(&self.owner, &self.db, database.db_type, self.db_type)
             .await?;
         database.db_type = self.db_type;
         db.save_db(&database).await?;

agdb_server/src/action/db_copy.rs

@@ -4,7 +4,6 @@ use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_db::Database;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbType;
 use serde::Deserialize;
@@ -21,17 +20,16 @@ pub(crate) struct DbCopy {
 
 impl Action for DbCopy {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
-        let target_name = db_name(&self.new_owner, &self.new_db);
         let new_owner_id = db.user_id(&self.new_owner).await?;
         db_pool
-            .copy_db(&name, &self.new_owner, &self.new_db, &target_name)
+            .copy_db(&self.owner, &self.db, &self.new_owner, &self.new_db)
             .await?;
         db.insert_db(
             new_owner_id,
             Database {
                 db_id: None,
-                name: target_name,
+                db: self.new_db,
+                owner: self.new_owner,
                 db_type: self.db_type,
                 backup: 0,
             },

agdb_server/src/action/db_delete.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,10 +15,9 @@ pub(crate) struct DbDelete {
 
 impl Action for DbDelete {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
         let user_id = db.user_id(&self.owner).await?;
-        db.remove_db(user_id, &name).await?;
-        db_pool.delete_db(&self.owner, &self.db, &name).await?;
+        db.remove_db(user_id, &self.owner, &self.db).await?;
+        db_pool.delete_db(&self.owner, &self.db).await?;
         Ok(ClusterActionResult::None)
     }
 }

agdb_server/src/action/db_exec.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::DbUserValue;
 use agdb::QueryResult;
 use agdb_api::Queries;
@@ -20,10 +19,9 @@ pub(crate) struct DbExec {
 
 impl Action for DbExec {
     async fn exec(self, _db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
         Ok(ClusterActionResult::QueryResults(
             db_pool
-                .exec_mut(&self.owner, &self.db, &name, &self.user, self.queries)
+                .exec_mut(&self.owner, &self.db, &self.user, self.queries)
                 .await?,
         ))
     }

agdb_server/src/action/db_optimize.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,8 +15,7 @@ pub(crate) struct DbOptimize {
 
 impl Action for DbOptimize {
     async fn exec(self, _db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
-        db_pool.optimize_db(&name).await?;
+        db_pool.optimize_db(&self.owner, &self.db).await?;
 
         Ok(ClusterActionResult::None)
     }

agdb_server/src/action/db_remove.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,10 +15,9 @@ pub(crate) struct DbRemove {
 
 impl Action for DbRemove {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
         let user_id = db.user_id(&self.owner).await?;
-        db.remove_db(user_id, &name).await?;
-        db_pool.remove_db(&name).await?;
+        db.remove_db(user_id, &self.owner, &self.db).await?;
+        db_pool.remove_db(&self.owner, &self.db).await?;
         Ok(ClusterActionResult::None)
     }
 }

agdb_server/src/action/db_rename.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbUserRole;
 use serde::Deserialize;
@@ -20,20 +19,12 @@ pub(crate) struct DbRename {
 impl Action for DbRename {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
         let owner_id = db.user_id(&self.owner).await?;
-        let name = db_name(&self.owner, &self.db);
-        let new_name = db_name(&self.new_owner, &self.new_db);
-        let mut database = db.user_db(owner_id, &name).await?;
+        let mut database = db.user_db(owner_id, &self.owner, &self.db).await?;
         db_pool
-            .rename_db(
-                &self.owner,
-                &self.db,
-                &name,
-                &self.new_owner,
-                &self.new_db,
-                &new_name,
-            )
+            .rename_db(&self.owner, &self.db, &self.new_owner, &self.new_db)
             .await?;
-        database.name = new_name;
+        database.owner = self.new_owner.clone();
+        database.db = self.new_db.to_string();
         db.save_db(&database).await?;
 
         if self.owner != self.new_owner {

agdb_server/src/action/db_restore.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -16,12 +15,11 @@ pub(crate) struct DbRestore {
 
 impl Action for DbRestore {
     async fn exec(self, db: ServerDb, db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let owner = db.user_id(&self.owner).await?;
-        let name = db_name(&self.owner, &self.db);
-        let mut database = db.user_db(owner, &name).await?;
+        let user = db.user_id(&self.owner).await?;
+        let mut database = db.user_db(user, &self.owner, &self.db).await?;
 
         if let Some(backup) = db_pool
-            .restore_db(&self.owner, &self.db, &name, database.db_type)
+            .restore_db(&self.owner, &self.db, database.db_type)
             .await?
         {
             database.backup = backup;

agdb_server/src/action/db_user_add.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use agdb_api::DbUserRole;
 use serde::Deserialize;
@@ -19,9 +18,8 @@ pub(crate) struct DbUserAdd {
 
 impl Action for DbUserAdd {
     async fn exec(self, db: ServerDb, _db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
         let owner_id = db.user_id(&self.owner).await?;
-        let db_id = db.user_db_id(owner_id, &name).await?;
+        let db_id = db.user_db_id(owner_id, &self.owner, &self.db).await?;
         let user_id = db.user_id(&self.user).await?;
         db.insert_db_user(db_id, user_id, self.db_role).await?;
 

agdb_server/src/action/db_user_remove.rs

@@ -3,7 +3,6 @@ use super::ServerDb;
 use crate::action::Action;
 use crate::action::ClusterActionResult;
 use crate::server_error::ServerResult;
-use crate::utilities::db_name;
 use agdb::UserValue;
 use serde::Deserialize;
 use serde::Serialize;
@@ -17,9 +16,8 @@ pub(crate) struct DbUserRemove {
 
 impl Action for DbUserRemove {
     async fn exec(self, db: ServerDb, _db_pool: DbPool) -> ServerResult<ClusterActionResult> {
-        let name = db_name(&self.owner, &self.db);
         let owner_id = db.user_id(&self.owner).await?;
-        let db_id = db.user_db_id(owner_id, &name).await?;
+        let db_id = db.user_db_id(owner_id, &self.owner, &self.db).await?;
         let user_id = db.user_id(&self.user).await?;
         db.remove_db_user(db_id, user_id).await?;