wasi-passthrough-keyvalue 0.2.0

wasi:keyvalue passthrough layer
Documentation 
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::bindings::exports;
use crate::bindings::exports::wasi::keyvalue::store::BucketBorrow;
use crate::bindings::wasi::keyvalue::store::{Error, KeyResponse};
use crate::bindings::wasi::keyvalue::{atomics, batch, store};

impl From<Error> for exports::wasi::keyvalue::store::Error {
    fn from(value: Error) -> Self {
        match value {
            Error::NoSuchStore => Self::NoSuchStore,
            Error::AccessDenied => Self::AccessDenied,
            Error::Other(s) => Self::Other(s),
        }
    }
}

impl From<exports::wasi::keyvalue::store::Error> for Error {
    fn from(value: exports::wasi::keyvalue::store::Error) -> Self {
        match value {
            exports::wasi::keyvalue::store::Error::NoSuchStore => Self::NoSuchStore,
            exports::wasi::keyvalue::store::Error::AccessDenied => Self::AccessDenied,
            exports::wasi::keyvalue::store::Error::Other(s) => Self::Other(s),
        }
    }
}

impl From<KeyResponse> for exports::wasi::keyvalue::store::KeyResponse {
    fn from(value: KeyResponse) -> Self {
        Self {
            keys: value.keys,
            cursor: value.cursor,
        }
    }
}

impl From<exports::wasi::keyvalue::store::KeyResponse> for KeyResponse {
    fn from(value: exports::wasi::keyvalue::store::KeyResponse) -> Self {
        Self {
            keys: value.keys,
            cursor: value.cursor,
        }
    }
}

impl exports::wasi::keyvalue::store::Guest for () {
    type Bucket = store::Bucket;

    fn open(
        identifier: String,
    ) -> Result<exports::wasi::keyvalue::store::Bucket, exports::wasi::keyvalue::store::Error> {
        let res = store::open(&identifier)?;
        Ok(exports::wasi::keyvalue::store::Bucket::new(res))
    }
}

impl exports::wasi::keyvalue::store::GuestBucket for store::Bucket {
    fn get(&self, key: String) -> Result<Option<Vec<u8>>, exports::wasi::keyvalue::store::Error> {
        let res = Self::get(self, &key)?;
        Ok(res)
    }

    fn set(
        &self,
        key: String,
        value: Vec<u8>,
    ) -> Result<(), exports::wasi::keyvalue::store::Error> {
        Self::set(self, &key, &value)?;
        Ok(())
    }

    fn delete(&self, key: String) -> Result<(), exports::wasi::keyvalue::store::Error> {
        Self::delete(self, &key)?;
        Ok(())
    }

    fn exists(&self, key: String) -> Result<bool, exports::wasi::keyvalue::store::Error> {
        let res = Self::exists(self, &key)?;
        Ok(res)
    }

    fn list_keys(
        &self,
        cursor: Option<u64>,
    ) -> Result<exports::wasi::keyvalue::store::KeyResponse, exports::wasi::keyvalue::store::Error>
    {
        let res = Self::list_keys(self, cursor)?;
        Ok(res.into())
    }
}

impl exports::wasi::keyvalue::atomics::Guest for () {
    fn increment(
        bucket: BucketBorrow<'_>,
        key: String,
        delta: u64,
    ) -> Result<u64, exports::wasi::keyvalue::store::Error> {
        let res = atomics::increment(bucket.get(), &key, delta)?;
        Ok(res)
    }
}

impl exports::wasi::keyvalue::batch::Guest for () {
    fn get_many(
        bucket: BucketBorrow<'_>,
        keys: Vec<String>,
    ) -> Result<Vec<Option<(String, Vec<u8>)>>, exports::wasi::keyvalue::store::Error> {
        let res = batch::get_many(bucket.get(), &keys)?;
        Ok(res)
    }

    fn set_many(
        bucket: BucketBorrow<'_>,
        key_values: Vec<(String, Vec<u8>)>,
    ) -> Result<(), exports::wasi::keyvalue::store::Error> {
        batch::set_many(bucket.get(), &key_values)?;
        Ok(())
    }

    fn delete_many(
        bucket: BucketBorrow<'_>,
        keys: Vec<String>,
    ) -> Result<(), exports::wasi::keyvalue::store::Error> {
        batch::delete_many(bucket.get(), &keys)?;
        Ok(())
    }
}