openserve 2.0.3

A modern, high-performance, AI-enhanced file server built in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Storage service for database operations

use anyhow::Result;
use sqlx::{Pool, Sqlite, SqlitePool};
use tracing::{debug, info};

use crate::config::StorageConfig;

/// Storage service for database operations
#[derive(Clone)]
pub struct StorageService {
    pool: Pool<Sqlite>,
}

/// File metadata stored in database
#[derive(Debug, sqlx::FromRow, serde::Serialize)]
pub struct FileMetadata {
    pub id: i64,
    pub path: String,
    pub name: String,
    pub size: i64,
    pub mime_type: String,
    pub checksum: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub updated_at: chrono::DateTime<chrono::Utc>,
    pub tags: Option<String>,
    pub description: Option<String>,
}

/// File search metadata
#[derive(Debug, sqlx::FromRow)]
pub struct FileSearchData {
    pub path: String,
    pub content: String,
    pub embeddings: Option<Vec<u8>>,
}

impl StorageService {
    /// Create a new storage service
    pub async fn new(config: &StorageConfig) -> Result<Self> {
        info!("Connecting to database: {}", config.database_url);
        
        let pool = SqlitePool::connect(&config.database_url).await?;
        
        // Run migrations
        sqlx::migrate!("./migrations").run(&pool).await?;
        
        Ok(Self { pool })
    }

    /// Store file metadata
    pub async fn store_file_metadata(&self, metadata: &FileMetadata) -> Result<i64> {
        debug!("Storing file metadata: {}", metadata.path);
        
        let result = sqlx::query!(
            r#"
            INSERT INTO file_metadata (path, name, size, mime_type, checksum, tags, description)
            VALUES (?, ?, ?, ?, ?, ?, ?)
            ON CONFLICT(path) DO UPDATE SET
                name = excluded.name,
                size = excluded.size,
                mime_type = excluded.mime_type,
                checksum = excluded.checksum,
                tags = excluded.tags,
                description = excluded.description,
                updated_at = CURRENT_TIMESTAMP
            "#,
            metadata.path,
            metadata.name,
            metadata.size,
            metadata.mime_type,
            metadata.checksum,
            metadata.tags,
            metadata.description
        )
        .execute(&self.pool)
        .await?;

        Ok(result.last_insert_rowid())
    }

    /// Get file metadata by path
    pub async fn get_file_metadata(&self, path: &str) -> Result<Option<FileMetadata>> {
        debug!("Getting file metadata: {}", path);