refactor/nanocld: resource kind repository (#732)

bin/nanocld/src/models/resource_kind.rs

@@ -1,18 +1,6 @@
-use std::sync::Arc;
-
 use diesel::prelude::*;
-use ntex::rt::JoinHandle;
-
-use nanocl_error::io::{IoError, IoResult};
-
-use nanocl_stubs::generic::{GenericFilter, GenericClause};
-
-use crate::{
-  utils, gen_where4string,
-  schema::{resource_kinds, resource_kind_versions},
-};
 
-use super::{Repository, Pool};
+use crate::schema::{resource_kinds, resource_kind_versions};
 
 /// This structure represent the resource kind verion in the database.
 /// A resource kind version represent the version of a resource kind.
@@ -73,86 +61,6 @@ impl From<&ResourceKindPartial> for ResourceKindVersionDb {
   }
 }
 
-impl Repository for ResourceKindVersionDb {
-  type Table = resource_kind_versions::table;
-  type Item = ResourceKindVersionDb;
-  type UpdateItem = ResourceKindVersionDb;
-
-  fn find_one(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Self::Item>> {
-    log::trace!("ResourceKindVersionDb::find_one: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query =
-      resource_kind_versions::dsl::resource_kind_versions.into_boxed();
-    if let Some(value) = r#where.get("resource_kind_name") {
-      gen_where4string!(
-        query,
-        resource_kind_versions::dsl::resource_kind_name,
-        value
-      );
-    }
-    if let Some(value) = r#where.get("version") {
-      gen_where4string!(query, resource_kind_versions::dsl::version, value);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let items = query
-        .get_result::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(items)
-    })
-  }
-
-  fn find(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Vec<Self::Item>>> {
-    log::trace!("ResourceKindVersionDb::find: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query =
-      resource_kind_versions::dsl::resource_kind_versions.into_boxed();
-    if let Some(value) = r#where.get("resource_kind_name") {
-      gen_where4string!(
-        query,
-        resource_kind_versions::dsl::resource_kind_name,
-        value
-      );
-    }
-    if let Some(value) = r#where.get("version") {
-      gen_where4string!(query, resource_kind_versions::dsl::version, value);
-    }
-    let limit = filter.limit.unwrap_or(100);
-    query = query.limit(limit as i64);
-    if let Some(offset) = filter.offset {
-      query = query.offset(offset as i64);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let items = query
-        .get_results::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(items)
-    })
-  }
-}
-
-impl ResourceKindVersionDb {
-  pub(crate) async fn get_version(
-    name: &str,
-    version: &str,
-    pool: &Pool,
-  ) -> IoResult<ResourceKindVersionDb> {
-    let filter = GenericFilter::new()
-      .r#where("resource_kind_name", GenericClause::Eq(name.to_owned()))
-      .r#where("version", GenericClause::Eq(version.to_owned()));
-    ResourceKindVersionDb::find_one(&filter, pool).await?
-  }
-}
-
 impl From<&ResourceKindPartial> for ResourceKindDb {
   fn from(p: &ResourceKindPartial) -> Self {
     ResourceKindDb {
@@ -161,54 +69,3 @@ impl From<&ResourceKindPartial> for ResourceKindDb {
     }
   }
 }
-
-impl Repository for ResourceKindDb {
-  type Table = resource_kinds::table;
-  type Item = ResourceKindDb;
-  type UpdateItem = ResourceKindDb;
-
-  fn find_one(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Self::Item>> {
-    log::trace!("ResourceKindDb::find_one: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query = resource_kinds::dsl::resource_kinds.into_boxed();
-    if let Some(value) = r#where.get("name") {
-      gen_where4string!(query, resource_kinds::dsl::name, value);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let item = query
-        .get_result::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(item)
-    })
-  }
-
-  fn find(
-    filter: &GenericFilter,
-    pool: &Pool,
-  ) -> JoinHandle<IoResult<Vec<Self::Item>>> {
-    log::trace!("ResourceKindDb::find: {filter:?}");
-    let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query = resource_kinds::dsl::resource_kinds.into_boxed();
-    if let Some(value) = r#where.get("name") {
-      gen_where4string!(query, resource_kinds::dsl::name, value);
-    }
-    let limit = filter.limit.unwrap_or(100);
-    query = query.limit(limit as i64);
-    if let Some(offset) = filter.offset {
-      query = query.offset(offset as i64);
-    }
-    let pool = Arc::clone(pool);
-    ntex::rt::spawn_blocking(move || {
-      let mut conn = utils::store::get_pool_conn(&pool)?;
-      let items = query
-        .get_results::<Self>(&mut conn)
-        .map_err(Self::map_err_context)?;
-      Ok::<_, IoError>(items)
-    })
-  }
-}

