Struct Store 

pub struct Store {
    pub base_domain: Arc<Mutex<Option<String>>>,
    /* private fields */
}

The in-memory store of data, containing the Resources, Properties and Classes It uses the default_agent as the default client.

Fields

base_domain: Arc<Mutex<Option<String>>>

The base domain of the store

Implementations

impl Store

pub async fn init() -> AtomicResult<Store>

Creates an empty Store. Run .populate() to get useful standard models loaded into your store.

pub fn set_base_url(&self, url: &str)

Sets the base URL of the store.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Storelike for Store

fn add_atoms<'life0, 'async_trait>( &'life0 self, atoms: Vec<Atom>, ) -> Pin<Box<dyn Future<Output = AtomicResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

👎Deprecated since 0.28.0:

The atoms abstraction has been deprecated in favor of Resources

Adds Atoms to the store. Will replace existing Atoms that share Subject / Property combination. Validates datatypes and required props presence.

fn add_drive_mapping(&self, host: &str, drive_did: &Value) -> AtomicResult<()>

Maps a host (domain/subdomain) to a Drive DID.

fn remove_drive_mapping(&self, host: &str) -> AtomicResult<()>

Removes the drive mapping for a given host.

fn get_base_domain(&self) -> Option<String>

Returns the base domain of the store, e.g. “https://atomicdata.dev”.

fn set_base_url(&self, url: &str)

Sets the base URL of the store.

fn add_resource_opts<'life0, 'life1, 'async_trait>( &'life0 self, resource: &'life1 Resource, check_required_props: bool, update_index: bool, overwrite_existing: bool, ) -> Pin<Box<dyn Future<Output = AtomicResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Adds a Resource to the store. Replaces existing resource with the contents. Does not do any validations.

fn all_resources( &self, _include_external: bool, ) -> Box<dyn Iterator<Item = Resource> + Send>

Returns an iterator that iterates over all resources in the store. If Include_external is false, this is filtered by selecting only resoureces that match the self URL of the store.

fn get_default_agent(&self) -> AtomicResult<Agent>

Returns the default Agent for applying commits.

fn get_resource<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 Subject, ) -> Pin<Box<dyn Future<Output = AtomicResult<Resource>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns a full Resource with native Values. Note that this does not construct dynamic Resources, such as collections. If you’re not sure what to use, use get_resource_extended. Returns a full Resource with native Values. Note that this does not construct dynamic Resources, such as collections. If you’re not sure what to use, use get_resource_extended.

fn has_stored_resource(&self, subject: &Subject) -> bool

Returns true when the resource is present in the local backing store.

fn remove_resource<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 Subject, ) -> Pin<Box<dyn Future<Output = AtomicResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Removes a resource and its children from the store. Errors if not present.

fn set_default_agent(&self, agent: Agent)

Sets the default Agent for applying commits.

fn query<'life0, 'life1, 'async_trait>( &'life0 self, q: &'life1 Query, ) -> Pin<Box<dyn Future<Output = AtomicResult<QueryResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Search the Store, returns the matching subjects.

fn get_server_url(&self) -> String

Returns the full server URL, e.g. “http://localhost:9883” or “https://atomicdata.dev”. Used by client helpers to route DID resolution requests through the server’s `/did` endpoint.

fn sync_policy(&self) -> Arc<dyn SyncPolicy>

The sync admission/quota policy for this store. The default is the permissive crate::sync::policy::OpenPolicy (self-hosted / local-first, and every non-Db store). A managed node’s Db returns the policy installed via Db::set_sync_policy, which the commit / sync paths consult to gate writes to un-enrolled drives.

fn get_active_drive(&self) -> Option<String>

Get the active drive subject, if one is set.

fn clear_tombstone(&self, _subject: &str)

Clear a bulk-sync tombstone for subject — see [crate::sync::tombstones::clear_tombstone] (F11, planning/unified-sync.md): a subject that legitimately passes a rights-checked genesis again after being destroyed must not keep being invisible to future bulk sync. No-op default for stores with no tombstone concept (test doubles, non-Db stores); Db overrides this to call the real KV-backed implementation.

fn set_active_drive(&self, _drive: &str) -> AtomicResult<()>

Set the active drive subject.

fn clear_default_agent(&self)

Clear the default agent.

fn normalize_subject(&self, subject: &Subject) -> Subject

fn add_resource<'life0, 'life1, 'async_trait>( &'life0 self, resource: &'life1 Resource, ) -> Pin<Box<dyn Future<Output = AtomicResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Adds a Resource to the store. Replaces existing resource with the contents. Updates the index. Validates the fields (checks required props). In most cases, you should use resource.save() instead, which uses Commits.

fn apply_commit<'life0, 'life1, 'async_trait>( &'life0 self, commit: Commit, opts: &'life1 CommitOpts, ) -> Pin<Box<dyn Future<Output = AtomicResult<CommitResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Takes a Commit and applies it to the Store. This includes changing the resource, writing the changes, verifying the checks specified in your CommitOpts The returned CommitResponse contains the new resource and the saved Commit Resource.

