wash new interface keyvalue

// key-value.smithy
// Definition of a key-value store and the 'wasmcloud:keyvalue' capability contract
//

// Tell the code generator how to reference symbols defined in this namespace
metadata package = [{
    namespace: "org.wasmcloud.interface.keyvalue",
    crate: "wasmcloud_interface_keyvalue",
    py_module: "wasmcloud_interface_keyvalue",
    doc: "Keyvalue: wasmcloud capability contract for key-value store",
}]

namespace org.wasmcloud.interface.keyvalue

use org.wasmcloud.model#wasmbus
use org.wasmcloud.model#rename
use org.wasmcloud.model#n
use org.wasmcloud.model#U32
use org.wasmcloud.model#I32

@wasmbus(
    contractId: "wasmcloud:keyvalue",
    providerReceive: true )
service KeyValue {
  version: "0.1.1",
  operations: [
    Increment, Contains, Del, Get,
    ListAdd, ListClear, ListDel, ListRange,
    Set, , SetAdd, SetDel, SetIntersection, SetQuery, SetUnion, SetClear,
  ]
}

/// Gets a value for a specified key. If the key exists,
/// the return structure contains exists: true and the value,
/// otherwise the return structure contains exists == false.
@readonly
operation Get {
  input: String,
  output: GetResponse,
}

/// Response to get request
structure GetResponse {
    /// the value, if it existed
    @required
    @n(0)
    value: String,
    /// whether or not the value existed
    @required
    @n(1)
    exists: Boolean,
}

/// Sets the value of a key.
/// expires is an optional number of seconds before the value should be automatically deleted,
/// or 0 for no expiration.
operation Set {
  input: SetRequest,
}

structure SetRequest {
    /// the key name to change (or create)
    @required
    @n(0)
    key: String,

    /// the new value
    @required
    @n(1)
    value: String,

    /// expiration time in seconds 0 for no expiration
    @required
    @n(2)
    expires: U32,
}

/// Deletes a key, returning true if the key was deleted
@rename([{lang:"Python", name:"delete"}])
operation Del {
  input: String,
  output: Boolean,
}

/// Increments a numeric value, returning the new value
operation Increment {
  input: IncrementRequest,
  output: I32
}

structure IncrementRequest {
    /// name of value to increment
  @required
  @n(0)
  key: String,
  /// amount to add to value
  @required
  @n(1)
  value: I32,
}

/// list of strings
list StringList {
  member: String
}

/// Append a value onto the end of a list. Returns the new list size
operation ListAdd {
  input: ListAddRequest,
  output: U32
}

/// Parameter to ListAdd operation
structure ListAddRequest {
    /// name of the list to modify
    @required
    @n(0)
    listName: String,

    /// value to append to the list
    @required
    @n(1)
    value: String,
}

/// Deletes a value from a list. Returns true if the item was removed.
operation ListDel{
  input: ListDelRequest,
  output: Boolean
}

/// Removes an item from the list. If the item occurred more than once,
/// removes only the first item.
/// Returns true if the item was found.
structure ListDelRequest {
    /// name of list to modify
  @required
  @n(0)
  listName: String,
  @required
  @n(1)
  value: String
}

/// Deletes a list and its contents
/// input: list name
/// output: true if the list existed and was deleted
operation ListClear {
  input: String,
  output: Boolean
}

/// Retrieves a range of values from a list using 0-based indices.
/// Start and end values are inclusive, for example, (0,10) returns
/// 11 items if the list contains at least 11 items. If the stop value
/// is beyond the end of the list, it is treated as the end of the list.
operation ListRange {
    input: ListRangeRequest,
    output: StringList,
}

structure ListRangeRequest {

    /// name of list
    @required
    @n(0)
    listName: String,

    /// start index of the range, 0-based, inclusive.
    @required
    @n(1)
    start: I32,

    /// end index of the range, 0-based, inclusive.
    @required
    @n(2)
    stop: I32,
}

/// Add an item into a set. Returns number of items added (1 or 0)
operation SetAdd {
  input: SetAddRequest,
  output: U32,
}

structure SetAddRequest {
    /// name of the set
    @required
    @n(0)
    setName: String,
    /// value to add to the set
    @required
    @n(1)
    value: String,
}

/// Deletes an item from the set. Returns number of items removed from the set (1 or 0)
operation SetDel {
  input: SetDelRequest,
  output: U32,
}

structure SetDelRequest {
  @required
  @n(0)
  setName: String,

  @required
  @n(1)
  value: String,
}

/// perform union of sets and returns values from the union
/// input: list of sets for performing union (at least two)
/// output: union of values
operation SetUnion {
  input: StringList,
  output: StringList,
}

