Merge branch 'devel-0.0.1'

Author: dmitryro

lib/Cargo.toml

@@ -13,7 +13,7 @@ rand = "0.8.5" # Consistent
 actix-web = "4.11.0" # Crucial: Updated to match security crate's version
 actix-rt = "2.10.0" # Updated to match server crate's version
 dotenv = "0.15.0" # Aligned with server
-tokio = { version = "1.44.2", features = ["macros", "rt-multi-thread"] } # Updated to latest stable
+tokio = { version = "1.44.2", features = ["full"] } # Updated to latest stable
 tracing = "0.1.37" # Updated to latest stable
 tracing-subscriber = "0.3.18" # Updated to latest stable
 env_logger = "0.11.8" # Aligned with storage_daemon_server

lib/src/database.rs

@@ -1,187 +1,146 @@
 // lib/src/database.rs
+// Corrected: 2025-07-02 - Final version ensuring correct trait usage and error handling.
+// Fixed models import path and conditional RocksDBStorage import.
+
+use std::sync::Arc;
+// Conditionally import RocksDBStorage
+#[cfg(feature = "with-rocksdb")]
+use crate::storage_engine::RocksDBStorage;
+use crate::storage_engine::{GraphStorageEngine, SledGraphStorage, StorageConfig, StorageEngineType, open_sled_db};
+use models::{Vertex, Edge, Identifier}; // Corrected: Removed `crate::` prefix
+use models::errors::{GraphError, GraphResult}; // Use GraphResult directly
+use uuid::Uuid;
+use serde_json::Value; // For query results
 
-use uuid::Uuid; // Uuid is used in the Transaction trait
-
-// Core graph model types
-use models::{Edge, Identifier, Json, Vertex};
-
-// More specific model types, assuming their locations within the 'models' crate
-// Please adjust these paths if your 'models' crate has a different internal structure.
-use models::bulk_insert::BulkInsertItem;
-// FIX: Changed from models::edges::EdgeDirection to models::queries::EdgeDirection
-use models::queries::EdgeDirection; // CORRECTED PATH
-use models::properties::{EdgeProperties, NamedProperty, PropertyValue, VertexProperties};
-use models::queries::{Query, QueryOutputValue};
-
-// Application-specific models, if they are used within database.rs or re-exported from here
-use models::medical::{Login, User}; // Assuming these are in models::medical
-
-// Import your custom error type
-use crate::errors::Result;
-
-// Define a type alias for a dynamic iterator, commonly used for trait objects
-// and allowing different iterator implementations to be returned.
-pub type DynIter<'a, T> = Box<dyn Iterator<Item = Result<T>> + 'a>;
-
-
-/// Defines the core functionality required for a datastore.
+/// A graph database wrapper that provides a simplified interface for
+/// interacting with an underlying `GraphStorageEngine`.
 ///
