feat(backend): add crate for lock service

Cargo.toml

@@ -31,6 +31,7 @@ members = [
     "crates/services/importer",
     "crates/services/integration",
     "crates/services/jwt",
+    "crates/services/lock",
     "crates/services/miscellaneous",
     "crates/services/notification",
     "crates/services/statistics",
@@ -144,6 +145,7 @@ serde_with = { version = "=3.11.0", features = ["chrono_0_4"] }
 serde-xml-rs = "=0.6.0"
 slug = "=0.1.6"
 sonarr-api-rs = "=3.0.0"
+sqlx = "=0.8.2"
 strum = { version = "=0.26.3", features = ["derive"] }
 struson = { version = "=0.6.0", features = ["serde"] }
 reqwest = { version = "=0.12.9", features = ["json", "stream"] }

apps/backend/Cargo.toml

@@ -36,6 +36,7 @@ importer-resolver = { path = "../../crates/resolvers/importer" }
 importer-service = { path = "../../crates/services/importer" }
 integration-service = { path = "../../crates/services/integration" }
 itertools = { workspace = true }
+lock-service = { path = "../../crates/services/lock" }
 logs-wheel = { workspace = true }
 migrations = { path = "../../crates/migrations" }
 miscellaneous-resolver = { path = "../../crates/resolvers/miscellaneous" }

apps/backend/src/common.rs

@@ -26,6 +26,7 @@ use importer_resolver::{ImporterMutation, ImporterQuery};
 use importer_service::ImporterService;
 use integration_service::IntegrationService;
 use itertools::Itertools;
+use lock_service::LockService;
 use miscellaneous_resolver::{MiscellaneousMutation, MiscellaneousQuery};
 use miscellaneous_service::MiscellaneousService;
 use openidconnect::{
@@ -71,10 +72,12 @@ pub async fn create_app_services(
         config.file_storage.s3_bucket_name.clone(),
     ));
     let cache_service = CacheService::new(&db, config.clone());
+    let lock_service = LockService::new(&db);
     let supporting_service = Arc::new(
         SupportingService::new(
             &db,
             timezone,
+            lock_service,
             cache_service,
             config.clone(),
             oidc_client,

crates/services/lock/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "lock-service"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+async-graphql = { workspace = true }
+chrono = { workspace = true }
+common-models = { path = "../../models/common" }
+common-utils = { path = "../../utils/common" }
+config = { path = "../../config" }
+database-models = { path = "../../models/database" }
+dependent-models = { path = "../../models/dependent" }
+env-utils = { path = "../../utils/env" }
+sea-orm = { workspace = true }
+sea-query = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+sqlx = { workspace = true }
+tracing = { workspace = true }
+uuid = { workspace = true }
+
+[package.metadata.cargo-machete]
+ignored = ["serde", "tracing"]

crates/services/lock/src/lib.rs

@@ -0,0 +1,19 @@
+use async_graphql::Result;
+use common_models::ApplicationCacheKey;
+use sea_orm::DatabaseConnection;
+
+pub struct LockService {
+    db: DatabaseConnection,
+}
+
+impl LockService {
+    pub fn new(db: &DatabaseConnection) -> Self {
+        Self { db: db.clone() }
+    }
+}
+
+impl LockService {
+    pub async fn acquire_lock(&self, key: ApplicationCacheKey) -> Result<bool> {
+        todo!()
+    }
+}

crates/services/supporting/Cargo.toml

@@ -20,6 +20,7 @@ env-utils = { path = "../../utils/env" }
 file-storage-service = { path = "../../services/file-storage" }
 isolang = { workspace = true }
 itertools = { workspace = true }
+lock-service = { path = "../../services/lock" }
 openidconnect = { workspace = true }
 rustypipe = { workspace = true }
 sea-orm = { workspace = true }

crates/services/supporting/src/lib.rs

@@ -22,6 +22,7 @@ use enum_models::{
 use env_utils::{APP_VERSION, UNKEY_API_ID};
 use file_storage_service::FileStorageService;
 use itertools::Itertools;
+use lock_service::LockService;
 use openidconnect::core::CoreClient;
 use rustypipe::param::{Language, LANGUAGES};
 use sea_orm::{DatabaseConnection, EntityTrait, Iterable, PaginatorTrait};
@@ -31,6 +32,7 @@ use unkey::{models::VerifyKeyRequest, Client};
 pub struct SupportingService {
     pub db: DatabaseConnection,
     pub timezone: chrono_tz::Tz,
+    pub lock_service: LockService,
     pub cache_service: CacheService,
     pub config: Arc<config::AppConfig>,
     pub oidc_client: Option<CoreClient>,
@@ -46,6 +48,7 @@ impl SupportingService {
     pub async fn new(
         db: &DatabaseConnection,
         timezone: chrono_tz::Tz,
+        lock_service: LockService,
         cache_service: CacheService,
         config: Arc<config::AppConfig>,
         oidc_client: Option<CoreClient>,
@@ -58,6 +61,7 @@ impl SupportingService {
             config,
             timezone,
             oidc_client,
+            lock_service,
             cache_service,
             db: db.clone(),
             file_storage_service,