samod 0.9.0

A rust library for managing automerge documents, compatible with the js automerge-repo library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! The storage abstraction

use std::collections::HashMap;

pub use samod_core::StorageKey;

mod filesystem;
mod in_memory;
pub use in_memory::InMemoryStorage;

#[cfg(feature = "tokio")]
pub use filesystem::tokio::FilesystemStorage as TokioFilesystemStorage;

#[cfg(feature = "gio")]
pub use filesystem::gio::FilesystemStorage as GioFilesystemStorage;

/// The storage abstraction used by a [`Repo`](crate::Repo) to store document data
///
/// This trait is designed to be pretty general. It's effectively a key/value store
/// with range queries. In particular there are no assumptions about the ordering of
/// operations between calls to methods on storage and no assumption of exclusive
/// access to storage.
///
/// I.e. you can have multiple storage instances mutating the same shared storage,
/// `samod` is designed so that this will never lose data.
///
/// ## Storage Keys
///
/// Storage is a key/value store. The keys are effectively `Vec<String>`. This
/// matches things like filesystems, where each element in the `Vec<String>` is
/// a directory and the last item is a file. It can just as well be implemented
/// in other mediums. To make this easier `StorageKey` guarantees that none of
/// the components of the key contain a "/", this means you can use `"/"` to
/// join elements of the key when storing the key as a string.
pub trait Storage: Send + Clone + 'static {
    /// Load a specific key from storage
    fn load(&self, key: StorageKey) -> impl Future<Output = Option<Vec<u8>>> + Send;
    /// Load a range of keys from storage, all of which begin with `prefix`
    ///
    /// Note that you can use [`StorageKey::is_prefix_of`] to implement this
    /// in simple cases
    fn load_range(
        &self,
        prefix: StorageKey,
    ) -> impl Future<Output = HashMap<StorageKey, Vec<u8>>> + Send;
    /// Put a particular value into storage
    fn put(&self, key: StorageKey, data: Vec<u8>) -> impl Future<Output = ()> + Send;
    /// Delete a value from storage
    fn delete(&self, key: StorageKey) -> impl Future<Output = ()> + Send;
}

/// A version of [`Storage`] that can be used with runtimes that don't require
/// `Send` or `'static` bounds. See the [module level documentation on
/// runtimes](../index.html#runtimes) for more details.
pub trait LocalStorage: Clone + 'static {
    /// Load a specific key from storage
    fn load(&self, key: StorageKey) -> impl Future<Output = Option<Vec<u8>>>;
    /// Load a range of keys from storage, all of which begin with `prefix`
    ///
    /// Note that you can use [`StorageKey::is_prefix_of`] to implement this
    /// in simple cases
    fn load_range(&self, prefix: StorageKey) -> impl Future<Output = HashMap<StorageKey, Vec<u8>>>;
    /// Put a particular value into storage
    fn put(&self, key: StorageKey, data: Vec<u8>) -> impl Future<Output = ()>;
    /// Delete a value from storage
    fn delete(&self, key: StorageKey) -> impl Future<Output = ()>;
}

impl<S: Storage> LocalStorage for S {
    fn load(&self, key: StorageKey) -> impl Future<Output = Option<Vec<u8>>> {
        Storage::load(self, key)
    }

    fn load_range(&self, prefix: StorageKey) -> impl Future<Output = HashMap<StorageKey, Vec<u8>>> {
        Storage::load_range(self, prefix)
    }

    fn put(&self, key: StorageKey, data: Vec<u8>) -> impl Future<Output = ()> {
        Storage::put(self, key, data)
    }

    fn delete(&self, key: StorageKey) -> impl Future<Output = ()> {
        Storage::delete(self, key)
    }
}