1#![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
43pub 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 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; pub 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 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 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 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 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 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(®.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}