Reverted some endpoints previously hidden

Author: dmitryro

lib/Cargo.toml

@@ -66,6 +66,7 @@ moka = { version = "0.12.10", features = ["sync", "future"] } # Consistent
 thiserror = "2.0.12" # Consistent
 models = { path = "../models", features = ["rocksdb-errors", "sled-errors", "bincode-errors"] } # Consistent, features enabled
 bcrypt = "0.15.1" # Aligned with models (highest version)
+regex = "1.11.1" # Consistent
 
 [features]
 default = []

lib/src/database.rs

@@ -1,13 +1,16 @@
 // 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.
+// Fixed: 2025-07-02 - Corrected import for SledStorage and RocksDBStorage, and models crate.
 
 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
+// Corrected imports for SledStorage and RocksDBStorage to use their full paths
+use crate::storage_engine::{GraphStorageEngine, StorageConfig, StorageEngineType, open_sled_db};
+use crate::storage_engine::sled_storage::SledStorage; // Explicitly import SledStorage
+#[cfg(feature = "with-rocksdb")] // Apply cfg to the import itself
+use crate::storage_engine::rocksdb_storage::RocksDBStorage; // Explicitly import RocksDBStorage
+
+// Corrected import for models crate (it's a separate crate, not a module within `crate`)
+use models::{Vertex, Edge, Identifier};
 use models::errors::{GraphError, GraphResult}; // Use GraphResult directly
 use uuid::Uuid;
 use serde_json::Value; // For query results
@@ -35,9 +38,9 @@ impl Database {
     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
+                // Open Sled DB and create SledStorage
                 let db = open_sled_db(&config.data_path)?;
-                Arc::new(SledGraphStorage::new(db)?)
+                Arc::new(SledStorage::new(db)?)
             },
             StorageEngineType::RocksDB => {
                 // Conditionally compile RocksDB initialization if the feature is enabled

lib/src/query_parser/query_parser.rs

@@ -1,6 +1,11 @@
+// lib/src/query_parser/query_parser.rs
+// Updated: 2025-07-02 - Re-introduced regex for Cypher and SQL query detection.
+
 use graphql_parser::parse_query;
 use graphql_parser::query::Document; // Required for parse_query to compile
 use std::fmt::Debug;
+use regex::Regex; // Import the regex crate
+use once_cell::sync::Lazy; // For lazy static regex initialization
 
 /// Represents the type of a parsed query: Cypher, SQL, or GraphQL.
 #[derive(Debug)]
@@ -10,20 +15,35 @@ pub enum QueryType {
     GraphQL,
 }
 
+// Lazily initialized regex for Cypher and SQL keywords
+static CYPHER_REGEX: Lazy<Regex> = Lazy::new(|| {
+    // Matches common Cypher keywords at the start of the query,
+    // ignoring leading whitespace and case.
+    Regex::new(r"^\s*(?i)(MATCH|CREATE|MERGE|RETURN|DETACH|DELETE|SET|REMOVE|WHERE|WITH|UNWIND|CALL|LOAD CSV)").unwrap()
+});
+
+static SQL_REGEX: Lazy<Regex> = Lazy::new(|| {
+    // Matches common SQL keywords at the start of the query,
+    // ignoring leading whitespace and case.
+    Regex::new(r"^\s*(?i)(SELECT|INSERT INTO|UPDATE|DELETE FROM|CREATE TABLE|ALTER TABLE|DROP TABLE|TRUNCATE TABLE)").unwrap()
+});
+
+
 /// Attempts to parse a query string into a known `QueryType`.
 pub fn parse_query_from_string(query: &str) -> Result<QueryType, String> {
     // Try to parse as a GraphQL query first
+    // This is typically a more strict grammar, so it's a good first check.
     if parse_query::<&str>(query).is_ok() {
         return Ok(QueryType::GraphQL);
     }
 
-    // Try to infer Cypher
-    if query.trim_start().starts_with("MATCH") || query.contains("RETURN") {
+    // Try to infer Cypher using regex
+    if CYPHER_REGEX.is_match(query) {
         return Ok(QueryType::Cypher);
     }
 
-    // Try to infer SQL
-    if query.contains("SELECT") || query.contains("FROM") {
+    // Try to infer SQL using regex
+    if SQL_REGEX.is_match(query) {
         return Ok(QueryType::SQL);
     }
 

lib/src/storage_engine/config.rs

@@ -20,6 +20,10 @@ pub struct StorageConfig {
     /// Optional: Any specific configuration parameters for the chosen engine.
     /// This could be a JSON string or a more structured enum/struct later.
     pub engine_specific_config: Option<String>,
+    /// Optional: Maximum number of open files for RocksDB.
+    /// This field is specifically used by the RocksDB storage engine.
+    #[serde(default)] // Allows this field to be optional in config files, defaulting to None
+    pub max_open_files: Option<i32>,
 }
 
 impl Default for StorageConfig {
@@ -28,6 +32,7 @@ impl Default for StorageConfig {
             engine_type: StorageEngineType::Sled, // Default to Sled
             data_path: "./data/graphdb_storage".to_string(), // Default data path
             engine_specific_config: None,
+            max_open_files: None, // Default to None for max_open_files
         }
     }
 }

lib/src/storage_engine/mod.rs

@@ -1,16 +1,21 @@
 // lib/src/storage_engine/mod.rs
 // Corrected: 2025-07-02 - Fixed module re-exports to resolve import errors.
+// Refactored: 2025-07-02 - Added storage_utils module for common helper functions.
 
-pub mod storage_engine; // Declares the module defined in storage_engine.rs
-pub mod sled_storage;
+pub mod storage_engine; // Declares the module defined in storage_engine.rs (now trait-only)
+pub mod sled_storage; // Declares the module for Sled implementation
 #[cfg(feature = "with-rocksdb")]
-pub mod rocksdb_storage;
+pub mod rocksdb_storage; // Declares the module for RocksDB implementation
 pub mod config;
+pub mod storage_utils; // Declare the new utility module
 
 // Re-export key traits and structs for easier access from `crate::storage_engine::*`
 pub use self::storage_engine::{StorageEngine, GraphStorageEngine};
-pub use self::sled_storage::{SledGraphStorage, open_sled_db}; // SledGraphStorage is the actual implementation struct
+// Corrected: Re-export SledStorage (not SledGraphStorage)
+pub use self::sled_storage::{SledStorage, open_sled_db};
 #[cfg(feature = "with-rocksdb")]
 pub use self::rocksdb_storage::RocksDBStorage;
 pub use self::config::{StorageConfig, StorageEngineType};
+// No need to re-export individual functions from storage_utils here unless they are meant for direct top-level use.
+// They will be imported directly by sled_storage and rocksdb_storage.