Struct MemoryStore 

pub struct MemoryStore { /* private fields */ }

In-memory store implementation

Thread-safe in-memory store using RwLock for concurrent access.

Implementations

impl MemoryStore

pub fn new() -> MemoryStore

Create new in-memory store

pub fn with_vector_search(self, config: IndexConfig) -> MemoryStore

Create store with vector search enabled

Arguments

• config - Index configuration

pub const fn with_ttl_config(self, config: TTLConfig) -> MemoryStore

Configure TTL behavior for item expiration.

Arguments

• config - TTL configuration

pub async fn sweep_expired_items(&self) -> Result<usize, StoreError>

Sweep expired items from the store, returning the count of removed items.

This method iterates through all namespaces and their items, collecting keys where expires_at < now. It removes at most sweep_max_items expired items to avoid blocking other operations for extended periods.

The sweep is cooperative with the lazy cleanup in get() and search(): expired items are removed during normal reads, while this method performs bulk cleanup in the background.

Errors

Returns StoreError::Storage if the sweep operation encounters an unexpected error (currently unused, reserved for future extensions).

Examples

use juncture_core::store::{MemoryStore, Store, TTLConfig};
use std::time::Duration;
use serde_json::json;

let store = MemoryStore::new().with_ttl_config(TTLConfig {
    default_ttl: Some(Duration::from_millis(50)),
    refresh_on_read: false,
    ..Default::default()
});

store.put("ns", "key1", json!({ "v": 1 }), None).await?;
store.put("ns", "key2", json!({ "v": 2 }), None).await?;

// Wait for items to expire
tokio::time::sleep(Duration::from_millis(80)).await;

// Sweep removes both expired items
let count = store.sweep_expired_items().await?;
assert_eq!(count, 2);

pub fn start_sweep_task(self: Arc<MemoryStore>) -> JoinHandle<()>

Start the background sweep task for periodic expired item cleanup.

This method spawns a tokio task that runs periodically according to sweep_interval in the TTL config. Each sweep cycle removes at most sweep_max_items expired items. Errors are logged via tracing::warn! and do not terminate the task.

Note

The returned JoinHandle can be used to abort the task via handle.abort() or awaited to ensure the task completes. If dropped without aborting, the task will continue running in the background.

Examples

use juncture_core::store::{MemoryStore, TTLConfig};
use std::{time::Duration, sync::Arc};

let store = Arc::new(MemoryStore::new().with_ttl_config(TTLConfig {
    default_ttl: Some(Duration::from_secs(300)),
    refresh_on_read: true,
    ..Default::default()
}));

// Start background sweep task
let _sweep_handle = store.start_sweep_task();

// Store continues to work, sweep task runs in background
// The task will run until _sweep_handle is dropped or aborted

Trait Implementations

impl Debug for MemoryStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for MemoryStore

fn default() -> MemoryStore

Returns the “default value” for a type.

impl Store for MemoryStore

fn get<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Item>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryStore: 'async_trait,

Get item from store

fn put<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, value: Value, index: Option<Vec<String>>, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryStore: 'async_trait,

Put item into store

fn delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryStore: 'async_trait,

Delete item from store

fn search<'life0, 'async_trait>( &'life0 self, query: SearchQuery, ) -> Pin<Box<dyn Future<Output = Result<SearchResult, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryStore: 'async_trait,

Search items with filtering and optional vector search

fn list_namespaces<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, prefix: Option<&'life1 str>, suffix: Option<&'life2 str>, max_depth: Option<usize>, limit: Option<usize>, offset: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, MemoryStore: 'async_trait,

List namespaces

fn batch<'life0, 'async_trait>( &'life0 self, ops: Vec<StoreOp>, ) -> Pin<Box<dyn Future<Output = Result<Vec<StoreResult>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MemoryStore: 'async_trait,

Execute batch operations