-/// Any type implementing this trait can serve as the backend for the `Database`.
-pub trait Datastore {
-    /// The associated transaction type for this datastore.
-    ///
-    /// This associated type allows the `Datastore` trait to define methods
-    /// that return a specific transaction type, which in turn implements
-    /// the `Transaction` trait. The `'a` lifetime parameter indicates that
-    /// the transaction's lifetime is tied to the lifetime of the `Datastore`
-    /// instance from which it was created.
-    type Transaction<'a>
-    where
-        Self: 'a; // Self must outlive 'a, or 'a is tied to Self's lifetime
-
-    /// Begins a new transaction for this datastore.
-    ///
-    /// The returned transaction can be used for both read and write operations.
-    fn transaction(&'_ self) -> Self::Transaction<'_>;
+/// This struct manages the storage engine instance and provides convenient methods
+/// for graph operations.
+#[derive(Debug)]
+pub struct Database {
+    storage_engine: Arc<dyn GraphStorageEngine>,
 }
 
+impl Database {
+    /// Creates a new database instance based on the provided storage configuration.
+    ///
+    /// This function initializes and starts the chosen storage engine (Sled or RocksDB).
+    ///
+    /// # Arguments
+    /// * `config`: The configuration for the storage engine.
+    ///
+    /// # Returns
+    /// A `GraphResult` indicating success or a `GraphError` if initialization fails.
+    pub async fn new(config: StorageConfig) -> GraphResult<Self> {
+        let storage_engine: Arc<dyn GraphStorageEngine> = match config.engine_type {
+            StorageEngineType::Sled => {
+                // Open Sled DB and create SledGraphStorage
+                let db = open_sled_db(&config.data_path)?;
+                Arc::new(SledGraphStorage::new(db)?)
+            },
+            StorageEngineType::RocksDB => {
+                // Conditionally compile RocksDB initialization if the feature is enabled
+                #[cfg(feature = "with-rocksdb")]
+                {
+                    Arc::new(RocksDBStorage::new(&config)?)
+                }
+                #[cfg(not(feature = "with-rocksdb"))]
+                {
+                    return Err(GraphError::ConfigError(
+                        "RocksDB backend requested but 'with-rocksdb' feature is not enabled. \
+                         Please enable it in lib/Cargo.toml".to_string()
+                    ));
+                }
+            },
+            // Add other storage types here as they are implemented (e.g., PostgreSQL, Redis)
+            _ => return Err(GraphError::ConfigError(
+                format!("Unsupported storage engine type: {:?}", config.engine_type)
+            )),
+        };
+
+        // Start the chosen storage engine
+        storage_engine.start().await?;
+
+        Ok(Database { storage_engine })
+    }
 
-/// Defines the operations that can be performed within a database transaction.
-///
-/// This trait outlines the read and write methods for interacting with the graph data.
-pub trait Transaction<'a>: Sized {
-    // Graph Read Operations
-
-    /// Returns the total number of vertices in the database.
-    fn vertex_count(&self) -> u64;
-
-    /// Returns an iterator over all vertices in the database.
-    fn all_vertices(&'a self) -> Result<DynIter<'a, Vertex>>;
-
-    /// Returns an iterator over vertices starting from a given offset UUID.
-    /// Useful for pagination or resuming iteration.
-    fn range_vertices(&'a self, offset: Uuid) -> Result<DynIter<'a, Vertex>>;
-
-    /// Returns an iterator over specific vertices identified by their UUIDs.
-    fn specific_vertices(&'a self, ids: Vec<Uuid>) -> Result<DynIter<'a, Vertex>>;
-
-    /// Returns an optional iterator of vertex UUIDs that have a property with the given name.
-    /// Returns `None` if the property is not indexed.
-    fn vertex_ids_with_property(&'a self, name: Identifier) -> Result<Option<DynIter<'a, Uuid>>>;
-
-    /// Returns an optional iterator of vertex UUIDs that have a property with the given name
-    /// and a specific JSON value. Returns `None` if the property is not indexed.
-    fn vertex_ids_with_property_value(&'a self, name: Identifier, value: &Json) -> Result<Option<DynIter<'a, Uuid>>>;
-
-    /// Returns the total number of edges in the database.
-    fn edge_count(&self) -> u64;
-
-    /// Returns an iterator over all edges in the database.
-    fn all_edges(&'a self) -> Result<DynIter<'a, Edge>>;
-
-    /// Returns an iterator over edges starting from a given offset Edge.
-    /// Useful for pagination or resuming iteration.
-    fn range_edges(&'a self, offset: Edge) -> Result<DynIter<'a, Edge>>;
-
-    /// Returns an iterator over reversed edges (inbound to outbound) starting from a given offset Edge.
-    fn range_reversed_edges(&'a self, offset: Edge) -> Result<DynIter<'a, Edge>>;
-
-    /// Returns an iterator over specific edges.
-    fn specific_edges(&'a self, edges: Vec<Edge>) -> Result<DynIter<'a, Edge>>;
-
-    /// Returns an optional iterator of edges that have a property with the given name.
-    /// Returns `None` if the property is not indexed.
-    fn edges_with_property(&'a self, name: Identifier) -> Result<Option<DynIter<'a, Edge>>>;
-
-    /// Returns an optional iterator of edges that have a property with the given name
-    /// and a specific JSON value. Returns `None` if the property is not indexed.
-    fn edges_with_property_value(&'a self, name: Identifier, value: &Json) -> Result<Option<DynIter<'a, Edge>>>;
-
-    /// Retrieves the value of a specific property for a given vertex.
-    fn vertex_property(&self, vertex: &Vertex, name: Identifier) -> Result<Option<Json>>;
-
-    /// Returns an iterator over all properties (name and value) for a given vertex.
-    fn all_vertex_properties_for_vertex(&'a self, vertex: &Vertex) -> Result<DynIter<'a, (Identifier, Json)>>;
-
-    /// Retrieves the value of a specific property for a given edge.
-    fn edge_property(&self, edge: &Edge, name: Identifier) -> Result<Option<Json>>;
-
-    /// Returns an iterator over all properties (name and value) for a given edge.
-    fn all_edge_properties_for_edge(&'a self, edge: &Edge) -> Result<DynIter<'a, (Identifier, Json)>>;
-
-    // Graph Write Operations
-
-    /// Deletes a collection of vertices and all their associated edges and properties.
-    fn delete_vertices(&mut self, vertices: Vec<Vertex>) -> Result<()>;
+    /// Returns a reference to the underlying graph storage engine.
+    pub fn storage(&self) -> &Arc<dyn GraphStorageEngine> {
+        &self.storage_engine
+    }
 
-    /// Deletes a collection of edges and their associated properties.
-    fn delete_edges(&mut self, edges: Vec<Edge>) -> Result<()>;
+    // --- Proxy methods to GraphStorageEngine for convenience ---
 
-    /// Deletes specific properties from vertices.
-    fn delete_vertex_properties(&mut self, props: Vec<(Uuid, Identifier)>) -> Result<()>;
+    /// Creates a new vertex in the database.
+    pub async fn create_vertex(&self, vertex: Vertex) -> GraphResult<()> {
+        self.storage_engine.as_ref().create_vertex(vertex).await
+    }
 
-    /// Deletes specific properties from edges.
-    fn delete_edge_properties(&mut self, props: Vec<(Edge, Identifier)>) -> Result<()>;
+    /// Retrieves a vertex by its ID.
+    pub async fn get_vertex(&self, id: &Uuid) -> GraphResult<Option<Vertex>> {
+        self.storage_engine.as_ref().get_vertex(id).await
+    }
 
-    /// Synchronizes the datastore's internal state with its persistent storage.
-    /// This might involve flushing buffers or performing compaction.
-    fn sync(&self) -> Result<()>;
+    /// Updates an existing vertex in the database.
+    pub async fn update_vertex(&self, vertex: Vertex) -> GraphResult<()> {
+        self.storage_engine.as_ref().update_vertex(vertex).await
+    }
 
-    /// Creates a new vertex in the database. Returns `true` if created, `false` if it already existed.
-    fn create_vertex(&mut self, vertex: &Vertex) -> Result<bool>;
+    /// Deletes a vertex by its ID.
+    pub async fn delete_vertex(&self, id: &Uuid) -> GraphResult<()> {
+        self.storage_engine.as_ref().delete_vertex(id).await
+    }
 
-    /// Creates a new edge in the database. Returns `true` if created, `false` if it already existed
-    /// or if the incident vertices do not exist.
-    fn create_edge(&mut self, edge: &Edge) -> Result<bool>;
+    /// Retrieves all vertices from the database.
+    pub async fn get_all_vertices(&self) -> GraphResult<Vec<Vertex>> {
+        self.storage_engine.as_ref().get_all_vertices().await
+    }
 
-    /// Performs a bulk insert of various graph items (vertices, edges, properties).
-    /// This method is typically optimized for performance by batching operations.
-    fn bulk_insert(&mut self, items: Vec<BulkInsertItem>) -> Result<()>;
+    /// Creates a new edge in the database.
+    pub async fn create_edge(&self, edge: Edge) -> GraphResult<()> {
+        self.storage_engine.as_ref().create_edge(edge).await
+    }
 
-    /// Indexes a property by its name. After indexing, queries on this property
-    /// will be more efficient. This operation may take time for existing data.
-    fn index_property(&mut self, name: Identifier) -> Result<()>;
+    /// Retrieves an edge by its composite key (outbound ID, type, inbound ID).
+    pub async fn get_edge(&self, outbound_id: &Uuid, edge_type: &Identifier, inbound_id: &Uuid) -> GraphResult<Option<Edge>> {
+        self.storage_engine.as_ref().get_edge(outbound_id, edge_type, inbound_id).await
+    }
 
-    /// Sets (creates or updates) a specific property for a collection of vertices.
-    fn set_vertex_properties(&mut self, vertices: Vec<Uuid>, name: Identifier, value: &Json) -> Result<()>;
+    /// Updates an existing edge in the database.
+    pub async fn update_edge(&self, edge: Edge) -> GraphResult<()> {
+        self.storage_engine.as_ref().update_edge(edge).await
+    }
 
-    /// Sets (creates or updates) a specific property for a collection of edges.
-    fn set_edge_properties(&mut self, edges: Vec<Edge>, name: Identifier, value: &Json) -> Result<()>;
-}
+    /// Deletes an edge by its composite key.
+    pub async fn delete_edge(&self, outbound_id: &Uuid, edge_type: &Identifier, inbound_id: &Uuid) -> GraphResult<()> {
+        self.storage_engine.as_ref().delete_edge(outbound_id, edge_type, inbound_id).await
+    }
 
+    /// Retrieves all edges from the database.
+    pub async fn get_all_edges(&self) -> GraphResult<Vec<Edge>> {
+        self.storage_engine.as_ref().get_all_edges().await
+    }
 
-/// A graph database wrapper that provides a simplified interface for
-/// interacting with an underlying `Datastore`.
-///
-/// This struct manages the datastore instance and provides convenient methods
-/// to obtain read and write transactions.
-#[derive(Debug)]
-pub struct Database<D: Datastore> {
-    datastore: D,
-}
+    /// Executes a generic query string against the graph storage engine.
+    /// The interpretation of the query string depends on the underlying engine.
+    pub async fn query(&self, query_string: &str) -> GraphResult<Value> {
+        self.storage_engine.as_ref().query(query_string).await
+    }
 
-impl<D: Datastore> Database<D> {
-    /// Creates a new database instance.
-    ///
-    /// # Arguments
-    /// * `datastore`: The underlying datastore implementation that will store the data.
-    pub fn new(datastore: D) -> Self {
-        Self { datastore }
+    /// Returns the type of the underlying storage engine.
+    pub fn get_type(&self) -> &'static str {
+        self.storage_engine.as_ref().get_type()
     }
 
-    /// Gets a read transaction for performing read operations on the database.
-    ///
-    /// The transaction's lifetime is tied to the `Database` instance.
-    pub fn read_txn(&self) -> D::Transaction<'_> {
-        self.datastore.transaction()
+    /// Checks if the underlying storage engine is running.
+    pub fn is_running(&self) -> bool {
+        self.storage_engine.as_ref().is_running()
     }
 
-    /// Gets a write transaction for performing write operations on the database.
-    ///
-    /// The transaction is typically committed automatically when it goes out of scope (dropped),
-    /// or it might provide explicit commit/rollback methods depending on the `Transaction`
-    /// trait implementation.
-    pub fn write_txn(&mut self) -> D::Transaction<'_> {
-        self.datastore.transaction()
+    /// Stops the underlying storage engine gracefully.
+    pub async fn stop(&self) -> GraphResult<()> {
+        self.storage_engine.as_ref().stop().await
     }
 }
+

lib/src/engine/medical.rs

@@ -6,6 +6,7 @@ use models::Identifier;
 use models::ToVertex;
 use models::vertices::Vertex as ModelVertex; // Alias to avoid conflict with EngineVertex
 use uuid::Uuid;
+use models::identifiers::SerializableUuid;
 // This import is correct for models::properties::PropertyValue
 use models::properties::PropertyValue;
 
@@ -14,10 +15,9 @@ fn convert_model_vertex_to_engine_vertex(v: &ModelVertex) -> crate::engine::vert
     use std::collections::BTreeMap;
 
     let mut eng_vertex = crate::engine::vertex::Vertex::new(v.label.to_string());
-    eng_vertex.id = v.id;
+    eng_vertex.id = Uuid::from(v.id); // Convert SerializableUuid to Uuid
     eng_vertex.properties = v.properties.iter()
-        .map(|(k, prop_val)| { // prop_val is &models::properties::PropertyValue
-            // This match correctly extracts String from models::properties::PropertyValue::String
+        .map(|(k, prop_val)| {
             let string_value = match prop_val {
                 PropertyValue::String(s) => s.clone(),
                 // Add conversion logic for other PropertyValue variants if needed
@@ -26,11 +26,8 @@ fn convert_model_vertex_to_engine_vertex(v: &ModelVertex) -> crate::engine::vert
                     "UNSUPPORTED_PROPERTY_TYPE".to_string()
                 },
             };
-            // This line *produces* models::properties::PropertyValue::String
             (k.clone(), PropertyValue::String(string_value))
         })
-        // This collect now produces a BTreeMap with models::properties::PropertyValue,
-        // which will match eng_vertex.properties after the fix in lib/src/engine/vertex.rs
         .collect::<BTreeMap<String, PropertyValue>>();
     eng_vertex
 }

lib/src/lib.rs

@@ -1,5 +1,6 @@
 // lib/src/lib.rs
-// Updated: 2025-06-30 - Refactored to use the new 'models' crate for shared types.
+// Updated: 2025-07-02 - Refactored to use the new 'models' crate for shared types.
+// Corrected unresolved imports for SledUserStorage and UserStorageEngine.
 
 #![cfg_attr(feature = "bench-suite", feature(test))]
 
@@ -49,7 +50,10 @@ pub use crate::memory::*;
 // REMOVED: pub use models::PropertyValue; // <-- REMOVED THIS DUPLICATE LINE
 
 // Re-export from storage_engine/mod.rs
-pub use crate::storage_engine::{SledUserStorage, UserStorageEngine, open_sled_db, StorageEngine, GraphStorageEngine};
+// Removed SledUserStorage and UserStorageEngine as their definitions/re-exports are not available.
+// If these are needed, ensure they are correctly defined and re-exported in storage_engine/mod.rs
+// and storage_engine/user_storage.rs
+pub use crate::storage_engine::{open_sled_db, StorageEngine, GraphStorageEngine};
 
 
 // Do NOT glob-import engine and models together to avoid ambiguity
@@ -88,3 +92,4 @@ pub use crate::sled::managers::SledManager as SledDatastore;
 
 #[cfg(feature = "sled-datastore")]
 pub type CurrentDatastore = SledDatastore;
+