bin/nanocld/src/repositories/mod.rs

@@ -2,5 +2,6 @@ mod node;
 mod cargo;
 mod process;
 mod namespace;
+mod resource_kind;
 
 pub mod generic;

bin/nanocld/src/repositories/process.rs

@@ -38,7 +38,7 @@ impl RepositoryDelBy for ProcessDb {
     Self: diesel::associations::HasTable,
   {
     let r#where = filter.r#where.to_owned().unwrap_or_default();
-    let mut query = diesel::delete(processes::dsl::processes).into_boxed();
+    let mut query = diesel::delete(processes::table).into_boxed();
     if let Some(value) = r#where.get("key") {
       gen_where4string!(query, processes::dsl::key, value);
     }

bin/nanocld/src/repositories/resource_kind.rs

@@ -0,0 +1,117 @@
+use diesel::prelude::*;
+
+use nanocl_error::io::IoResult;
+
+use nanocl_stubs::generic::{GenericFilter, GenericClause};
+
+use crate::{
+  gen_where4string,
+  models::{Pool, ResourceKindDb, ResourceKindVersionDb},
+  schema::{resource_kinds, resource_kind_versions},
+};
+
+use super::generic::*;
+
+impl RepositoryBase for ResourceKindDb {}
+
+impl RepositoryCreate for ResourceKindDb {}
+
+impl RepositoryDelByPk for ResourceKindDb {}
+
+impl RepositoryRead for ResourceKindDb {
+  type Output = ResourceKindDb;
+  type Query = resource_kinds::BoxedQuery<'static, diesel::pg::Pg>;
+
+  fn gen_read_query(filter: &GenericFilter, is_multiple: bool) -> Self::Query {
+    let r#where = filter.r#where.to_owned().unwrap_or_default();
+    let mut query = resource_kinds::dsl::resource_kinds.into_boxed();
+    if let Some(value) = r#where.get("name") {
+      gen_where4string!(query, resource_kinds::dsl::name, value);
+    }
+    if is_multiple {
+      query = query.order(resource_kinds::dsl::created_at.desc());
+      let limit = filter.limit.unwrap_or(100);
+      query = query.limit(limit as i64);
+      if let Some(offset) = filter.offset {
+        query = query.offset(offset as i64);
+      }
+    }
+    query
+  }
+}
+
+impl RepositoryBase for ResourceKindVersionDb {}
+
+impl RepositoryCreate for ResourceKindVersionDb {}
+
+impl RepositoryDelByPk for ResourceKindVersionDb {}
+
+impl RepositoryRead for ResourceKindVersionDb {
+  type Output = ResourceKindVersionDb;
+  type Query = resource_kind_versions::BoxedQuery<'static, diesel::pg::Pg>;
+
+  fn gen_read_query(filter: &GenericFilter, is_multiple: bool) -> Self::Query {
+    let r#where = filter.r#where.to_owned().unwrap_or_default();
+    let mut query =
+      resource_kind_versions::dsl::resource_kind_versions.into_boxed();
+    if let Some(value) = r#where.get("resource_kind_name") {
+      gen_where4string!(
+        query,
+        resource_kind_versions::dsl::resource_kind_name,
+        value
+      );
+    }
+    if let Some(value) = r#where.get("version") {
+      gen_where4string!(query, resource_kind_versions::dsl::version, value);
+    }
+    if is_multiple {
+      query = query.order(resource_kind_versions::dsl::created_at.desc());
+      let limit = filter.limit.unwrap_or(100);
+      query = query.limit(limit as i64);
+      if let Some(offset) = filter.offset {
+        query = query.offset(offset as i64);
+      }
+    }
+    query
+  }
+}
+
+impl RepositoryDelBy for ResourceKindVersionDb {
+  fn gen_del_query(
+    filter: &GenericFilter,
+  ) -> diesel::query_builder::BoxedDeleteStatement<
+    'static,
+    diesel::pg::Pg,
+    <Self as diesel::associations::HasTable>::Table,
+  >
+  where
+    Self: diesel::associations::HasTable,
+  {
+    let r#where = filter.r#where.to_owned().unwrap_or_default();
+    let mut query = diesel::delete(resource_kind_versions::table).into_boxed();
+    if let Some(value) = r#where.get("resource_kind_name") {
+      gen_where4string!(
+        query,
+        resource_kind_versions::dsl::resource_kind_name,
+        value
+      );
+    }
+    if let Some(value) = r#where.get("version") {
+      gen_where4string!(query, resource_kind_versions::dsl::version, value);
+    }
+    query
+  }
+}
+
+impl ResourceKindVersionDb {
+  pub(crate) async fn get_version(
+    name: &str,
+    version: &str,
+    pool: &Pool,
+  ) -> IoResult<ResourceKindVersionDb> {
+    let filter = GenericFilter::new()
+      .r#where("resource_kind_name", GenericClause::Eq(name.to_owned()))
+      .r#where("version", GenericClause::Eq(version.to_owned()));
+    ResourceKindVersionDb::read_one(&filter, pool).await?
+  }
+}