fn get_value<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 str, property: &'life2 str, ) -> Pin<Box<dyn Future<Output = AtomicResult<Value>> + Send + 'async_trait>>

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

Returns a single Value from a Resource

fn create_agent<'life0, 'life1, 'async_trait>( &'life0 self, name: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = AtomicResult<Agent>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create an Agent, storing its public key. An Agent is required for signing Commits. Returns a tuple of (subject, private_key). Make sure to store the private_key somewhere safe! Does not create a Commit - the recommended way is to use agent.to_resource().save_locally().

fn export(&self, include_external: bool) -> AtomicResult<String>

Exports the store to a big JSON-AD file. Sorts the export by first exporting Property Resources, which makes importing faster and more dependent.

fn fetch_resource<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 str, client_agent: Option<&'life2 Agent>, ) -> Pin<Box<dyn Future<Output = AtomicResult<Resource>> + Send + 'async_trait>>

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

Fetches a resource, makes sure its subject matches. Save to the store. Uses client_agent for Authentication.

fn search<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, opts: SearchOpts, ) -> Pin<Box<dyn Future<Output = AtomicResult<Vec<Resource>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs a full-text search on the Server’s /search endpoint. Requires a server URL to be set.

fn get_defaults_fingerprint(&self) -> AtomicResult<Option<String>>

The fingerprint of the built-in defaults (lib/defaults/*.json + base models) that were last seeded into this store, if the store persists one. See crate::populate::bootstrap. Stores that do not persist it return None, which makes every open re-run the (idempotent) seed.

fn set_defaults_fingerprint(&self, _fingerprint: &str) -> AtomicResult<()>

Records the defaults fingerprint after a successful seed. No-op for stores that do not persist it.

fn get_resource_new<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 Subject, ) -> Pin<Box<dyn Future<Output = Resource> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns an existing resource, or creates a new one with the given Subject

fn get_class<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 str, ) -> Pin<Box<dyn Future<Output = AtomicResult<Class>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves a Class from the store by subject URL and converts it into a Class useful for forms

fn get_classes_for_subject<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 Subject, ) -> Pin<Box<dyn Future<Output = AtomicResult<Vec<Class>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Finds all classes (isA) for any subject. Returns an empty vector if there are none.

fn get_property<'life0, 'life1, 'async_trait>( &'life0 self, subject: &'life1 str, ) -> Pin<Box<dyn Future<Output = AtomicResult<Property>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetches a property by URL, returns a Property instance

fn get_resource_extended<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 Subject, skip_dynamic: bool, for_agent: &'life2 ForAgent, ) -> Pin<Box<dyn Future<Output = AtomicResult<ResourceResponse>> + Send + 'async_trait>>

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

Get’s the resource, parses the Query parameters and calculates dynamic properties. Defaults to get_resource if store doesn’t support extended resources If for_agent is None, no authorization checks will be done, and all resources will return. If you want public only resurces, pass Some(crate::authentication::public_agent) as the agent.

fn handle_commit(&self, _commit_response: &CommitResponse)

This function is called whenever a Commit is applied. Implement this if you want to have custom handlers for Commits.

fn handle_not_found<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, subject: &'life1 str, _error: AtomicError, for_agent: Option<&'life2 Agent>, ) -> Pin<Box<dyn Future<Output = AtomicResult<Resource>> + Send + 'async_trait>>

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

fn import<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, string: &'life1 str, parse_opts: &'life2 ParseOpts, ) -> Pin<Box<dyn Future<Output = AtomicResult<usize>> + Send + 'async_trait>>

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

Imports a JSON-AD string, returns the amount of imported resources.

fn get_path<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, atomic_path: &'life1 str, mapping: Option<&'life2 Mapping>, for_agent: &'life3 ForAgent, ) -> Pin<Box<dyn Future<Output = AtomicResult<PathReturn>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Accepts an Atomic Path string, returns the result value (resource or property value) E.g. https://example.com description or thing isa 0 https://docs.atomicdata.dev/core/paths.html The for_agent argument is used to check if the user has rights to the resource. You can pass None if you don’t care about the rights (e.g. in client side apps) If you want to perform read rights checks, pass Some for_agent subject

fn post_resource<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _subject: &'life1 str, _body: Vec<u8>, _for_agent: &'life2 ForAgent, ) -> Pin<Box<dyn Future<Output = AtomicResult<Resource>> + Send + 'async_trait>>

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

Handles a HTTP POST request to the store. This is where [crate::endpoints::Endpoint] are used.

fn populate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = AtomicResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads the default store. For DBs it also adds default Collections and Endpoints.

fn validate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ValidationReport> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Performs a light validation, without fetching external data

fn begin_batch(&self)

Start buffering writes for a single batched transaction.

fn commit_batch(&self) -> AtomicResult<()>

Commit all buffered writes. No-op if not batching.