🚀 Release v1.4.0

CHANGELOG.md

@@ -361,9 +361,9 @@ BLOCK_CACHE_SIZE_MB=256
 
 **Basic Usage**:
 ```rust
-use lsm_kv_store::storage::builder::SstableBuilder;
-use lsm_kv_store::infra::config::StorageConfig;
-use lsm_kv_store::core::log_record::LogRecord;
+use apexstore::storage::builder::SstableBuilder;
+use apexstore::infra::config::StorageConfig;
+use apexstore::core::log_record::LogRecord;
 
 // Create builder
 let config = StorageConfig::default();

docs/RELEASE_NOTES_v1.3.0.md

@@ -77,7 +77,7 @@ pub struct MetaBlock {
 **Builder API Usage**:
 
 ```rust
-use lsm_kv_store::storage::builder::SstableBuilder;
+use apexstore::storage::builder::SstableBuilder;
 
 // Create builder with automatic block management
 let mut builder = SstableBuilder::new(

docs/SETUP.md

@@ -367,7 +367,7 @@ export RUST_LOG=debug
 RUST_LOG=trace cargo run
 
 # Filter by module
-RUST_LOG=lsm_kv_store::core::engine=debug cargo run
+RUST_LOG=apexstore::core::engine=debug cargo run
 ```
 
 ---

docs/implementation-plans/IMPLEMENTATION_PLAN_31_36.md

@@ -835,8 +835,8 @@ pub async fn start_server(
 
 ```rust
 use actix_web::{test, App};
-use lsm_kv_store::api::auth::TokenManager;
-use lsm_kv_store::api::server::configure_routes;
+use apexstore::api::auth::TokenManager;
+use apexstore::api::server::configure_routes;
 use std::sync::Arc;
 
 #[actix_web::test]
@@ -882,7 +882,7 @@ async fn test_valid_token_access() {
     let (token, _) = token_manager
         .create(
             "test-token".to_string(),
-            vec![lsm_kv_store::api::auth::token::Permission::Write],
+            vec![apexstore::api::auth::token::Permission::Write],
             None,
         )
         .unwrap();

src/bin/server.rs

@@ -1,4 +1,4 @@
-use lsm_kv_store::{LsmConfig, LsmEngine};
+use apexstore::{LsmConfig, LsmEngine};
 use std::env;
 use std::io;
 use std::path::PathBuf;
@@ -21,7 +21,7 @@ async fn main() -> std::io::Result<()> {
     println!("╚═══════════════════════════════════════════════════════╝\n");
 
     // Load server configuration from environment
-    let server_config = lsm_kv_store::api::ServerConfig::from_env();
+    let server_config = apexstore::api::ServerConfig::from_env();
 
     // Load LSM engine configuration from environment
     let data_dir = env::var("DATA_DIR").unwrap_or_else(|_| "./.lsm_data".to_string());
@@ -67,7 +67,10 @@ async fn main() -> std::io::Result<()> {
         Ok(abs_path) => println!("   Data Directory: {}", abs_path.display()),
         Err(_) => println!("   Data Directory: {} (will be created)", data_dir),
     }
-    println!("   MemTable Max Size: {} MB", memtable_max_size / 1024 / 1024);
+    println!(
+        "   MemTable Max Size: {} MB",
+        memtable_max_size / 1024 / 1024
+    );
     println!("   Block Size: {} bytes", block_size);
     println!("   Block Cache: {} MB", block_cache_size_mb);
     println!("   Sparse Index Interval: {}", sparse_index_interval);
@@ -78,12 +81,14 @@ async fn main() -> std::io::Result<()> {
         Ok(engine) => engine,
         Err(e) => {
             eprintln!("❌ Error initializing LSM Engine: {}", e);
-            eprintln!("💡 Tip: if you don't need to recover unflushed writes, rename/delete wal.log and try again.");
+            eprintln!(
+                "💡 Tip: if you don't need to recover unflushed writes, rename/delete wal.log and try again."
+            );
             return Err(io::Error::new(io::ErrorKind::InvalidData, e.to_string()));
         }
     };
 
     println!("✓ Engine initialized successfully!\n");
 
-    lsm_kv_store::api::start_server(engine, server_config).await
+    apexstore::api::start_server(engine, server_config).await
 }

src/cli/mod.rs

@@ -1,4 +1,4 @@
-use lsm_kv_store::{LsmConfig, LsmEngine};
+use apexstore::{LsmConfig, LsmEngine};
 use std::io::{self, Write};
 use std::path::PathBuf;
 

src/core/memtable.rs

@@ -1,4 +1,5 @@
 use crate::core::log_record::LogRecord;
+use crate::storage::iterator::MemTableIterator;
 use std::collections::BTreeMap;
 
 pub struct MemTable {
@@ -34,10 +35,44 @@ impl MemTable {
         self.data.get(key).cloned()
     }
 
+    /// Returns a StorageIterator over all entries (backward compatible)
     pub fn iter_ordered(&self) -> impl Iterator<Item = (&String, &LogRecord)> {
         self.data.iter()
     }
 
+    /// Returns a MemTableIterator starting from the beginning
+    ///
+    /// This is the preferred method for using the StorageIterator trait.
+    ///
+    /// # Example
+    /// ```ignore
+    /// let mut iter = memtable.iter();
+    /// while iter.is_valid() {
+    ///     println!("{}={:?}", String::from_utf8_lossy(iter.key()), iter.value());
+    ///     iter.next();
+    /// }
+    /// ```
+    pub fn iter(&self) -> MemTableIterator<'_> {
+        MemTableIterator::new(&self.data)
+    }
+
+    /// Returns a MemTableIterator starting from a specific key
+    ///
+    /// # Arguments
+    /// * `start_key` - The key to start iteration from (inclusive)
+    ///
+    /// # Example
+    /// ```ignore
+    /// let mut iter = memtable.iter_from("key_100");
+    /// while iter.is_valid() {
+    ///     // Iterate from key_100 onwards
+    ///     iter.next();
+    /// }
+    /// ```
+    pub fn iter_from(&self, start_key: &str) -> MemTableIterator<'_> {
+        MemTableIterator::new_from(&self.data, start_key)
+    }
+
     pub fn clear(&mut self) -> usize {
         let count = self.data.len();
         self.data.clear();
@@ -49,3 +84,46 @@ impl MemTable {
         record.key.len() + record.value.len() + 32
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::storage::iterator::StorageIterator;
+
+    #[test]
+    fn test_memtable_iter() {
+        let mut memtable = MemTable::new(1024);
+        memtable.insert(LogRecord::new("key1".to_string(), b"value1".to_vec()));
+        memtable.insert(LogRecord::new("key2".to_string(), b"value2".to_vec()));
+        memtable.insert(LogRecord::new("key3".to_string(), b"value3".to_vec()));
+
+        let mut iter = memtable.iter();
+        let mut count = 0;
+
+        while iter.is_valid() {
+            count += 1;
+            iter.next();
+        }
+
+        assert_eq!(count, 3);
+    }
+
+    #[test]
+    fn test_memtable_iter_from() {
+        let mut memtable = MemTable::new(1024);
+        memtable.insert(LogRecord::new("key1".to_string(), b"value1".to_vec()));
+        memtable.insert(LogRecord::new("key2".to_string(), b"value2".to_vec()));
+        memtable.insert(LogRecord::new("key3".to_string(), b"value3".to_vec()));
+
+        let mut iter = memtable.iter_from("key2");
+        assert!(iter.is_valid());
+        assert_eq!(iter.key(), b"key2");
+
+        iter.next();
+        assert!(iter.is_valid());
+        assert_eq!(iter.key(), b"key3");
+
+        iter.next();
+        assert!(!iter.is_valid());
+    }
+}

src/lib.rs

@@ -45,19 +45,19 @@
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
 //! // Create engine with default configuration
 //! let config = LsmConfig::default();
-//! let mut engine = LsmEngine::open(config)?;
+//! let engine = LsmEngine::new(config)?;
 //!
 //! // Write data
-//! engine.put("user:1", b"Alice")?;
-//! engine.put("user:2", b"Bob")?;
+//! engine.set("user:1".to_string(), b"Alice".to_vec())?;
+//! engine.set("user:2".to_string(), b"Bob".to_vec())?;
 //!
 //! // Read data
-//! if let Some(record) = engine.get("user:1")? {
-//!     println!("Value: {:?}", record.value);
+//! if let Some(value) = engine.get("user:1")? {
+//!     println!("Value: {:?}", value);
 //! }
 //!
 //! // Delete data
-//! engine.delete("user:1")?;
+//! engine.delete("user:1".to_string())?;
 //! # Ok(())
 //! # }
 //! ```

src/main.rs

@@ -1,8 +1,8 @@
-use lsm_kv_store::{LsmConfig, LsmEngine};
+use apexstore::{LsmConfig, LsmEngine};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let config = LsmConfig::builder()
-        .dir_path("/var/lib/lsm_kv_store/data")
+        .dir_path("/var/lib/apexstore/data")
         .build()?;
 
     let _engine = LsmEngine::new(config)?;