feat: implement ProjectCacheManager for efficient project resolution

- Add ProjectCacheManager with TTL and LRU support
- Remove redundant resolved_projects field from AccessControl
- Use DashMap for high-performance concurrent access
- Implement bidirectional caching (ID ↔ Key ↔ Project)
- Configure with 5-minute TTL and 1000 project capacity
- Update add_issue_impl to use project cache for key resolution

This improves performance by reducing API calls for project resolution
and provides a centralized caching system with advanced features.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Yuji Matsumoto

Cargo.lock

@@ -31,6 +31,7 @@ backlog-domain-models = { path = "../crates/backlog-domain-models" } # For Custo
 schemars = { workspace = true, features = ["derive"] } # For JsonSchema derive
 strsim = "0.11.1"
 base64 = { workspace = true } # Added for base64 encoding
+dashmap = "6.1"
 
 [dev-dependencies]
-# wiremock = { workspace = true }
+wiremock = { workspace = true }

backlog-mcp-server/Cargo.toml

@@ -1,20 +1,20 @@
 use crate::error::Error;
+use crate::project_cache::{CacheConfig, ProjectCacheManager};
 use backlog_api_client::client::BacklogApiClient;
 use backlog_core::identifier::ProjectId;
 use backlog_core::{ProjectIdOrKey, ProjectKey};
-use std::collections::HashMap;
 use std::env;
 use std::str::FromStr;
 use std::sync::Arc;
-use tokio::sync::RwLock;
+use std::time::Duration;
 
 /// Structure to manage project access control
 #[derive(Debug, Clone)]
 pub struct AccessControl {
     /// Allowed project keys from environment variable
     allowed_projects: Option<Vec<ProjectKey>>,
-    /// Resolved project mappings (ProjectId -> ProjectKey)
-    resolved_projects: Arc<RwLock<HashMap<ProjectId, ProjectKey>>>,
+    /// Project cache manager
+    project_cache: Arc<ProjectCacheManager>,
 }
 
 impl AccessControl {
@@ -39,9 +39,16 @@ impl AccessControl {
             None
         };
 
+        // キャッシュ設定（5分のTTL、最大1000プロジェクト）
+        let cache_config = CacheConfig {
+            ttl: Some(Duration::from_secs(300)),
+            max_size: Some(1000),
+        };
+        let project_cache = Arc::new(ProjectCacheManager::with_config(cache_config));
+
         Ok(Self {
             allowed_projects,
-            resolved_projects: Arc::new(RwLock::new(HashMap::new())),
+            project_cache,
         })
     }
 
@@ -51,18 +58,16 @@ impl AccessControl {
         project_id: &ProjectId,
         client: &BacklogApiClient,
     ) -> Result<ProjectKey, Error> {
-        use backlog_project::GetProjectDetailParams;
-
-        let params = GetProjectDetailParams::new(ProjectIdOrKey::Id(*project_id));
-        let project = client.project().get_project(params).await.map_err(|e| {
-            Error::Parameter(format!("Failed to resolve project ID '{project_id}': {e}"))
-        })?;
-
-        // Store the resolved project
-        let mut resolved_map = self.resolved_projects.write().await;
-        resolved_map.insert(project.id, project.project_key.clone());
-
-        Ok(project.project_key)
+        // キャッシュから取得
+        let project = self
+            .project_cache
+            .get_by_id(project_id, client)
+            .await
+            .map_err(|e| {
+                Error::Parameter(format!("Failed to resolve project ID '{project_id}': {e}"))
+            })?;
+
+        Ok(project.project_key.clone())
     }
 
     /// Check access permissions for the specified project ID (async version)
@@ -77,22 +82,17 @@ impl AccessControl {
         }
         let allowed_keys = self.allowed_projects.as_ref().unwrap();
 
-        // Check if this project ID is already resolved
-        {
-            let resolved_map = self.resolved_projects.read().await;
-            if let Some(project_key) = resolved_map.get(project_id) {
-                if allowed_keys.contains(project_key) {
-                    return Ok(());
-                }
+        // Check if this project ID is in cache
+        if let Some(project) = self.project_cache.get_from_cache_by_id(project_id).await {
+            if allowed_keys.contains(&project.project_key) {
+                return Ok(());
             }
         }
 
-        // If not resolved and not in unresolved list, try to resolve it
-        if let Some(allowed_keys) = &self.allowed_projects {
-            if let Ok(project_key) = self.resolve_project_by_id(project_id, client).await {
-                if allowed_keys.contains(&project_key) {
-                    return Ok(());
-                }
+        // If not in cache, try to resolve it
+        if let Ok(project_key) = self.resolve_project_by_id(project_id, client).await {
+            if allowed_keys.contains(&project_key) {
+                return Ok(());
             }
         }
 
@@ -143,6 +143,11 @@ impl AccessControl {
         self.allowed_projects.is_some()
     }
 
+    /// Get the project cache manager
+    pub fn project_cache(&self) -> &Arc<ProjectCacheManager> {
+        &self.project_cache
+    }
+
     // Synchronous versions for backward compatibility (will be removed)
 
     /// Check access permissions for the specified project ID (synchronous - for tests only)
@@ -197,9 +202,15 @@ impl AccessControl {
 
 impl Default for AccessControl {
     fn default() -> Self {
-        Self::new().unwrap_or(Self {
-            allowed_projects: None,
-            resolved_projects: Arc::new(RwLock::new(HashMap::new())),
+        Self::new().unwrap_or_else(|_| {
+            let cache_config = CacheConfig {
+                ttl: Some(Duration::from_secs(300)),
+                max_size: Some(1000),
+            };
+            Self {
+                allowed_projects: None,
+                project_cache: Arc::new(ProjectCacheManager::with_config(cache_config)),
+            }
         })
     }
 }

backlog-mcp-server/src/access_control.rs

@@ -353,21 +353,13 @@ pub(crate) async fn add_issue_impl(
 
     let client_guard = client.lock().await;
 
-    // Resolve project ID if a key was provided
     let project_id = match &project_id_or_key {
         ProjectIdOrKey::Id(id) => *id,
         ProjectIdOrKey::Key(key) => {
-            // Get project list and find by key
-            let projects = client_guard
-                .project()
-                .get_project_list(backlog_project::GetProjectListParams::default())
+            let project = access_control
+                .project_cache()
+                .get_by_key(key, &client_guard)
                 .await?;
-            let project = projects
-                .iter()
-                .find(|p| &p.project_key == key)
-                .ok_or_else(|| {
-                    McpError::ProjectNotFound(format!("Project with key '{key}' not found"))
-                })?;
             project.id
         }
         ProjectIdOrKey::EitherIdOrKey(id, _) => *id,

backlog-mcp-server/src/issue/bridge.rs

@@ -7,6 +7,7 @@ pub mod file;
 pub mod git;
 pub mod issue;
 pub mod project;
+pub(crate) mod project_cache;
 mod server;
 pub mod user;
 mod util;