chore: use x-tenant-id sent by router rather than maintaining a seper…

…ate global tenant

config/development.toml

@@ -19,14 +19,14 @@ pool_size = 5
 min_idle = 2
 enable_ssl = false
 
-[multitenancy.global_tenant]
-cache_prefix = "global"
-schema = "global"
-
 [multitenancy.tenants.public]
 cache_prefix = "public"
 schema = "public"
 
+[multitenancy.tenants.global]
+cache_prefix = "global"
+schema = "global"
+
 [log]
 log_level = "debug"
 log_format = "console"

src/app.rs

@@ -53,7 +53,6 @@ pub struct SessionState {
     pub thread_pool: ThreadPool,
     pub keymanager_client: KeyManagerClient,
     db_pool: StorageState,
-    global_db_pool: StorageState,
     pub hash_client: Blake3,
 }
 
@@ -65,17 +64,13 @@ impl SessionState {
     pub async fn from_config(config: &Config, tenant_config: &TenantConfig) -> Self {
         let secrets = config.secrets.clone();
         let db_pool = StorageState::from_config(config, &tenant_config.schema).await;
-        let global_db_pool =
-            StorageState::from_config(config, &config.multitenancy.global_tenant.0.schema).await;
-
         let num_threads = config.pool_config.pool;
         let hash_client = Blake3::from_config(config).await;
 
         Self {
             cache_prefix: tenant_config.cache_prefix.clone(),
             keymanager_client: secrets.create_keymanager_client().await,
             db_pool,
-            global_db_pool,
             hash_client,
             thread_pool: ThreadPoolBuilder::new()
                 .num_threads(num_threads)
@@ -84,10 +79,6 @@ impl SessionState {
         }
     }
 
-    pub fn global_db_pool(&self) -> &StorageState {
-        &self.global_db_pool
-    }
-
     pub fn db_pool(&self) -> &StorageState {
         &self.db_pool
     }

src/config.rs

@@ -149,12 +149,8 @@ pub struct Config {
 #[derive(Deserialize, Debug)]
 pub struct MultiTenancy {
     pub tenants: TenantsConfig,
-    pub global_tenant: GlobalTenant,
 }
 
-#[derive(Deserialize, Debug)]
-pub struct GlobalTenant(pub TenantConfig);
-
 #[derive(Deserialize, Debug)]
 pub struct TenantsConfig(pub FxHashMap<String, TenantConfig>);
 
@@ -258,6 +254,17 @@ impl Cassandra {
     }
 }
 
+impl MultiTenancy {
+    fn validate(&self) -> CustomResult<(), errors::ParsingError> {
+        error_stack::ensure!(
+            !self.tenants.0.is_empty(),
+            errors::ParsingError::DecodingFailed("Failed to validate multitenancy configuration. You need to configure atleast one tenant".to_string()
+         )
+       );
+        Ok(())
+    }
+}
+
 impl Config {
     pub fn config_path(environment: Environment, explicit_config_path: Option<PathBuf>) -> PathBuf {
         let mut config_path = PathBuf::new();
@@ -305,6 +312,10 @@ impl Config {
         self.cassandra
             .validate()
             .expect("Failed to valdiate cassandra some missing configuration found");
+
+        self.multitenancy
+            .validate()
+            .expect("Failed to validate multitenancy, some missing configuration found");
     }
 }
 

src/core/datakey/create.rs

@@ -12,7 +12,7 @@ pub async fn generate_and_create_data_key(
     custodian: Custodian,
     req: CreateDataKeyRequest,
 ) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
-    let db = state.get_db_pool(&req.identifier);
+    let db = state.get_db_pool();
     let version = Version::get_latest(&req.identifier, &state).await;
 
     let (source, aes_key) = state.keymanager_client.generate_key().await.switch()?;

src/core/datakey/rotate.rs

@@ -12,7 +12,7 @@ pub async fn generate_and_rotate_data_key(
     custodian: Custodian,
     req: RotateDataKeyRequest,
 ) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
-    let db = state.get_db_pool(&req.identifier);
+    let db = state.get_db_pool();
     let version = db
         .get_latest_version(&req.identifier)
         .await

src/core/datakey/transfer.rs

@@ -17,7 +17,7 @@ pub async fn transfer_data_key(
     custodian: Custodian,
     req: TransferKeyRequest,
 ) -> errors::CustomResult<DataKeyCreateResponse, errors::ApplicationErrorResponse> {
-    let db = &state.get_db_pool(&req.identifier);
+    let db = &state.get_db_pool();
     let key = BASE64_ENGINE.decode(req.key).change_context(
         errors::ApplicationErrorResponse::InternalServerError("Failed to decode the base64 key"),
     )?;

src/multitenancy.rs

@@ -1,7 +1,6 @@
 use crate::{
     app::{AppState, SessionState, StorageState},
     errors::{self, ApiErrorContainer, ToContainerError},
-    types::Identifier,
 };
 use error_stack::ResultExt;
 use hyper::header;
@@ -28,11 +27,8 @@ impl TenantState {
         Self(session)
     }
 
-    pub(crate) fn get_db_pool(&self, identifier: &Identifier) -> &StorageState {
-        match identifier {
-            Identifier::UserAuth(_) | Identifier::User(_) => self.global_db_pool(),
-            Identifier::Merchant(_) | Identifier::Entity(_) => self.db_pool(),
-        }
+    pub(crate) fn get_db_pool(&self) -> &StorageState {
+        self.db_pool()
     }
 }
 

src/types/core/key.rs

@@ -43,7 +43,7 @@ impl Key {
         identifier: &Identifier,
         version: Version,
     ) -> errors::CustomResult<Self, errors::DatabaseError> {
-        let db = state.get_db_pool(identifier);
+        let db = state.get_db_pool();
         let get_and_decrypt_key = || async {
             let key = db.get_key(version, identifier).await?;
             key.decrypt(state).await.switch()
@@ -63,7 +63,7 @@ impl Key {
         identifier: &Identifier,
         version: FxHashSet<Version>,
     ) -> errors::CustomResult<FxHashMap<Version, Self>, errors::DatabaseError> {
-        let db = &state.get_db_pool(identifier);
+        let db = &state.get_db_pool();
         let get_and_decrypt_key = |v: Version| async move {
             let key = db.get_key(v, identifier).await?;
             key.decrypt(state).await.switch()
@@ -168,7 +168,7 @@ impl Serialize for Version {
 
 impl Version {
     pub async fn get_latest(identifier: &Identifier, state: &TenantState) -> Self {
-        let db = state.get_db_pool(identifier);
+        let db = state.get_db_pool();
         let latest_version = db.get_latest_version(identifier);
         let v = cache::get_or_populate_cache(
             state,