Struct AsyncDejaDB 

pub struct AsyncDejaDB { /* private fields */ }

A DejaDB that is safe to use from async code.

Cheap to clone: every clone shares one store. Operations against it serialise, because the underlying store is &mut-driven; callers queue asynchronously rather than occupying blocking threads. Clone this into tasks rather than wrapping it in an Arc.

Call close when the store must be shut down before the process moves on; otherwise dropping the last handle is enough.

Implementations

impl AsyncDejaDB

pub async fn open(path: &str) -> Result<Self>

Open a store at path.

pub async fn open_with(path: &str, opts: DejaDbOptions) -> Result<Self>

Open with explicit DejaDbOptions.

pub async fn open_encrypted(path: &str, key: [u8; 32]) -> Result<Self>

Open an encrypted store.

The key is held in a zeroize::Zeroizing buffer for as long as this call owns it, so the copy handed to the blocking pool is wiped once the store is open rather than left in freed memory.

pub async fn with<T, F>(&self, op: F) -> Result<T>

where F: FnOnce(&mut DejaDB) -> Result<T> + Send + 'static, T: Send + 'static,

Run an arbitrary operation against the store, safely, on the blocking pool.

This is the escape hatch: any DejaDB method not wrapped below stays reachable without reintroducing the runtime hazard.

let rebuilt = db.with(|db| db.rebuild_text_index()).await?;

pub async fn add<G>(&self, grain: G) -> Result<Hash>

where G: Grain + Send + 'static,

Add a grain, returning its content hash.

pub async fn add_if_novel<G>(&self, grain: G) -> Result<(Hash, bool)>

where G: Grain + Send + 'static,

Add a grain only if its content is not already present.

pub async fn latest( &self, ns: &str, subject: &str, relation: &str, ) -> Result<Option<DeserializedGrain>>

The current grain for (namespace, subject, relation).

pub async fn recall_hybrid( &self, ns: &str, subject: Option<&str>, relation: Option<&str>, query: Option<&str>, k: usize, deadline: Option<Duration>, ) -> Result<Vec<DeserializedGrain>>

Hybrid recall (triple + text + vector legs, RRF-fused).

pub async fn recent( &self, ns: &str, gtype: Option<GrainType>, limit: usize, ) -> Result<Vec<DeserializedGrain>>

The most recent grains in a namespace.

pub async fn forget(&self, hash: Hash) -> Result<()>

Tombstone a grain by hash.

pub async fn stats(&self) -> Result<StoreStats>

Store statistics.

pub async fn close(self) -> Result<()>

Close the store, waiting for teardown to finish.

Dropping the last handle also closes the store, but it does so on a detached thread and cannot be awaited: if the process exits immediately afterwards, teardown may not have run. Call close when the store must be shut down before the program moves on — on graceful shutdown, before copying the .db file, or at the end of a test.

The store is shared by every clone, so this closes it for all of them: subsequent operations on any handle fail. It waits for an in-flight operation to finish first, and closing an already-closed store is a no-op.

Trait Implementations

impl Clone for AsyncDejaDB

fn clone(&self) -> AsyncDejaDB

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for AsyncDejaDB

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.