/// perform intersection of sets and returns values from the intersection.
/// input: list of sets for performing intersection (at least two)
/// output: values
operation SetIntersection {
  input: StringList,
  output: StringList,
}

/// Retrieves all items from a set
/// input: String
/// output: set members
operation SetQuery {
  input: String,
  output: StringList,
}

/// returns whether the store contains the key
@readonly
operation Contains {
  input: String,
  output: Boolean,
}

/// clears all values from the set and removes it
/// input: set name
/// output: true if the set existed and was deleted
operation SetClear {
    input: String
    output: Boolean
}

wash new provider kvredis

/// Handle KeyValue methods that interact with redis
#[async_trait]
impl KeyValue for KvRedisProvider {
		/// Increments a numeric value, returning the new value
    #[instrument(level = "debug", skip(self, ctx, arg), fields(actor_id = ?ctx.actor, key = %arg.key))]
    **async fn increment**(&self, ctx: &Context, arg: &IncrementRequest) -> RpcResult<i32> {
        let mut cmd = redis::Cmd::incr(&arg.key, &arg.value);
        let val: i32 = self.exec(ctx, &mut cmd).await?;
        Ok(val)
    }

    /// Deletes a key, returning true if the key was deleted
    #[instrument(level = "debug", skip(self, ctx, arg), fields(actor_id = ?ctx.actor, key = %arg.to_string()))]
    **async fn del**<TS: ToString + ?Sized + Sync>(&self, ctx: &Context, arg: &TS) -> RpcResult<bool> {
        let mut cmd = redis::Cmd::del(arg.to_string());
        let val: i32 = self.exec(ctx, &mut cmd).await?;
        Ok(val > 0)
    }

    /// Gets a value for a specified key. If the key exists,
    /// the return structure contains exists: true and the value,
    /// otherwise the return structure contains exists == false.
    #[instrument(level = "debug", skip(self, ctx, arg), fields(actor_id = ?ctx.actor, key = %arg.to_string()))]
    **async fn get**<TS: ToString + ?Sized + Sync>(
        &self,
        ctx: &Context,
        arg: &TS,
    ) -> RpcResult<GetResponse> {
        let mut cmd = redis::Cmd::get(arg.to_string());
        let val: Option<String> = self.exec(ctx, &mut cmd).await?;
        let resp = match val {
            Some(s) => GetResponse {
                exists: true,
                value: s,
            },
            None => GetResponse {
                exists: false,
                ..Default::default()
            },
        };
        Ok(resp)
    }

    /// Sets the value of a key.
    /// expires is an optional number of seconds before the value should be automatically deleted,
    /// or 0 for no expiration.
    #[instrument(level = "debug", skip(self, ctx, arg), fields(actor_id = ?ctx.actor, key = %arg.key))]
    **async fn set**(&self, ctx: &Context, arg: &SetRequest) -> RpcResult<()> {
        let mut cmd = match arg.expires {
            0 => redis::Cmd::set(&arg.key, &arg.value),
            _ => redis::Cmd::set_ex(&arg.key, &arg.value, arg.expires as usize),
        };
        let _value: Option<String> = self.exec(ctx, &mut cmd).await?;
        Ok(())
    }

 wash new actor kvcounter

# examples/actor/kvcounter

PROJECT = kvcounter
VERSION = $(shell cargo metadata --no-deps --format-version 1 | jq -r '.packages[] .version' | head -1)
REVISION = 0
# list of all contract claims for actor signing (space-separated)
**CLAIMS=wasmcloud:httpserver wasmcloud:keyvalue**

[package]
name = "kvcounter"

[dependencies]
**wasmcloud-interface-keyvalue = "0.7.0"**
**wasmcloud-interface-httpserver = "0.6.0"**

#[async_trait]
impl HttpServer for KvCounterActor {
    async fn handle_request(&self, ctx: &Context, req: &HttpRequest) -> RpcResult<HttpResponse> {
        // increment the value in kv and send response in json
        let (body, status_code) = match **increment_counter**(ctx, key, amount).await {
            Ok(v) => (json!({ "counter": v }).to_string(), 200),
            // if we caught an error, return it to client
            Err(e) => (json!({ "error": e.to_string() }).to_string(), 500),
        };
        let resp = HttpResponse {
            body: body.as_bytes().to_vec(),
            status_code,
            ..Default::default()
        };
        Ok(resp)
    }
}

/// increment the counter by the amount, returning the new value
async fn increment_counter(ctx: &Context, key: String, value: i32) -> RpcResult<i32> {
    let new_val = KeyValueSender::new()
        **.increment(ctx, &IncrementRequest { key, value })**
        .await?;
    Ok(new_val)
}

➜ ~ curl localhost:8080
{"counter":17}%
➜ ~ curl localhost:8080
{"counter":18}%