osiris/src/store/generic_store.rs

use crate::error::Result;
use crate::index::FieldIndex;
use crate::store::{HeroDbClient, Object, TypeRegistry};
use std::sync::Arc;

/// Generic storage layer for OSIRIS objects
#[derive(Debug)]
pub struct GenericStore {
    client: HeroDbClient,
    index: FieldIndex,
    type_registry: Option<Arc<TypeRegistry>>,
}

impl GenericStore {
    /// Create a new generic store
    pub fn new(client: HeroDbClient) -> Self {
        let index = FieldIndex::new(client.clone());
        Self { 
            client, 
            index,
            type_registry: None,
        }
    }
    
    /// Create a new generic store with a type registry
    pub fn with_registry(client: HeroDbClient, registry: Arc<TypeRegistry>) -> Self {
        let index = FieldIndex::new(client.clone());
        Self { 
            client, 
            index,
            type_registry: Some(registry),
        }
    }
    
    /// Set the type registry
    pub fn set_registry(&mut self, registry: Arc<TypeRegistry>) {
        self.type_registry = Some(registry);
    }
    
    /// Store an object
    pub async fn put<T: Object>(&self, obj: &T) -> Result<()> {
        // Serialize object to JSON
        let json = obj.to_json()?;
        let key = format!("obj:{}:{}", obj.namespace(), obj.id());
        
        // Store in HeroDB
        self.client.set(&key, &json).await?;
        
        // Index the object
        self.index_object(obj).await?;
        
        Ok(())
    }
    
    /// Get an object by ID
    pub async fn get<T: Object>(&self, ns: &str, id: &str) -> Result<T> {
        let key = format!("obj:{}:{}", ns, id);
        let json = self.client.get(&key).await?
            .ok_or_else(|| crate::error::Error::NotFound(format!("Object {}:{}", ns, id)))?;
        
        T::from_json(&json)
    }
    
    /// Get raw JSON data by ID (for generic access without type)
    pub async fn get_raw(&self, ns: &str, id: &str) -> Result<String> {
        let key = format!("obj:{}:{}", ns, id);
        self.client.get(&key).await?
            .ok_or_else(|| crate::error::Error::NotFound(format!("Object {}:{}", ns, id)))
    }
    
    /// Get the type registry if configured
    pub fn type_registry(&self) -> Option<Arc<TypeRegistry>> {
        self.type_registry.clone()
    }
    
    /// Delete an object
    pub async fn delete<T: Object>(&self, obj: &T) -> Result<bool> {
        let key = format!("obj:{}:{}", obj.namespace(), obj.id());
        
        // Deindex first
        self.deindex_object(obj).await?;
        
        // Delete from HeroDB
        self.client.del(&key).await
    }
    
    /// Check if an object exists
    pub async fn exists(&self, ns: &str, id: &str) -> Result<bool> {
        let key = format!("obj:{}:{}", ns, id);
        self.client.exists(&key).await
    }
    
    /// Index an object
    async fn index_object<T: Object>(&self, obj: &T) -> Result<()> {
        let index_keys = obj.index_keys();
        
        for key in index_keys {
            let field_key = format!("idx:{}:{}:{}", obj.namespace(), key.name, key.value);
            self.client.sadd(&field_key, obj.id()).await?;
        }
        
        // Add to scan index for full-text search
        let scan_key = format!("scan:{}", obj.namespace());
        self.client.sadd(&scan_key, obj.id()).await?;
        
        Ok(())
    }
    
    /// Deindex an object
    async fn deindex_object<T: Object>(&self, obj: &T) -> Result<()> {
        let index_keys = obj.index_keys();
        
        for key in index_keys {
            let field_key = format!("idx:{}:{}:{}", obj.namespace(), key.name, key.value);
            self.client.srem(&field_key, obj.id()).await?;
        }
        
        // Remove from scan index
        let scan_key = format!("scan:{}", obj.namespace());
        self.client.srem(&scan_key, obj.id()).await?;
        
        Ok(())
    }
    
    /// Get all IDs matching an index key
    pub async fn get_ids_by_index(&self, ns: &str, field: &str, value: &str) -> Result<Vec<String>> {
        let field_key = format!("idx:{}:{}:{}", ns, field, value);
        self.client.smembers(&field_key).await
    }
    
    /// Get all IDs in a namespace
    pub async fn get_all_ids(&self, ns: &str) -> Result<Vec<String>> {
        let scan_key = format!("scan:{}", ns);
        self.client.smembers(&scan_key).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::objects::Note;
    
    #[tokio::test]
    #[ignore]
    async fn test_generic_store() {
        let client = HeroDbClient::new("redis://localhost:6379", 1).unwrap();
        let store = GenericStore::new(client);
        
        let note = Note::new("test".to_string())
            .set_title("Test Note")
            .set_content("This is a test");
        
        store.put(&note).await.unwrap();
        
        let retrieved: Note = store.get("test", note.id()).await.unwrap();
        assert_eq!(retrieved.title, note.title);
    }
}