Struct JsonFileStore 

pub struct JsonFileStore { /* private fields */ }

JSON-file-backed state store.

Each namespace is a single JSON file at {root}/{namespace}.json. Writes are atomic: the new state is written to a .tmp sibling and then renamed.

The root directory is provided at construction time; callers are expected to resolve it from the service-layer AppDir abstraction (typically ~/.algocline/state/).

Concurrency

Per-namespace locks (std::sync::Mutex) prevent lost updates under concurrent alc.state.* calls within the same process. The lock is acquired for the full load → mutate → atomic-rename cycle, so two tokio tasks operating on the same namespace are serialised.

Rationale for std::sync::Mutex over tokio::sync::Mutex: all I/O inside the lock uses std::fs (synchronous, no .await), so a standard mutex is sufficient and avoids holding a tokio mutex across potential scheduler context switches.

Multi-process safety is NOT provided. If multiple alc processes share the same state directory (uncommon), use a backend with native INCR (Redis) or transactions (SQLite).

Implementations

impl JsonFileStore

pub fn new(root: PathBuf) -> Self

Construct a store rooted at an explicit path.

The directory is not created eagerly; it is created lazily on the first set / set_nx / incr call via Self::state_path.

pub fn root(&self) -> &Path

Return the root directory this store writes under.

pub fn state_path(&self, ns: &str) -> Result<PathBuf, String>

Resolve the JSON file path for a namespace, validating the name and creating the root directory on demand.

Trait Implementations

impl StateStore for JsonFileStore

fn get(&self, ns: &str, key: &str) -> Result<Option<Value>, String>

Read a value. Returns None if the key does not exist.

fn set(&self, ns: &str, key: &str, value: Value) -> Result<(), String>

Write a value (upsert).

fn delete(&self, ns: &str, key: &str) -> Result<bool, String>

Remove a key. Returns true if it existed.

fn keys(&self, ns: &str) -> Result<Vec<String>, String>

List all keys in a namespace.

fn has(&self, ns: &str, key: &str) -> Result<bool, String>

Check whether a key exists.

fn set_nx(&self, ns: &str, key: &str, value: Value) -> Result<bool, String>

Set a value only if the key does not already exist. Returns true if the value was written, false if the key was already present.

fn incr( &self, ns: &str, key: &str, delta: f64, default: f64, ) -> Result<f64, String>

Counter increment, serialised per namespace within the same process.