WalFlow.Stores.Memory 0.1.0-alpha.alpha.20260708090623

WalFlow.Stores.Memory

In-memory store for WalFlow CDC processor. State is NOT persisted across restarts. Suitable for testing, development, or scenarios where state persistence is not required.

Features

• In-Memory Storage: Fast, zero-dependency storage using ConcurrentDictionary
• Thread-Safe: Safe for concurrent access
• State Cloning: Clones state on save to prevent external modifications
• Testing Utilities: Includes Clear() and Count properties for testing
• No Persistence: State is lost on restart (by design)

Installation

dotnet add package WalFlow.Stores.Memory

Usage

Basic Registration

services.AddSingleton<IReplicationStore, MemoryStore>();

Complete Example

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using WalFlow.Abstractions;
using WalFlow.Stores.Memory;

var services = new ServiceCollection();

// Add logging
services.AddLogging(builder => builder.AddConsole());

// Register memory store
services.AddSingleton<IReplicationStore, MemoryStore>();

var serviceProvider = services.BuildServiceProvider();
var stateStore = serviceProvider.GetRequiredService<IReplicationStore>();

// Use the store
var state = new ReplicationState { SlotName = "my_slot", LastProcessedLsn = 12345 };
await stateStore.SaveReplicationStateAsync(state);

var loaded = await stateStore.LoadReplicationStateAsync("my_slot");
Console.WriteLine($"Loaded LSN: {loaded?.LastProcessedLsn}");

Direct Instantiation

var logger = loggerFactory.CreateLogger<MemoryStore>();
var stateStore = new MemoryStore(logger);

// Save state
await stateStore.SaveReplicationStateAsync(new ReplicationState 
{ 
    SlotName = "test_slot",
    LastProcessedLsn = 12345,
    MessagesProcessed = 1000
});

// Load state
var state = await stateStore.LoadReplicationStateAsync("test_slot");

Testing Utilities

var memoryStore = serviceProvider.GetRequiredService<IReplicationStore>() as MemoryStore;

// Check how many states are stored
Console.WriteLine($"States stored: {memoryStore.Count}");

// Clear all states (useful between tests)
memoryStore.Clear();

Use Cases

✅ Good For

• Unit and integration testing
• Development and debugging
• Proof-of-concept implementations
• Stateless/ephemeral CDC scenarios
• Load testing (no I/O overhead)

❌ Not Suitable For

• Production deployments (state lost on restart)
• Multi-instance deployments (state not shared)
• Long-running processes (memory growth over time)
• State recovery after crashes

State Isolation

Each MemoryStore instance maintains its own isolated state. If you need shared state across components, register it as a singleton:

// Singleton - shared state across all components
services.AddSingleton<IReplicationStore, MemoryStore>();

// Transient - each component gets its own isolated state (rarely needed)
services.AddTransient<IReplicationStore, MemoryStore>();

Thread Safety

The MemoryStore is thread-safe and uses ConcurrentDictionary internally. Multiple threads can safely call LoadReplicationStateAsync and SaveReplicationStateAsync concurrently.

Memory Considerations

State is stored in memory and will grow over time. For long-running processes with frequent state updates, consider:

• Periodically calling Clear() for slots that are no longer active
• Monitoring memory usage
• Using a persistent store for production

Comparison with Other Stores

License

See the LICENSE file in the repository root.