update wasi keyvalue to draft2

Signed-off-by: David Justice <[email protected]>

Author: devigned

crates/factor-key-value/src/host.rs

@@ -228,17 +228,20 @@ impl wasi_keyvalue::store::HostBucket for KeyValueDispatch {
     async fn list_keys(
         &mut self,
         self_: Resource<Bucket>,
-        cursor: Option<u64>,
+        cursor: Option<String>,
     ) -> Result<wasi_keyvalue::store::KeyResponse, wasi_keyvalue::store::Error> {
-        if cursor.unwrap_or_default() != 0 {
-            return Err(wasi_keyvalue::store::Error::Other(
-                "list_keys: cursor not supported".to_owned(),
-            ));
+        match cursor {
+            Some(_) => {
+                Err(wasi_keyvalue::store::Error::Other(
+                    "list_keys: cursor not supported".to_owned(),
+                ))
+            },
+            None => {
+                let store = self.get_store_wasi(self_)?;
+                let keys = store.get_keys().await.map_err(to_wasi_err)?;
+                Ok(wasi_keyvalue::store::KeyResponse { keys, cursor: None })
+            }
         }
-
-        let store = self.get_store_wasi(self_)?;
-        let keys = store.get_keys().await.map_err(to_wasi_err)?;
-        Ok(wasi_keyvalue::store::KeyResponse { keys, cursor: None })
     }
 
     async fn drop(&mut self, rep: Resource<Bucket>) -> anyhow::Result<()> {

wit/deps/keyvalue-2024-05-03/atomic.wit

@@ -0,0 +1,46 @@
+/// A keyvalue interface that provides atomic operations.
+/// 
+/// Atomic operations are single, indivisible operations. When a fault causes an atomic operation to
+/// fail, it will appear to the invoker of the atomic operation that the action either completed
+/// successfully or did nothing at all.
+/// 
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface atomics {
+  use store.{bucket, error};
+
+  /// The error returned by a CAS operation
+  variant cas-error {
+	/// A store error occurred when performing the operation
+	store-error(error),
+	  /// The CAS operation failed because the value was too old. This returns a new CAS handle
+	  /// for easy retries. Implementors MUST return a CAS handle that has been updated to the
+	  /// latest version or transaction.
+	cas-failed(cas),
+  }
+
+  /// A handle to a CAS (compare-and-swap) operation.
+  resource cas {
+	/// Construct a new CAS operation. Implementors can map the underlying functionality
+	/// (transactions, versions, etc) as desired.
+	new: static func(bucket: borrow<bucket>, key: string) -> result<cas, error>;
+	/// Get the current value of the key (if it exists). This allows for avoiding reads if all
+	/// that is needed to ensure the atomicity of the operation
+	current: func() -> result<option<list<u8>>, error>;
+  }
+
+  /// Atomically increment the value associated with the key in the store by the given delta. It
+  /// returns the new value.
+  ///
+  /// If the key does not exist in the store, it creates a new key-value pair with the value set
+  /// to the given delta.
+  ///
+  /// If any other error occurs, it returns an `Err(error)`.
+  increment: func(bucket: borrow<bucket>, key: string, delta: s64) -> result<s64, error>;
+
+  /// Perform the swap on a CAS operation. This consumes the CAS handle and returns an error if
+  /// the CAS operation failed.
+  swap: func(cas: cas, value: list<u8>) -> result<_, cas-error>;
+}

wit/deps/keyvalue-2024-05-03/batch.wit

@@ -0,0 +1,63 @@
+/// A keyvalue interface that provides batch operations.
+/// 
+/// A batch operation is an operation that operates on multiple keys at once.
+/// 
+/// Batch operations are useful for reducing network round-trip time. For example, if you want to
+/// get the values associated with 100 keys, you can either do 100 get operations or you can do 1
+/// batch get operation. The batch operation is faster because it only needs to make 1 network call
+/// instead of 100.
+/// 
+/// A batch operation does not guarantee atomicity, meaning that if the batch operation fails, some
+/// of the keys may have been modified and some may not. 
+/// 
+/// This interface does has the same consistency guarantees as the `store` interface, meaning that
+/// you should be able to "read your writes."
+/// 
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface batch {
+  use store.{bucket, error};
+
+  /// Get the key-value pairs associated with the keys in the store. It returns a list of
+  /// key-value pairs.
+  ///
+  /// If any of the keys do not exist in the store, it returns a `none` value for that pair in the
+  /// list.
+  ///
+  /// MAY show an out-of-date value if there are concurrent writes to the store.
+  ///
+  /// If any other error occurs, it returns an `Err(error)`.
+  get-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<list<option<tuple<string, list<u8>>>>, error>;
+
+  /// Set the values associated with the keys in the store. If the key already exists in the
+  /// store, it overwrites the value.
+  ///
+  /// Note that the key-value pairs are not guaranteed to be set in the order they are provided.
+  ///
+  /// If any of the keys do not exist in the store, it creates a new key-value pair.
+  ///
+  /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+  /// rollback the key-value pairs that were already set. Thus, this batch operation does not
+  /// guarantee atomicity, implying that some key-value pairs could be set while others might
+  /// fail.
+  ///
+  /// Other concurrent operations may also be able to see the partial results.
+  set-many: func(bucket: borrow<bucket>, key-values: list<tuple<string, list<u8>>>) -> result<_, error>;
+
+  /// Delete the key-value pairs associated with the keys in the store.
+  ///
+  /// Note that the key-value pairs are not guaranteed to be deleted in the order they are
+  /// provided.
+  ///
+  /// If any of the keys do not exist in the store, it skips the key.
+  ///
+  /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+  /// rollback the key-value pairs that were already deleted. Thus, this batch operation does not
+  /// guarantee atomicity, implying that some key-value pairs could be deleted while others might
+  /// fail.
+  ///
+  /// Other concurrent operations may also be able to see the partial results.
+  delete-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<_, error>;
+}