Skip to main content

snip_sync/
lib.rs

1// The `format!("{}", var)` patterns below are inherited from the
2// pre-existing main.rs implementation. They were not flagged by clippy
3// when the code lived in a binary crate's `#[cfg(test)] mod tests`
4// (binary test targets are not always checked by `cargo clippy
5// --all-targets`), but moving the code into the library makes them
6// visible to lib test compilation. The lint suppression keeps the
7// refactor minimal; a follow-up should inline the args.
8//
9// Similarly, `RateLimiter::new()` and a few other constructors predate
10// the refactor and never carried a `Default` impl. Suppressing
11// `new_without_default` here keeps the diff focused.
12#![allow(clippy::uninlined_format_args, clippy::new_without_default)]
13
14pub mod db;
15pub mod metrics;
16pub mod premade;
17pub mod rate_limiter;
18#[cfg(any(test, feature = "test-helpers"))]
19pub mod test_helpers;
20
21pub use db::Database;
22pub use metrics::Metrics;
23pub use premade::PremadeManager;
24pub use rate_limiter::RateLimiter;
25
26use serde::Deserialize;
27use snip_proto::{
28    CreateLibraryRequest, CreateLibraryResponse, DeleteLibraryRequest, DeleteLibraryResponse,
29    GetPremadeLibraryRequest, GetPremadeLibraryResponse, GetSnippetsRequest, HealthRequest,
30    HealthResponse, Library, ListLibrariesRequest, ListLibrariesResponse,
31    ListPremadeLibrariesRequest, ListPremadeLibrariesResponse,
32    PremadeLibrary as ProtoPremadeLibrary, PushSnippetsRequest, PushSnippetsResponse,
33    RegisterRequest, RegisterResponse, SearchPremadeLibrariesRequest,
34    SearchPremadeLibrariesResponse, Snippet as ProtoSnippet, SnippetList, SyncRequest,
35    SyncResponse, snippet_sync_server::SnippetSync,
36};
37use std::net::SocketAddr;
38use std::path::PathBuf;
39use std::sync::Arc;
40use std::time::Duration;
41use tonic::{Request, Response, Status};
42
43/// Extract the API key from a gRPC request's `authorization` metadata.
44/// Falls back to the body `api_key` field for backward compatibility.
45pub fn extract_api_key<T>(request: &Request<T>, body_api_key: &str) -> String {
46    request
47        .metadata()
48        .get("authorization")
49        .and_then(|v| v.to_str().ok())
50        .and_then(|v| v.strip_prefix("Bearer "))
51        .filter(|v| !v.is_empty())
52        .unwrap_or(body_api_key)
53        .to_string()
54}
55
56fn strip_port(addr: &str) -> String {
57    if let Some(close_bracket) = addr.find("]:") {
58        return addr[1..close_bracket].to_string();
59    }
60    // Bare IPv6 addresses contain multiple colons but no brackets.
61    // They have no port to strip, so return as-is.
62    if !addr.starts_with('[') && addr.matches(':').count() > 1 {
63        return addr.to_string();
64    }
65    if let Some(colon_pos) = addr.rfind(':')
66        && !addr.starts_with('[')
67    {
68        return addr[..colon_pos].to_string();
69    }
70    addr.to_string()
71}
72
73pub const DEFAULT_MAX_COMMAND_LENGTH: usize = 1024;
74pub const DEFAULT_MAX_DESCRIPTION_LENGTH: usize = 1024;
75pub const DEFAULT_MAX_TAGS: usize = 50;
76pub const DEFAULT_MAX_TAG_LENGTH: usize = 100;
77pub const DEFAULT_MAX_ID_LENGTH: usize = 128;
78pub const DEFAULT_MAX_DEVICE_ID_LENGTH: usize = 128;
79pub const DEFAULT_MAX_API_KEY_LENGTH: usize = 512;
80pub const DEFAULT_MAX_SYNC_SNIPPETS: usize = 10000;
81pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30;
82pub const DEFAULT_RATE_LIMIT_PER_MINUTE: u32 = 120;
83pub const DEFAULT_DB_MAX_CONNECTIONS: u32 = 5;
84pub const DEFAULT_GRPC_MAX_MESSAGE_SIZE: u32 = 4 * 1024 * 1024; // 4 MiB
85pub const MAX_REQUEST_LIMIT: i32 = 1000;
86
87#[derive(Deserialize, Default)]
88pub struct ConfigFile {
89    pub server: Option<ServerConfig>,
90}
91
92#[derive(Deserialize, Default)]
93pub struct ServerConfig {
94    pub grpc_host: Option<String>,
95    pub grpc_port: Option<u16>,
96    pub http_host: Option<String>,
97    pub http_port: Option<u16>,
98    pub database: Option<DatabaseConfig>,
99    pub premade: Option<PremadeConfig>,
100    pub limits: Option<LimitsConfig>,
101    pub rate_limit: Option<RateLimitConfig>,
102    pub metrics: Option<MetricsConfig>,
103    pub cors: Option<CorsConfig>,
104}
105
106#[derive(Deserialize, Default)]
107pub struct DatabaseConfig {
108    pub path: Option<String>,
109    pub max_connections: Option<u32>,
110}
111
112#[derive(Deserialize, Default)]
113pub struct PremadeConfig {
114    pub directory: Option<String>,
115}
116
117#[derive(Deserialize, Default)]
118pub struct LimitsConfig {
119    pub max_command_length: Option<usize>,
120    pub max_description_length: Option<usize>,
121    pub max_tags: Option<usize>,
122    pub max_tag_length: Option<usize>,
123    pub max_id_length: Option<usize>,
124    pub max_device_id_length: Option<usize>,
125    pub max_api_key_length: Option<usize>,
126    pub request_timeout_secs: Option<u64>,
127    pub grpc_max_message_size: Option<u32>,
128}
129
130#[derive(Deserialize, Default)]
131pub struct RateLimitConfig {
132    pub requests_per_minute: Option<u32>,
133    pub trusted_proxies: Option<Vec<String>>,
134    pub persist: Option<bool>,
135}
136
137#[derive(Deserialize, Default)]
138pub struct MetricsConfig {
139    pub username: Option<String>,
140    pub password: Option<String>,
141}
142
143#[derive(Deserialize, Default)]
144pub struct CorsConfig {
145    pub allowed_origins: Option<String>,
146}
147
148#[derive(Clone)]
149pub struct Config {
150    pub grpc_host: String,
151    pub grpc_port: u16,
152    pub http_host: String,
153    pub http_port: u16,
154    pub db_path: String,
155    pub db_max_connections: u32,
156    pub premade_dir: PathBuf,
157    pub max_command_length: usize,
158    pub max_description_length: usize,
159    pub max_tags: usize,
160    pub max_tag_length: usize,
161    pub max_id_length: usize,
162    pub max_device_id_length: usize,
163    pub max_api_key_length: usize,
164    pub request_timeout_secs: u64,
165    pub grpc_max_message_size: u32,
166    pub rate_limit_per_minute: u32,
167    pub trusted_proxies: Vec<String>,
168    pub persist_rate_limits: bool,
169    pub metrics_username: Option<String>,
170    pub metrics_password: Option<String>,
171    pub cors_allowed_origins: Vec<String>,
172}
173
174impl Config {
175    pub fn load() -> Self {
176        let config_path = std::env::var("CONFIG_PATH")
177            .map(PathBuf::from)
178            .unwrap_or_else(|_| PathBuf::from("config.toml"));
179
180        let config_file = if config_path.exists() {
181            match std::fs::read_to_string(&config_path) {
182                Ok(content) => match toml::from_str(&content) {
183                    Ok(c) => c,
184                    Err(e) => {
185                        tracing::error!(
186                            "Failed to parse config file {}: {}. Using defaults. Fix the config file or remove it to regenerate.",
187                            config_path.display(),
188                            e
189                        );
190                        ConfigFile::default()
191                    }
192                },
193                Err(e) => {
194                    tracing::error!(
195                        "Failed to read config file {}: {}. Using defaults.",
196                        config_path.display(),
197                        e
198                    );
199                    ConfigFile::default()
200                }
201            }
202        } else {
203            ConfigFile::default()
204        };
205
206        let server = config_file.server.unwrap_or_default();
207
208        Self {
209            grpc_host: std::env::var("GRPC_HOST")
210                .ok()
211                .or_else(|| server.grpc_host.clone())
212                .unwrap_or_else(|| "127.0.0.1".to_string()),
213            grpc_port: std::env::var("GRPC_PORT")
214                .ok()
215                .and_then(|v| v.parse().ok())
216                .or(server.grpc_port)
217                .unwrap_or(50051),
218            http_host: std::env::var("HTTP_HOST")
219                .ok()
220                .or_else(|| server.http_host.clone())
221                .unwrap_or_else(|| "127.0.0.1".to_string()),
222            http_port: std::env::var("HTTP_PORT")
223                .ok()
224                .and_then(|v| v.parse().ok())
225                .or(server.http_port)
226                .unwrap_or(50050),
227            db_path: std::env::var("DATABASE_URL")
228                .ok()
229                .or_else(|| server.database.as_ref().and_then(|d| d.path.clone()))
230                .unwrap_or_else(|| {
231                    dirs::home_dir()
232                        .unwrap_or_else(|| PathBuf::from("."))
233                        .join(".config")
234                        .join("snip-sync")
235                        .join("snippets.db")
236                        .to_string_lossy()
237                        .into_owned()
238                }),
239            db_max_connections: std::env::var("DB_MAX_CONNECTIONS")
240                .ok()
241                .and_then(|v| v.parse().ok())
242                .or(server.database.as_ref().and_then(|d| d.max_connections))
243                .unwrap_or(DEFAULT_DB_MAX_CONNECTIONS),
244            premade_dir: std::env::var("PREMADE_DIR")
245                .map(PathBuf::from)
246                .ok()
247                .or_else(|| {
248                    server
249                        .premade
250                        .as_ref()
251                        .and_then(|p| p.directory.clone())
252                        .map(PathBuf::from)
253                })
254                .unwrap_or_else(|| PathBuf::from("premade-libraries")),
255            max_command_length: std::env::var("MAX_COMMAND_LENGTH")
256                .ok()
257                .and_then(|v| v.parse().ok())
258                .or(server.limits.as_ref().and_then(|l| l.max_command_length))
259                .unwrap_or(DEFAULT_MAX_COMMAND_LENGTH),
260            max_description_length: std::env::var("MAX_DESCRIPTION_LENGTH")
261                .ok()
262                .and_then(|v| v.parse().ok())
263                .or(server
264                    .limits
265                    .as_ref()
266                    .and_then(|l| l.max_description_length))
267                .unwrap_or(DEFAULT_MAX_DESCRIPTION_LENGTH),
268            max_tags: std::env::var("MAX_TAGS")
269                .ok()
270                .and_then(|v| v.parse().ok())
271                .or(server.limits.as_ref().and_then(|l| l.max_tags))
272                .unwrap_or(DEFAULT_MAX_TAGS),
273            max_tag_length: std::env::var("MAX_TAG_LENGTH")
274                .ok()
275                .and_then(|v| v.parse().ok())
276                .or(server.limits.as_ref().and_then(|l| l.max_tag_length))
277                .unwrap_or(DEFAULT_MAX_TAG_LENGTH),
278            max_id_length: std::env::var("MAX_ID_LENGTH")
279                .ok()
280                .and_then(|v| v.parse().ok())
281                .or(server.limits.as_ref().and_then(|l| l.max_id_length))
282                .unwrap_or(DEFAULT_MAX_ID_LENGTH),
283            max_device_id_length: std::env::var("MAX_DEVICE_ID_LENGTH")
284                .ok()
285                .and_then(|v| v.parse().ok())
286                .or(server.limits.as_ref().and_then(|l| l.max_device_id_length))
287                .unwrap_or(DEFAULT_MAX_DEVICE_ID_LENGTH),
288            max_api_key_length: std::env::var("MAX_API_KEY_LENGTH")
289                .ok()
290                .and_then(|v| v.parse().ok())
291                .or(server.limits.as_ref().and_then(|l| l.max_api_key_length))
292                .unwrap_or(DEFAULT_MAX_API_KEY_LENGTH),
293            request_timeout_secs: std::env::var("REQUEST_TIMEOUT_SECS")
294                .ok()
295                .and_then(|v| v.parse().ok())
296                .or(server.limits.as_ref().and_then(|l| l.request_timeout_secs))
297                .unwrap_or(DEFAULT_REQUEST_TIMEOUT_SECS),
298            grpc_max_message_size: std::env::var("GRPC_MAX_MESSAGE_SIZE")
299                .ok()
300                .and_then(|v| v.parse().ok())
301                .or(server.limits.as_ref().and_then(|l| l.grpc_max_message_size))
302                .unwrap_or(DEFAULT_GRPC_MAX_MESSAGE_SIZE),
303            rate_limit_per_minute: std::env::var("RATE_LIMIT_PER_MINUTE")
304                .ok()
305                .and_then(|v| v.parse().ok())
306                .or(server
307                    .rate_limit
308                    .as_ref()
309                    .and_then(|r| r.requests_per_minute))
310                .unwrap_or(DEFAULT_RATE_LIMIT_PER_MINUTE),
311            trusted_proxies: std::env::var("TRUSTED_PROXIES")
312                .ok()
313                .map(|v| {
314                    v.split(',')
315                        .map(|s| s.trim().to_string())
316                        .filter(|s| !s.is_empty() && s.parse::<std::net::IpAddr>().is_ok())
317                        .collect()
318                })
319                .or_else(|| server.rate_limit.as_ref()?.trusted_proxies.clone())
320                .unwrap_or_default(),
321            persist_rate_limits: std::env::var("PERSIST_RATE_LIMITS")
322                .ok()
323                .map(|v| v == "true" || v == "1")
324                .or(server.rate_limit.as_ref().and_then(|r| r.persist))
325                .unwrap_or(false),
326            metrics_username: std::env::var("METRICS_USERNAME")
327                .ok()
328                .or_else(|| server.metrics.as_ref().and_then(|m| m.username.clone())),
329            metrics_password: std::env::var("METRICS_PASSWORD")
330                .ok()
331                .or_else(|| server.metrics.as_ref().and_then(|m| m.password.clone())),
332            cors_allowed_origins: std::env::var("CORS_ALLOWED_ORIGINS")
333                .ok()
334                .or_else(|| server.cors.as_ref().and_then(|c| c.allowed_origins.clone()))
335                .map(|v| v.split(',').map(|s| s.trim().to_string()).collect())
336                .unwrap_or_default(),
337        }
338    }
339
340    pub fn ensure_config_file() {
341        let config_path = std::env::var("CONFIG_PATH")
342            .map(PathBuf::from)
343            .unwrap_or_else(|_| PathBuf::from("config.toml"));
344
345        if !config_path.exists() {
346            let default_config = include_str!("../config.toml");
347            if let Err(e) = std::fs::write(&config_path, default_config) {
348                tracing::warn!("Failed to create default config file: {}", e);
349            } else {
350                tracing::info!("Created default config file at {}", config_path.display());
351            }
352        }
353    }
354}
355
356#[derive(Clone)]
357pub struct AppState {
358    pub config: Config,
359    pub metrics: Metrics,
360    pub db: Arc<Database>,
361}
362
363pub struct SnipSyncService {
364    pub db: Arc<Database>,
365    pub rate_limiter: Arc<RateLimiter>,
366    pub config: Config,
367    pub metrics: Metrics,
368    pub premade_manager: PremadeManager,
369    /// Test-only: most recent `authorization` header value observed by
370    /// the gRPC handlers. Used by integration tests to assert that the
371    /// sync client actually sends a non-empty bearer token in metadata
372    /// (catching the auth-header regression where `request.api_key` was
373    /// read instead of the caller's API key).
374    pub captured_auth_header: Arc<std::sync::Mutex<Option<String>>>,
375}
376
377impl SnipSyncService {
378    pub fn record_request(&self, method: &str) {
379        self.metrics
380            .requests_total
381            .with_label_values(&[method])
382            .inc();
383        tracing::trace!("Request: {}", method);
384    }
385
386    pub fn record_request_duration(&self, method: &str, start: std::time::Instant) {
387        let duration = start.elapsed().as_secs_f64();
388        self.metrics
389            .request_duration_seconds
390            .with_label_values(&[method])
391            .observe(duration);
392        tracing::debug!("Request {} completed in {:.3}s", method, duration);
393    }
394
395    pub fn record_rate_limit(&self) {
396        self.metrics.rate_limit_hits.inc();
397    }
398
399    pub fn record_auth_failure(&self) {
400        self.metrics.auth_failures.inc();
401    }
402
403    pub fn record_sync(&self, direction: &str) {
404        self.metrics
405            .sync_operations_total
406            .with_label_values(&[direction])
407            .inc();
408    }
409
410    pub fn record_library_op(&self, operation: &str) {
411        self.metrics
412            .library_operations_total
413            .with_label_values(&[operation])
414            .inc();
415    }
416
417    fn capture_auth_header<T>(&self, request: &Request<T>, body_api_key: &str) -> String {
418        let api_key = extract_api_key(request, body_api_key);
419        if !api_key.is_empty() {
420            let mut slot = self
421                .captured_auth_header
422                .lock()
423                .unwrap_or_else(|e| e.into_inner());
424            if slot.is_none() {
425                *slot = Some(format!("Bearer {api_key}"));
426            }
427        }
428        api_key
429    }
430
431    pub async fn authenticate_and_rate_limit(&self, api_key: &str) -> Result<String, Status> {
432        self.authenticate_and_rate_limit_with_duration(api_key, None)
433            .await
434    }
435
436    /// Like `authenticate_and_rate_limit`, but records request duration on
437    /// failure so the histogram captures latency for error responses.
438    pub async fn authenticate_and_rate_limit_with_duration(
439        &self,
440        api_key: &str,
441        start: Option<std::time::Instant>,
442    ) -> Result<String, Status> {
443        if api_key.is_empty() {
444            if let Some(s) = start {
445                self.record_request_duration("auth", s);
446            }
447            return Err(Status::unauthenticated("API key is required"));
448        }
449        if api_key.len() > self.config.max_api_key_length {
450            if let Some(s) = start {
451                self.record_request_duration("auth", s);
452            }
453            return Err(Status::invalid_argument(format!(
454                "API key exceeds maximum length of {} bytes",
455                self.config.max_api_key_length
456            )));
457        }
458
459        if !self
460            .rate_limiter
461            .allow(
462                api_key,
463                self.config.rate_limit_per_minute as usize,
464                Duration::from_secs(60),
465            )
466            .await
467        {
468            self.record_rate_limit();
469            if let Some(s) = start {
470                self.record_request_duration("auth", s);
471            }
472            return Err(Status::resource_exhausted("Rate limit exceeded"));
473        }
474
475        let user_id = self
476            .db
477            .get_user_by_api_key(api_key)
478            .await
479            .map_err(|_| {
480                if let Some(s) = start {
481                    self.record_request_duration("auth", s);
482                }
483                Status::internal("Internal error")
484            })?
485            .ok_or_else(|| {
486                self.record_auth_failure();
487                if let Some(s) = start {
488                    self.record_request_duration("auth", s);
489                }
490                Status::unauthenticated("Invalid API key")
491            })?;
492
493        Ok(user_id)
494    }
495
496    pub fn validate_snippet(&self, snippet: &ProtoSnippet) -> Result<(), Status> {
497        if snippet.id.is_empty() {
498            return Err(Status::invalid_argument("Snippet ID is required"));
499        }
500        if snippet.id.len() > self.config.max_id_length {
501            return Err(Status::invalid_argument(format!(
502                "Snippet ID exceeds maximum length of {} bytes",
503                self.config.max_id_length
504            )));
505        }
506
507        if snippet.device_id.is_empty() {
508            return Err(Status::invalid_argument("Device ID is required"));
509        }
510        if snippet.device_id.len() > self.config.max_device_id_length {
511            return Err(Status::invalid_argument(format!(
512                "Device ID exceeds maximum length of {} bytes",
513                self.config.max_device_id_length
514            )));
515        }
516
517        if !snippet.encrypted && snippet.command.len() > self.config.max_command_length {
518            return Err(Status::invalid_argument(format!(
519                "Command exceeds maximum length of {} bytes",
520                self.config.max_command_length
521            )));
522        }
523
524        if !snippet.encrypted && snippet.command.trim().is_empty() {
525            return Err(Status::invalid_argument("Snippet command is required"));
526        }
527
528        if snippet.encrypted && (snippet.command.is_empty() || snippet.command.trim().is_empty()) {
529            return Err(Status::invalid_argument(
530                "Encrypted snippet payload is required",
531            ));
532        }
533
534        if snippet.description.len() > self.config.max_description_length {
535            return Err(Status::invalid_argument(format!(
536                "Description exceeds maximum length of {} bytes",
537                self.config.max_description_length
538            )));
539        }
540
541        if snippet.tags.len() > self.config.max_tags {
542            return Err(Status::invalid_argument(format!(
543                "Too many tags (max {})",
544                self.config.max_tags
545            )));
546        }
547
548        for tag in &snippet.tags {
549            if tag.len() > self.config.max_tag_length {
550                return Err(Status::invalid_argument(format!(
551                    "Tag '{}' exceeds maximum length of {} bytes",
552                    tag, self.config.max_tag_length
553                )));
554            }
555        }
556
557        let now = chrono::Utc::now().timestamp();
558        if snippet.updated_at > now + 300 {
559            return Err(Status::invalid_argument(
560                "Updated timestamp is more than 5 minutes in the future",
561            ));
562        }
563        if snippet.created_at > now + 300 {
564            return Err(Status::invalid_argument(
565                "Created timestamp is more than 5 minutes in the future",
566            ));
567        }
568        if snippet.created_at < 0 || snippet.updated_at < 0 {
569            return Err(Status::invalid_argument("Timestamps must be non-negative"));
570        }
571        if snippet.created_at > snippet.updated_at {
572            return Err(Status::invalid_argument(
573                "created_at must not be greater than updated_at",
574            ));
575        }
576
577        Ok(())
578    }
579}
580
581#[tonic::async_trait]
582impl SnippetSync for SnipSyncService {
583    async fn health(
584        &self,
585        _request: Request<HealthRequest>,
586    ) -> Result<Response<HealthResponse>, Status> {
587        let request_id = uuid::Uuid::new_v4();
588        let start = std::time::Instant::now();
589        self.record_request("health");
590        tracing::debug!(request_id = %request_id, "Health check");
591        let healthy = self.db.ping().await.is_ok();
592        self.record_request_duration("health", start);
593        Ok(Response::new(HealthResponse {
594            healthy,
595            version: env!("CARGO_PKG_VERSION").to_string(),
596        }))
597    }
598
599    async fn register(
600        &self,
601        request: Request<RegisterRequest>,
602    ) -> Result<Response<RegisterResponse>, Status> {
603        let request_id = uuid::Uuid::new_v4();
604        let start = std::time::Instant::now();
605        self.record_request("register");
606        tracing::info!(request_id = %request_id, "Register request");
607
608        // Use peer IP address for rate limiting (device_id is client-controlled)
609        // tonic populates request.extensions() with the peer SocketAddr
610        let peer_ip = request
611            .extensions()
612            .get::<SocketAddr>()
613            .map(|addr| addr.ip().to_string());
614
615        let rate_limit_key = if let Some(ref ip) = peer_ip
616            && self.config.trusted_proxies.contains(ip)
617        {
618            request
619                .metadata()
620                .get("x-forwarded-for")
621                .and_then(|v| v.to_str().ok())
622                .and_then(|header| header.split(',').next())
623                .map(|s| strip_port(s.trim()))
624                .unwrap_or_else(|| ip.clone())
625        } else {
626            peer_ip.unwrap_or_else(|| "unknown".to_string())
627        };
628
629        if !self
630            .rate_limiter
631            .allow(
632                &rate_limit_key,
633                self.config.rate_limit_per_minute as usize,
634                Duration::from_secs(60),
635            )
636            .await
637        {
638            self.record_rate_limit();
639            self.record_request_duration("register", start);
640            return Err(Status::resource_exhausted(
641                "Rate limit exceeded for registration",
642            ));
643        }
644
645        let _req = request.into_inner();
646
647        let api_key = uuid::Uuid::new_v4().to_string();
648
649        match self.db.create_user(&api_key).await {
650            Ok(device_id) => {
651                if uuid::Uuid::parse_str(&device_id).is_err() {
652                    tracing::error!(
653                        request_id = %request_id,
654                        "Generated device_id is not a valid UUID: {}",
655                        device_id
656                    );
657                    self.record_request_duration("register", start);
658                    return Err(Status::internal(
659                        "Internal error: invalid device ID generated",
660                    ));
661                }
662                tracing::info!(
663                    request_id = %request_id,
664                    device_id = %device_id,
665                    "Created new user"
666                );
667                self.record_request_duration("register", start);
668                Ok(Response::new(RegisterResponse {
669                    success: true,
670                    api_key,
671                    message: "Account created successfully".to_string(),
672                    device_id,
673                }))
674            }
675            Err(e) => {
676                tracing::error!(request_id = %request_id, "Failed to create user: {}", e);
677                self.record_request_duration("register", start);
678                Err(Status::internal("Internal error"))
679            }
680        }
681    }
682
683    async fn get_snippets(
684        &self,
685        request: Request<GetSnippetsRequest>,
686    ) -> Result<Response<SnippetList>, Status> {
687        let request_id = uuid::Uuid::new_v4();
688        let start = std::time::Instant::now();
689        self.record_request("get_snippets");
690        tracing::info!(request_id = %request_id, "GetSnippets request");
691        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
692        let req = request.into_inner();
693
694        let user_id = self
695            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
696            .await?;
697
698        let library_id = if req.library_id.is_empty() {
699            self.db.get_default_library(&user_id).await.map_err(|e| {
700                self.record_request_duration("get_snippets", start);
701                tracing::error!("Internal error: {}", e);
702                Status::internal("Internal error")
703            })?
704        } else {
705            if !self
706                .db
707                .verify_library_ownership(&user_id, &req.library_id)
708                .await
709                .map_err(|e| {
710                    self.record_request_duration("get_snippets", start);
711                    tracing::error!("Internal error: {}", e);
712                    Status::internal("Internal error")
713                })?
714            {
715                tracing::warn!(
716                    "User {} attempted to access library {} without ownership",
717                    user_id,
718                    req.library_id
719                );
720                self.record_request_duration("get_snippets", start);
721                return Err(Status::not_found("Library not found"));
722            }
723            req.library_id
724        };
725
726        let limit = if req.limit > 0 {
727            req.limit.clamp(1, MAX_REQUEST_LIMIT)
728        } else {
729            100
730        };
731        let offset = if req.offset > 0 { req.offset } else { 0 };
732
733        let (snippets, total) = self
734            .db
735            .get_snippets(&user_id, &library_id, req.since, limit, offset, false)
736            .await
737            .map_err(|e| {
738                self.record_request_duration("get_snippets", start);
739                tracing::error!("Internal error: {}", e);
740                Status::internal("Internal error")
741            })?;
742
743        let has_more = offset.saturating_add(snippets.len() as i32) < total;
744
745        let proto_snippets: Vec<ProtoSnippet> = snippets
746            .into_iter()
747            .map(|s| ProtoSnippet {
748                id: s.id,
749                description: s.description,
750                command: s.command,
751                tags: s.tags,
752                created_at: s.created_at,
753                updated_at: s.updated_at,
754                device_id: s.device_id,
755                deleted: s.deleted,
756                encrypted: s.encrypted,
757            })
758            .collect();
759
760        self.record_request_duration("get_snippets", start);
761
762        Ok(Response::new(SnippetList {
763            snippets: proto_snippets,
764            total_count: total,
765            has_more,
766        }))
767    }
768
769    async fn push_snippets(
770        &self,
771        request: Request<PushSnippetsRequest>,
772    ) -> Result<Response<PushSnippetsResponse>, Status> {
773        let request_id = uuid::Uuid::new_v4();
774        let start = std::time::Instant::now();
775        self.record_request("push_snippets");
776        tracing::info!(request_id = %request_id, "PushSnippets request");
777        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
778        let req = request.into_inner();
779
780        let user_id = self
781            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
782            .await?;
783
784        let library_id = if req.library_id.is_empty() {
785            self.db.get_default_library(&user_id).await.map_err(|e| {
786                self.record_request_duration("push_snippets", start);
787                tracing::error!("Internal error: {}", e);
788                Status::internal("Internal error")
789            })?
790        } else {
791            if !self
792                .db
793                .verify_library_ownership(&user_id, &req.library_id)
794                .await
795                .map_err(|e| {
796                    self.record_request_duration("push_snippets", start);
797                    tracing::error!("Internal error: {}", e);
798                    Status::internal("Internal error")
799                })?
800            {
801                tracing::warn!(
802                    "User {} attempted to push to library {} without ownership",
803                    user_id,
804                    req.library_id
805                );
806                self.record_request_duration("push_snippets", start);
807                return Err(Status::not_found("Library not found"));
808            }
809            req.library_id
810        };
811
812        if req.snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
813            self.record_request_duration("push_snippets", start);
814            return Err(Status::invalid_argument(format!(
815                "Too many snippets in push request (max {}), got {}",
816                DEFAULT_MAX_SYNC_SNIPPETS,
817                req.snippets.len()
818            )));
819        }
820
821        let mut accepted = 0;
822        let mut rejected = 0;
823
824        let mut tx = self.db.pool().begin().await.map_err(|e| {
825            self.record_request_duration("push_snippets", start);
826            tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
827            Status::internal("Internal error")
828        })?;
829
830        for snippet in req.snippets {
831            if let Err(e) = self.validate_snippet(&snippet) {
832                rejected += 1;
833                tracing::warn!(request_id = %request_id, snippet_id = %snippet.id, reason = %e, "Snippet validation failed");
834                continue;
835            }
836
837            let db_snippet = db::Snippet {
838                id: snippet.id.clone(),
839                description: snippet.description,
840                command: snippet.command,
841                tags: snippet.tags,
842                created_at: snippet.created_at,
843                updated_at: snippet.updated_at,
844                device_id: snippet.device_id,
845                deleted: snippet.deleted,
846                encrypted: snippet.encrypted,
847            };
848
849            match self
850                .db
851                .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
852                .await
853            {
854                Ok(_) => accepted += 1,
855                Err(e) => {
856                    tracing::warn!(
857                        request_id = %request_id,
858                        snippet_id = %snippet.id,
859                        reason = %e,
860                        "Snippet upsert failed"
861                    );
862                    rejected += 1;
863                }
864            }
865        }
866
867        tx.commit().await.map_err(|e| {
868            self.record_request_duration("push_snippets", start);
869            tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
870            Status::internal("Internal error")
871        })?;
872
873        self.record_request_duration("push_snippets", start);
874
875        Ok(Response::new(PushSnippetsResponse {
876            success: rejected == 0,
877            message: format!("Accepted {}, rejected {}", accepted, rejected),
878            accepted_count: accepted,
879            rejected_count: rejected,
880        }))
881    }
882
883    async fn sync(&self, request: Request<SyncRequest>) -> Result<Response<SyncResponse>, Status> {
884        let request_id = uuid::Uuid::new_v4();
885        let start = std::time::Instant::now();
886        self.record_request("sync");
887        tracing::info!(request_id = %request_id, "Sync request");
888        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
889        let req = request.into_inner();
890
891        let user_id = self
892            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
893            .await?;
894
895        if req.local_snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
896            self.record_request_duration("sync", start);
897            return Err(Status::invalid_argument(format!(
898                "Too many snippets in sync request (max {}), got {}",
899                DEFAULT_MAX_SYNC_SNIPPETS,
900                req.local_snippets.len()
901            )));
902        }
903
904        self.record_sync("bidirectional");
905
906        let library_id = if req.library_id.is_empty() {
907            self.db.get_default_library(&user_id).await.map_err(|e| {
908                self.record_request_duration("sync", start);
909                tracing::error!("Internal error: {}", e);
910                Status::internal("Internal error")
911            })?
912        } else {
913            if !self
914                .db
915                .verify_library_ownership(&user_id, &req.library_id)
916                .await
917                .map_err(|e| {
918                    self.record_request_duration("sync", start);
919                    tracing::error!("Internal error: {}", e);
920                    Status::internal("Internal error")
921                })?
922            {
923                tracing::warn!(
924                    "User {} attempted to sync with library {} without ownership",
925                    user_id,
926                    req.library_id
927                );
928                self.record_request_duration("sync", start);
929                return Err(Status::not_found("Library not found"));
930            }
931            req.library_id
932        };
933
934        let mut skipped_ids = Vec::new();
935
936        let mut tx = self.db.pool().begin().await.map_err(|e| {
937            self.record_request_duration("sync", start);
938            tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
939            Status::internal("Internal error")
940        })?;
941
942        for snippet in &req.local_snippets {
943            if let Err(e) = self.validate_snippet(snippet) {
944                tracing::warn!(
945                    request_id = %request_id,
946                    snippet_id = %snippet.id,
947                    reason = %e,
948                    "Snippet skipped: validation failed"
949                );
950                skipped_ids.push(snippet.id.clone());
951                continue;
952            }
953
954            if snippet.updated_at <= req.last_sync_timestamp {
955                continue;
956            }
957
958            let db_snippet = db::Snippet {
959                id: snippet.id.clone(),
960                description: snippet.description.clone(),
961                command: snippet.command.clone(),
962                tags: snippet.tags.clone(),
963                created_at: snippet.created_at,
964                updated_at: snippet.updated_at,
965                device_id: snippet.device_id.clone(),
966                deleted: snippet.deleted,
967                encrypted: snippet.encrypted,
968            };
969
970            if let Err(e) = self
971                .db
972                .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
973                .await
974            {
975                tracing::warn!(
976                    request_id = %request_id,
977                    snippet_id = %snippet.id,
978                    reason = %e,
979                    "Snippet skipped: upsert failed"
980                );
981                skipped_ids.push(snippet.id.clone());
982            }
983        }
984
985        tx.commit().await.map_err(|e| {
986            self.record_request_duration("sync", start);
987            tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
988            Status::internal("Internal error")
989        })?;
990
991        let limit = if req.limit > 0 {
992            req.limit.clamp(1, MAX_REQUEST_LIMIT)
993        } else {
994            1000
995        };
996
997        let offset = if req.offset > 0 { req.offset } else { 0 };
998
999        let (snippets, total) = self
1000            .db
1001            .get_snippets(
1002                &user_id,
1003                &library_id,
1004                req.last_sync_timestamp,
1005                limit,
1006                offset,
1007                true,
1008            )
1009            .await
1010            .map_err(|e| {
1011                self.record_request_duration("sync", start);
1012                tracing::error!("Internal error: {}", e);
1013                Status::internal("Internal error")
1014            })?;
1015
1016        let has_more = offset.saturating_add(snippets.len() as i32) < total;
1017
1018        let timestamp = if has_more {
1019            // Don't advance timestamp when paginating — client needs to fetch remaining pages
1020            req.last_sync_timestamp
1021        } else {
1022            self.db
1023                .get_latest_timestamp(&user_id, &library_id)
1024                .await
1025                .map_err(|e| {
1026                    self.record_request_duration("sync", start);
1027                    tracing::error!("Internal error: {}", e);
1028                    Status::internal("Internal error")
1029                })?
1030        };
1031
1032        let proto_snippets: Vec<ProtoSnippet> = snippets
1033            .into_iter()
1034            .map(|s| ProtoSnippet {
1035                id: s.id,
1036                description: s.description,
1037                command: s.command,
1038                tags: s.tags,
1039                created_at: s.created_at,
1040                updated_at: s.updated_at,
1041                device_id: s.device_id,
1042                deleted: s.deleted,
1043                encrypted: s.encrypted,
1044            })
1045            .collect();
1046
1047        let skipped_count = skipped_ids.len() as i32;
1048
1049        tracing::info!(
1050            request_id = %request_id,
1051            snippets_synced = proto_snippets.len(),
1052            skipped_count = skipped_count,
1053            has_more = has_more,
1054            "Sync completed"
1055        );
1056
1057        self.record_request_duration("sync", start);
1058
1059        Ok(Response::new(SyncResponse {
1060            success: true,
1061            message: if skipped_count > 0 {
1062                format!("Sync completed, {} snippets skipped", skipped_count)
1063            } else {
1064                "Sync completed".to_string()
1065            },
1066            snippets: proto_snippets,
1067            server_timestamp: timestamp,
1068            skipped_count,
1069            skipped_ids,
1070            has_more,
1071            total_count: total,
1072        }))
1073    }
1074
1075    async fn create_library(
1076        &self,
1077        request: Request<CreateLibraryRequest>,
1078    ) -> Result<Response<CreateLibraryResponse>, Status> {
1079        let request_id = uuid::Uuid::new_v4();
1080        let start = std::time::Instant::now();
1081        self.record_request("create_library");
1082        self.record_library_op("create");
1083        tracing::info!(request_id = %request_id, "CreateLibrary request");
1084        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1085        let req = request.into_inner();
1086
1087        let user_id = self
1088            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1089            .await?;
1090
1091        match self.db.create_library(&user_id, &req.name).await {
1092            Ok(lib_id) => {
1093                tracing::info!("Created library '{}' for user {}", req.name, user_id);
1094                self.record_request_duration("create_library", start);
1095                Ok(Response::new(CreateLibraryResponse {
1096                    success: true,
1097                    library_id: lib_id,
1098                    message: format!("Library '{}' created successfully", req.name),
1099                }))
1100            }
1101            Err(db::DbError::Conflict(msg)) => {
1102                self.record_request_duration("create_library", start);
1103                Err(Status::already_exists(msg))
1104            }
1105            Err(db::DbError::Validation(msg)) => {
1106                self.record_request_duration("create_library", start);
1107                Err(Status::invalid_argument(msg))
1108            }
1109            Err(db::DbError::NotFound(msg)) => {
1110                self.record_request_duration("create_library", start);
1111                Err(Status::invalid_argument(msg))
1112            }
1113            Err(db::DbError::Internal(msg)) => {
1114                tracing::error!("Internal error creating library: {}", msg);
1115                self.record_request_duration("create_library", start);
1116                Err(Status::internal("Internal error"))
1117            }
1118            Err(db::DbError::Database(e)) => {
1119                tracing::error!("Database error creating library: {}", e);
1120                self.record_request_duration("create_library", start);
1121                Err(Status::internal("Internal error"))
1122            }
1123        }
1124    }
1125
1126    async fn list_libraries(
1127        &self,
1128        request: Request<ListLibrariesRequest>,
1129    ) -> Result<Response<ListLibrariesResponse>, Status> {
1130        let request_id = uuid::Uuid::new_v4();
1131        let start = std::time::Instant::now();
1132        self.record_request("list_libraries");
1133        self.record_library_op("list");
1134        tracing::info!(request_id = %request_id, "ListLibraries request");
1135        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1136        let req = request.into_inner();
1137
1138        let user_id = self
1139            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1140            .await?;
1141
1142        let limit = if req.limit > 0 {
1143            req.limit.clamp(1, MAX_REQUEST_LIMIT)
1144        } else {
1145            50
1146        };
1147        let offset = if req.offset > 0 { req.offset } else { 0 };
1148
1149        let (libraries, total) = self
1150            .db
1151            .list_libraries(&user_id, limit, offset)
1152            .await
1153            .map_err(|e| {
1154                self.record_request_duration("list_libraries", start);
1155                tracing::error!("Internal error: {}", e);
1156                Status::internal("Internal error")
1157            })?;
1158
1159        let has_more = offset.saturating_add(libraries.len() as i32) < total;
1160
1161        let proto_libraries: Vec<Library> = libraries
1162            .into_iter()
1163            .map(|l| Library {
1164                id: l.id,
1165                name: l.name,
1166                created_at: l.created_at,
1167                snippet_count: l.snippet_count,
1168            })
1169            .collect();
1170
1171        self.record_request_duration("list_libraries", start);
1172
1173        Ok(Response::new(ListLibrariesResponse {
1174            libraries: proto_libraries,
1175            total_count: total,
1176            has_more,
1177        }))
1178    }
1179
1180    async fn delete_library(
1181        &self,
1182        request: Request<DeleteLibraryRequest>,
1183    ) -> Result<Response<DeleteLibraryResponse>, Status> {
1184        let request_id = uuid::Uuid::new_v4();
1185        let start = std::time::Instant::now();
1186        self.record_request("delete_library");
1187        self.record_library_op("delete");
1188        tracing::info!(request_id = %request_id, "DeleteLibrary request");
1189        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1190        let req = request.into_inner();
1191
1192        let user_id = self
1193            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1194            .await?;
1195
1196        // Prevent deleting default library — resolve the actual UUID, not
1197        // the literal string "default" which is just the library name.
1198        if req.library_id.is_empty() || req.library_id == "default" {
1199            self.record_request_duration("delete_library", start);
1200            return Err(Status::invalid_argument("Cannot delete default library"));
1201        }
1202        if let Ok(default_id) = self.db.get_default_library(&user_id).await
1203            && req.library_id == default_id
1204        {
1205            self.record_request_duration("delete_library", start);
1206            return Err(Status::invalid_argument("Cannot delete default library"));
1207        }
1208
1209        let result = match self.db.delete_library(&user_id, &req.library_id).await {
1210            Ok(_) => {
1211                tracing::info!("Deleted library {} for user {}", req.library_id, user_id);
1212                Ok(Response::new(DeleteLibraryResponse {
1213                    success: true,
1214                    message: "Library deleted successfully".to_string(),
1215                }))
1216            }
1217            Err(db::DbError::NotFound(msg)) => Err(Status::not_found(msg)),
1218            Err(db::DbError::Conflict(msg)) => Err(Status::failed_precondition(msg)),
1219            Err(db::DbError::Validation(msg)) => Err(Status::invalid_argument(msg)),
1220            Err(db::DbError::Internal(msg)) => {
1221                tracing::error!("Internal error deleting library: {}", msg);
1222                Err(Status::internal("Internal error"))
1223            }
1224            Err(db::DbError::Database(e)) => {
1225                tracing::error!("Failed to delete library: {}", e);
1226                Err(Status::internal("Internal error"))
1227            }
1228        };
1229        self.record_request_duration("delete_library", start);
1230        result
1231    }
1232
1233    async fn list_premade_libraries(
1234        &self,
1235        request: Request<ListPremadeLibrariesRequest>,
1236    ) -> Result<Response<ListPremadeLibrariesResponse>, Status> {
1237        let request_id = uuid::Uuid::new_v4();
1238        let start = std::time::Instant::now();
1239        self.record_request("list_premade_libraries");
1240        tracing::info!(request_id = %request_id, "ListPremadeLibraries request");
1241        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1242        let _req = request.into_inner();
1243
1244        let user_id = self
1245            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1246            .await?;
1247
1248        let libraries = self.premade_manager.list();
1249
1250        let proto_libraries: Vec<ProtoPremadeLibrary> = libraries
1251            .into_iter()
1252            .map(|l| ProtoPremadeLibrary {
1253                name: l.name,
1254                filename: l.filename,
1255                description: l.description,
1256                snippet_count: l.snippet_count,
1257                tags: l.tags,
1258            })
1259            .collect();
1260
1261        tracing::info!(
1262            request_id = %request_id,
1263            user_id = %user_id,
1264            count = proto_libraries.len(),
1265            "ListPremadeLibraries completed"
1266        );
1267
1268        let count = proto_libraries.len() as i32;
1269
1270        self.record_request_duration("list_premade_libraries", start);
1271
1272        Ok(Response::new(ListPremadeLibrariesResponse {
1273            libraries: proto_libraries,
1274            has_more: false,
1275            total_count: count,
1276        }))
1277    }
1278
1279    async fn get_premade_library(
1280        &self,
1281        request: Request<GetPremadeLibraryRequest>,
1282    ) -> Result<Response<GetPremadeLibraryResponse>, Status> {
1283        let request_id = uuid::Uuid::new_v4();
1284        let start = std::time::Instant::now();
1285        self.record_request("get_premade_library");
1286        tracing::info!(request_id = %request_id, "GetPremadeLibrary request");
1287        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1288        let req = request.into_inner();
1289
1290        let user_id = self
1291            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1292            .await?;
1293
1294        if req.filename.is_empty() {
1295            self.record_request_duration("get_premade_library", start);
1296            return Err(Status::invalid_argument("Filename is required"));
1297        }
1298
1299        if req.filename.contains("..") || req.filename.contains('/') || req.filename.contains('\\')
1300        {
1301            self.record_request_duration("get_premade_library", start);
1302            return Err(Status::invalid_argument("Invalid filename"));
1303        }
1304
1305        let sanitized: String = req
1306            .filename
1307            .chars()
1308            .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
1309            .collect();
1310
1311        if sanitized.is_empty() || sanitized.len() > 64 {
1312            self.record_request_duration("get_premade_library", start);
1313            return Err(Status::invalid_argument("Invalid filename"));
1314        }
1315
1316        let content = match self.premade_manager.get(&sanitized) {
1317            Ok(c) => c,
1318            Err(e) => {
1319                self.record_request_duration("get_premade_library", start);
1320                return Err(e);
1321            }
1322        };
1323
1324        tracing::info!("User {} fetched premade library '{}'", user_id, sanitized);
1325
1326        self.record_request_duration("get_premade_library", start);
1327
1328        Ok(Response::new(GetPremadeLibraryResponse {
1329            success: true,
1330            name: sanitized.clone(),
1331            content,
1332            message: "Library fetched successfully".to_string(),
1333        }))
1334    }
1335
1336    async fn search_premade_libraries(
1337        &self,
1338        request: Request<SearchPremadeLibrariesRequest>,
1339    ) -> Result<Response<SearchPremadeLibrariesResponse>, Status> {
1340        let request_id = uuid::Uuid::new_v4();
1341        let start = std::time::Instant::now();
1342        self.record_request("search_premade_libraries");
1343        tracing::info!(request_id = %request_id, "SearchPremadeLibraries request");
1344        let api_key = self.capture_auth_header(&request, &request.get_ref().api_key);
1345        let req = request.into_inner();
1346
1347        let _user_id = self
1348            .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1349            .await?;
1350
1351        if req.query.is_empty() {
1352            self.record_request_duration("search_premade_libraries", start);
1353            return Err(Status::invalid_argument("Query is required"));
1354        }
1355
1356        let results = self.premade_manager.search(&req.query);
1357
1358        let proto_libraries: Vec<ProtoPremadeLibrary> = results
1359            .into_iter()
1360            .map(|l| ProtoPremadeLibrary {
1361                name: l.name,
1362                filename: l.filename,
1363                description: l.description,
1364                snippet_count: l.snippet_count,
1365                tags: l.tags,
1366            })
1367            .collect();
1368
1369        let count = proto_libraries.len() as i32;
1370
1371        tracing::info!(
1372            request_id = %request_id,
1373            query = %req.query,
1374            count = count,
1375            "SearchPremadeLibraries completed"
1376        );
1377
1378        self.record_request_duration("search_premade_libraries", start);
1379
1380        Ok(Response::new(SearchPremadeLibrariesResponse {
1381            libraries: proto_libraries,
1382            total_count: count,
1383        }))
1384    }
1385}
1386
1387#[cfg(test)]
1388mod tests {
1389    use super::*;
1390    use snip_proto::{
1391        CreateLibraryRequest, GetSnippetsRequest, HealthRequest, ListLibrariesRequest,
1392        PushSnippetsRequest, RegisterRequest, Snippet as ProtoSnippet, SyncRequest,
1393    };
1394
1395    pub async fn setup_test_service() -> SnipSyncService {
1396        setup_test_service_with_rate_limit(DEFAULT_RATE_LIMIT_PER_MINUTE).await
1397    }
1398
1399    async fn setup_test_service_with_rate_limit(rate_limit_per_minute: u32) -> SnipSyncService {
1400        let db = Arc::new(Database::connect("sqlite::memory:", 5).await.unwrap());
1401        let config = Config {
1402            grpc_host: "127.0.0.1".to_string(),
1403            grpc_port: 50051,
1404            http_host: "127.0.0.1".to_string(),
1405            http_port: 50050,
1406            db_path: "sqlite::memory:".to_string(),
1407            db_max_connections: 5,
1408            premade_dir: PathBuf::from("premade-libraries"),
1409            max_command_length: 1024,
1410            max_description_length: 1024,
1411            max_tags: 50,
1412            max_tag_length: 100,
1413            max_id_length: 128,
1414            max_device_id_length: 128,
1415            max_api_key_length: 512,
1416            request_timeout_secs: 30,
1417            grpc_max_message_size: 4 * 1024 * 1024,
1418            rate_limit_per_minute,
1419            trusted_proxies: vec![],
1420            persist_rate_limits: false,
1421            metrics_username: None,
1422            metrics_password: None,
1423            cors_allowed_origins: vec![],
1424        };
1425        let metrics = Metrics::fallback();
1426        let rate_limiter = Arc::new(RateLimiter::new());
1427        let premade_manager = PremadeManager::new(PathBuf::from("premade-libraries"));
1428
1429        SnipSyncService {
1430            db,
1431            rate_limiter,
1432            config,
1433            metrics,
1434            premade_manager,
1435            captured_auth_header: Arc::new(std::sync::Mutex::new(None)),
1436        }
1437    }
1438
1439    pub async fn register_test_user(service: &SnipSyncService) -> String {
1440        let req = Request::new(RegisterRequest {
1441            device_id: "test-device".to_string(),
1442        });
1443        let resp = service.register(req).await.unwrap();
1444        resp.into_inner().api_key
1445    }
1446
1447    #[tokio::test]
1448    async fn test_health_check() {
1449        let service = setup_test_service().await;
1450        let req = Request::new(HealthRequest {});
1451        let resp = service.health(req).await.unwrap();
1452        let health = resp.into_inner();
1453        assert!(health.healthy);
1454        assert_eq!(health.version, env!("CARGO_PKG_VERSION"));
1455    }
1456
1457    #[tokio::test]
1458    async fn test_register_creates_user() {
1459        let service = setup_test_service().await;
1460        let req = Request::new(RegisterRequest {
1461            device_id: "test-device".to_string(),
1462        });
1463        let resp = service.register(req).await.unwrap();
1464        let reg = resp.into_inner();
1465        assert!(reg.success);
1466        assert!(!reg.api_key.is_empty());
1467        assert!(!reg.device_id.is_empty());
1468        assert!(uuid::Uuid::parse_str(&reg.device_id).is_ok());
1469    }
1470
1471    #[tokio::test]
1472    async fn test_register_rate_limiting() {
1473        let service = setup_test_service_with_rate_limit(3).await;
1474        for _ in 0..3 {
1475            let req = Request::new(RegisterRequest {
1476                device_id: "test-device".to_string(),
1477            });
1478            let _ = service.register(req).await;
1479        }
1480        let req = Request::new(RegisterRequest {
1481            device_id: "test-device".to_string(),
1482        });
1483        let resp = service.register(req).await;
1484        assert!(resp.is_err());
1485        assert_eq!(resp.unwrap_err().code(), tonic::Code::ResourceExhausted);
1486    }
1487
1488    #[tokio::test]
1489    async fn test_create_and_list_libraries() {
1490        let service = setup_test_service().await;
1491        let api_key = register_test_user(&service).await;
1492
1493        let req = Request::new(CreateLibraryRequest {
1494            api_key: api_key.clone(),
1495            name: "test-lib".to_string(),
1496        });
1497        let resp = service.create_library(req).await.unwrap();
1498        let create = resp.into_inner();
1499        assert!(create.success);
1500        assert!(!create.library_id.is_empty());
1501
1502        let req = Request::new(ListLibrariesRequest {
1503            api_key: api_key.clone(),
1504            limit: 100,
1505            offset: 0,
1506        });
1507        let resp = service.list_libraries(req).await.unwrap();
1508        let list = resp.into_inner();
1509        assert_eq!(list.libraries.len(), 2);
1510        assert!(list.libraries.iter().any(|l| l.name == "test-lib"));
1511    }
1512
1513    #[tokio::test]
1514    async fn test_create_duplicate_library_name() {
1515        let service = setup_test_service().await;
1516        let api_key = register_test_user(&service).await;
1517
1518        let req = Request::new(CreateLibraryRequest {
1519            api_key: api_key.clone(),
1520            name: "test-lib".to_string(),
1521        });
1522        let _ = service.create_library(req).await.unwrap();
1523
1524        let req = Request::new(CreateLibraryRequest {
1525            api_key: api_key.clone(),
1526            name: "test-lib".to_string(),
1527        });
1528        let resp = service.create_library(req).await;
1529        assert!(resp.is_err());
1530        assert_eq!(resp.unwrap_err().code(), tonic::Code::AlreadyExists);
1531    }
1532
1533    #[tokio::test]
1534    async fn test_invalid_api_key() {
1535        let service = setup_test_service().await;
1536        let req = Request::new(GetSnippetsRequest {
1537            api_key: "invalid-key".to_string(),
1538            library_id: String::new(),
1539            limit: 100,
1540            offset: 0,
1541            since: 0,
1542        });
1543        let resp = service.get_snippets(req).await;
1544        assert!(resp.is_err());
1545        assert_eq!(resp.unwrap_err().code(), tonic::Code::Unauthenticated);
1546    }
1547
1548    #[tokio::test]
1549    async fn test_validate_snippet_empty_id() {
1550        let service = setup_test_service().await;
1551        let snippet = ProtoSnippet {
1552            id: String::new(),
1553            description: "test".to_string(),
1554            command: "echo hello".to_string(),
1555            tags: vec![],
1556            created_at: 0,
1557            updated_at: 0,
1558            device_id: "device".to_string(),
1559            deleted: false,
1560            encrypted: false,
1561        };
1562        let result = service.validate_snippet(&snippet);
1563        assert!(result.is_err());
1564        assert!(result.unwrap_err().message().contains("ID is required"));
1565    }
1566
1567    #[tokio::test]
1568    async fn test_validate_snippet_oversized_command() {
1569        let service = setup_test_service().await;
1570        let snippet = ProtoSnippet {
1571            id: "test-id".to_string(),
1572            description: "test".to_string(),
1573            command: "x".repeat(2000),
1574            tags: vec![],
1575            created_at: 0,
1576            updated_at: 0,
1577            device_id: "device".to_string(),
1578            deleted: false,
1579            encrypted: false,
1580        };
1581        let result = service.validate_snippet(&snippet);
1582        assert!(result.is_err());
1583        assert!(result.unwrap_err().message().contains("maximum length"));
1584    }
1585
1586    #[tokio::test]
1587    async fn test_validate_snippet_future_timestamp() {
1588        let service = setup_test_service().await;
1589        let future = chrono::Utc::now().timestamp() + 600;
1590        let snippet = ProtoSnippet {
1591            id: "test-id".to_string(),
1592            description: "test".to_string(),
1593            command: "echo hello".to_string(),
1594            tags: vec![],
1595            created_at: future,
1596            updated_at: future,
1597            device_id: "device".to_string(),
1598            deleted: false,
1599            encrypted: false,
1600        };
1601        let result = service.validate_snippet(&snippet);
1602        assert!(result.is_err());
1603        assert!(result.unwrap_err().message().contains("future"));
1604    }
1605
1606    #[tokio::test]
1607    async fn test_validate_snippet_negative_timestamp() {
1608        let service = setup_test_service().await;
1609        let snippet = ProtoSnippet {
1610            id: "test-id".to_string(),
1611            description: "test".to_string(),
1612            command: "echo hello".to_string(),
1613            tags: vec![],
1614            created_at: -1,
1615            updated_at: -1,
1616            device_id: "device".to_string(),
1617            deleted: false,
1618            encrypted: false,
1619        };
1620        let result = service.validate_snippet(&snippet);
1621        assert!(result.is_err());
1622        assert!(result.unwrap_err().message().contains("non-negative"));
1623    }
1624
1625    #[tokio::test]
1626    async fn test_validate_snippet_too_many_tags() {
1627        let service = setup_test_service().await;
1628        let snippet = ProtoSnippet {
1629            id: "test-id".to_string(),
1630            description: "test".to_string(),
1631            command: "echo hello".to_string(),
1632            tags: (0..100).map(|i| format!("tag{}", i)).collect(),
1633            created_at: 0,
1634            updated_at: 0,
1635            device_id: "device".to_string(),
1636            deleted: false,
1637            encrypted: false,
1638        };
1639        let result = service.validate_snippet(&snippet);
1640        assert!(result.is_err());
1641        assert!(result.unwrap_err().message().contains("Too many tags"));
1642    }
1643
1644    #[tokio::test]
1645    async fn test_validate_snippet_valid() {
1646        let service = setup_test_service().await;
1647        let snippet = ProtoSnippet {
1648            id: "test-id".to_string(),
1649            description: "test".to_string(),
1650            command: "echo hello".to_string(),
1651            tags: vec!["bash".to_string()],
1652            created_at: 0,
1653            updated_at: 0,
1654            device_id: "device".to_string(),
1655            deleted: false,
1656            encrypted: false,
1657        };
1658        assert!(service.validate_snippet(&snippet).is_ok());
1659    }
1660
1661    #[tokio::test]
1662    async fn test_cross_user_library_access_denied() {
1663        let service = setup_test_service().await;
1664        let api_key1 = register_test_user(&service).await;
1665
1666        let req = Request::new(CreateLibraryRequest {
1667            api_key: api_key1.clone(),
1668            name: "user1-lib".to_string(),
1669        });
1670        let resp = service.create_library(req).await.unwrap();
1671        let library_id = resp.into_inner().library_id;
1672
1673        let api_key2 = register_test_user(&service).await;
1674
1675        let req = Request::new(GetSnippetsRequest {
1676            api_key: api_key2,
1677            library_id,
1678            limit: 100,
1679            offset: 0,
1680            since: 0,
1681        });
1682        let resp = service.get_snippets(req).await;
1683        assert!(resp.is_err());
1684        assert_eq!(resp.unwrap_err().code(), tonic::Code::NotFound);
1685    }
1686
1687    #[tokio::test]
1688    async fn test_push_and_get_snippets() {
1689        let service = setup_test_service().await;
1690        let api_key = register_test_user(&service).await;
1691
1692        let req = Request::new(CreateLibraryRequest {
1693            api_key: api_key.clone(),
1694            name: "test-lib".to_string(),
1695        });
1696        let resp = service.create_library(req).await.unwrap();
1697        let library_id = resp.into_inner().library_id;
1698
1699        let snippet = ProtoSnippet {
1700            id: "snippet-1".to_string(),
1701            description: "Test snippet".to_string(),
1702            command: "echo hello".to_string(),
1703            tags: vec!["test".to_string()],
1704            created_at: chrono::Utc::now().timestamp(),
1705            updated_at: chrono::Utc::now().timestamp(),
1706            device_id: "device-1".to_string(),
1707            deleted: false,
1708            encrypted: false,
1709        };
1710        let req = Request::new(PushSnippetsRequest {
1711            api_key: api_key.clone(),
1712            library_id: library_id.clone(),
1713            snippets: vec![snippet],
1714        });
1715        let resp = service.push_snippets(req).await.unwrap();
1716        let push = resp.into_inner();
1717        assert_eq!(push.accepted_count, 1);
1718        assert_eq!(push.rejected_count, 0);
1719
1720        let req = Request::new(GetSnippetsRequest {
1721            api_key: api_key.clone(),
1722            library_id,
1723            limit: 100,
1724            offset: 0,
1725            since: 0,
1726        });
1727        let resp = service.get_snippets(req).await.unwrap();
1728        let list = resp.into_inner();
1729        assert_eq!(list.snippets.len(), 1);
1730        assert_eq!(list.snippets[0].id, "snippet-1");
1731        assert_eq!(list.snippets[0].command, "echo hello");
1732    }
1733
1734    #[tokio::test]
1735    async fn test_delete_library() {
1736        let service = setup_test_service().await;
1737        let api_key = register_test_user(&service).await;
1738
1739        let req = Request::new(CreateLibraryRequest {
1740            api_key: api_key.clone(),
1741            name: "to-delete".to_string(),
1742        });
1743        let resp = service.create_library(req).await.unwrap();
1744        let library_id = resp.into_inner().library_id;
1745
1746        let req = Request::new(snip_proto::DeleteLibraryRequest {
1747            api_key: api_key.clone(),
1748            library_id: library_id.clone(),
1749        });
1750        let resp = service.delete_library(req).await.unwrap();
1751        assert!(resp.into_inner().success);
1752
1753        let req = Request::new(ListLibrariesRequest {
1754            api_key: api_key.clone(),
1755            limit: 100,
1756            offset: 0,
1757        });
1758        let resp = service.list_libraries(req).await.unwrap();
1759        let list = resp.into_inner();
1760        assert_eq!(list.libraries.len(), 1);
1761        assert_eq!(list.libraries[0].name, "default");
1762    }
1763
1764    #[tokio::test]
1765    async fn test_delete_default_library_blocked() {
1766        let service = setup_test_service().await;
1767        let api_key = register_test_user(&service).await;
1768
1769        let req = Request::new(snip_proto::DeleteLibraryRequest {
1770            api_key: api_key.clone(),
1771            library_id: "default".to_string(),
1772        });
1773        let resp = service.delete_library(req).await;
1774        assert!(resp.is_err());
1775        assert!(resp.unwrap_err().message().contains("Cannot delete"));
1776    }
1777
1778    #[tokio::test]
1779    async fn test_sync_basic() {
1780        let service = setup_test_service().await;
1781        let api_key = register_test_user(&service).await;
1782
1783        let req = Request::new(CreateLibraryRequest {
1784            api_key: api_key.clone(),
1785            name: "sync-test".to_string(),
1786        });
1787        let resp = service.create_library(req).await.unwrap();
1788        let library_id = resp.into_inner().library_id;
1789
1790        let req = Request::new(SyncRequest {
1791            api_key: api_key.clone(),
1792            local_snippets: vec![],
1793            last_sync_timestamp: 0,
1794            library_id,
1795            limit: 1000,
1796            offset: 0,
1797        });
1798        let resp = service.sync(req).await.unwrap();
1799        let sync = resp.into_inner();
1800        assert_eq!(sync.snippets.len(), 0);
1801    }
1802}