Trait atomic_lib::storelike::Storelike

source · [−]
pub trait Storelike: Sized {

Show 29 methods    fn add_atoms(&self, atoms: Vec<Atom>) -> AtomicResult<()>;
    fn add_resource_opts(
        &self, 
        resource: &Resource, 
        check_required_props: bool, 
        update_index: bool, 
        overwrite_existing: bool
    ) -> AtomicResult<()>;
    fn all_resources(&self, include_external: bool) -> ResourceCollection;
    fn get_server_url(&self) -> &str;
    fn get_resource(&self, subject: &str) -> AtomicResult<Resource>;
    fn remove_resource(&self, subject: &str) -> AtomicResult<()>;
    fn set_default_agent(&self, agent: Agent);

    fn add_atom_to_index(
        &self, 
        _atom: &Atom, 
        _resource: &Resource
    ) -> AtomicResult<()> { ... }
    fn add_resource(&self, resource: &Resource) -> AtomicResult<()> { ... }
    fn build_index(&self, include_external: bool) -> AtomicResult<()> { ... }
    fn get_self_url(&self) -> Option<String> { ... }
    fn get_default_agent(&self) -> AtomicResult<Agent> { ... }
    fn create_agent(&self, name: Option<&str>) -> AtomicResult<Agent> { ... }
    fn export(&self, include_external: bool) -> AtomicResult<String> { ... }
    fn fetch_resource(&self, subject: &str) -> AtomicResult<Resource> { ... }
    fn get_resource_new(&self, subject: &str) -> Resource { ... }
    fn get_class(&self, subject: &str) -> AtomicResult<Class> { ... }
    fn get_classes_for_subject(&self, subject: &str) -> AtomicResult<Vec<Class>> { ... }
    fn get_property(&self, subject: &str) -> AtomicResult<Property> { ... }
    fn get_resource_extended(
        &self, 
        subject: &str, 
        skip_dynamic: bool, 
        for_agent: Option<&str>
    ) -> AtomicResult<Resource> { ... }
    fn handle_commit(&self, _commit_response: &CommitResponse) { ... }
    fn handle_not_found(
        &self, 
        subject: &str, 
        error: AtomicError
    ) -> AtomicResult<Resource> { ... }
    fn import(&self, string: &str) -> AtomicResult<usize> { ... }
    fn tpf(
        &self, 
        q_subject: Option<&str>, 
        q_property: Option<&str>, 
        q_value: Option<&Value>, 
        include_external: bool
    ) -> AtomicResult<Vec<Atom>> { ... }
    fn get_path(
        &self, 
        atomic_path: &str, 
        mapping: Option<&Mapping>, 
        for_agent: Option<&str>
    ) -> AtomicResult<PathReturn> { ... }
    fn populate(&self) -> AtomicResult<()> { ... }
    fn query(&self, q: &Query) -> AtomicResult<QueryResult> { ... }
    fn remove_atom_from_index(
        &self, 
        _atom: &Atom, 
        _resource: &Resource
    ) -> AtomicResult<()> { ... }
    fn validate(&self) -> ValidationReport { ... }

}
Expand description

Storelike provides many useful methods for interacting with an Atomic Store. It serves as a basic store Trait, agnostic of how it functions under the hood. This is useful, because we can create methods for Storelike that will work with either in-memory stores, as well as with persistent on-disk stores.

Required Methods

👎 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.

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

Returns a collection with 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. WARNING: This could be very expensive!

Returns the base URL where the default store is. E.g. https://example.com This is where deltas should be sent to. Also useful for Subject URL generation.

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.

Removes a resource from the store. Errors if not present.

Sets the default Agent for applying commits.

Provided Methods

Adds an Atom to the PropSubjectMap. Overwrites if already present. The default implementation for this does not do anything, so overwrite it if your store needs indexing.

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.

Constructs the value index from all resources in the store. Could take a while.

Returns the root URL where this instance of the store is hosted. Should return None if this is simply a client and not a server. E.g. https://example.com

Returns the default Agent for applying commits.

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().

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

Fetches a resource, makes sure its subject matches. Uses the default agent to sign the request. Save to the store.

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

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

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

Fetches a property by URL, returns a Property instance

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.

  • skip_dynamic Does not calculte dynamic properties. Adds an incomplete=true property if the resource should have been dynamic.

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

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

Triple Pattern Fragments interface. Use this for most queries, e.g. finding all items with some property / value combination. Returns an empty array if nothing is found.

Example

For example, if I want to view all Resources that are instances of the class “Property”, I’d do:

use atomic_lib::Storelike;
let mut store = atomic_lib::Store::init().unwrap();
store.populate();
let atoms = store.tpf(
    None,
    Some("https://atomicdata.dev/properties/isA"),
    Some(&atomic_lib::Value::AtomicUrl("https://atomicdata.dev/classes/Class".into())),
    true
).unwrap();
assert!(atoms.len() > 11)

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

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

Search the Store, returns the matching subjects. The second returned vector should be filled if query.include_resources is true. Tries query_cache, which you should implement yourself.

Removes an Atom from the PropSubjectMap.

Performs a light validation, without fetching external data

Implementors