bin/nanocld/src/utils/resource.rs

@@ -7,11 +7,15 @@ use nanocl_error::http::{HttpError, HttpResult};
 use nanocl_stubs::{
   system::EventAction,
   resource::{Resource, ResourcePartial},
+  generic::{GenericFilter, GenericClause},
 };
 
-use crate::models::{
-  Pool, ResourceKindPartial, DaemonState, ResourceKindVersionDb, Repository,
-  ResourceKindDb, ResourceSpecDb, ResourceDb,
+use crate::{
+  repositories::generic::*,
+  models::{
+    Pool, ResourceKindPartial, DaemonState, ResourceKindVersionDb, Repository,
+    ResourceKindDb, ResourceSpecDb, ResourceDb,
+  },
 };
 
 use super::ctrl_client::CtrlClient;
@@ -43,13 +47,13 @@ async fn hook_create_resource(
       if resource_kind.schema.is_none() && resource_kind.url.is_none() {
         return Err(HttpError::bad_request("Neither schema nor url provided"));
       }
-      if ResourceKindDb::find_by_pk(&resource.name, pool)
+      if ResourceKindDb::read_by_pk(&resource.name, pool)
         .await?
         .is_err()
       {
-        ResourceKindDb::create(&resource_kind, pool).await??;
+        ResourceKindDb::create_from(&resource_kind, pool).await??;
       }
-      ResourceKindVersionDb::create(&resource_kind, pool).await??;
+      ResourceKindVersionDb::create_from(&resource_kind, pool).await??;
     }
     _ => {
       let kind = ResourceKindVersionDb::get_version(
@@ -156,13 +160,12 @@ pub(crate) async fn delete(
     log::warn!("{err}");
   }
   if resource.kind.as_str() == "Kind" {
-    ResourceKindVersionDb::delete_by(
-      crate::schema::resource_kind_versions::dsl::resource_kind_name
-        .eq(resource.spec.resource_key.to_owned()),
-      &state.pool,
-    )
-    .await??;
-    ResourceKindDb::delete_by_pk(&resource.spec.resource_key, &state.pool)
+    let filter = GenericFilter::new().r#where(
+      "resource_kind_name",
+      GenericClause::Eq(resource.spec.resource_key.to_owned()),
+    );
+    ResourceKindVersionDb::del_by(&filter, &state.pool).await??;
+    ResourceKindDb::del_by_pk(&resource.spec.resource_key, &state.pool)
       .await??;
   }
   ResourceDb::delete_by_pk(&resource.spec.resource_key, &state.pool).await??;