componentized:valkey-as-keyvalue

Imports

• componentized:valkey/resp
• componentized:valkey/store
• wasi:config/store@0.2.0-rc.1

Exports

• wasi:keyvalue/store@0.2.0-draft2
• wasi:keyvalue/atomics@0.2.0-draft2
• wasi:keyvalue/batch@0.2.0-draft2

WIT

package root:component;

world root {
  import componentized:valkey/resp;
  import componentized:valkey/store;
  import wasi:config/store@0.2.0-rc.1;

  export wasi:keyvalue/store@0.2.0-draft2;
  export wasi:keyvalue/atomics@0.2.0-draft2;
  export wasi:keyvalue/batch@0.2.0-draft2;
}
package componentized:valkey {
  interface resp {
    type error = string;
  }
  interface store {
    use resp.{error as resp-error};

    resource connection {
      hdel: func(key: string, field: string) -> result<_, error>;
      hexists: func(key: string, field: string) -> result<bool, error>;
      hget: func(key: string, field: string) -> result<option<string>, error>;
      hincrby: func(key: string, field: string, increment: s64) -> result<s64, error>;
      hkeys: func(key: string) -> result<list<string>, error>;
      hset: func(key: string, field: string, value: string) -> result<_, error>;
    }

    variant error {
      client(string),
      resp(resp-error),
      valkey(string),
    }

    record hello-opts {
      proto-ver: option<string>,
      auth: option<tuple<string, string>>,
      client-name: option<string>,
    }

    connect: func(host: string, port: u16, opts: option<hello-opts>) -> result<connection, error>;
  }
}


package wasi:config@0.2.0-rc.1 {
  interface store {
    variant error {
      upstream(string),
      io(string),
    }

    get: func(key: string) -> result<option<string>, error>;
  }
}


package wasi:keyvalue@0.2.0-draft2 {
  interface store {
    variant error {
      no-such-store,
      access-denied,
      other(string),
    }

    record key-response {
      keys: list<string>,
      cursor: option<string>,
    }

    resource bucket {
      get: func(key: string) -> result<option<list<u8>>, error>;
      set: func(key: string, value: list<u8>) -> result<_, error>;
      delete: func(key: string) -> result<_, error>;
      exists: func(key: string) -> result<bool, error>;
      list-keys: func(cursor: option<string>) -> result<key-response, error>;
    }

    open: func(identifier: string) -> result<bucket, error>;
  }
  interface atomics {
    use store.{bucket, error};

    resource cas {
      new: static func(bucket: borrow<bucket>, key: string) -> result<cas, error>;
      current: func() -> result<option<list<u8>>, error>;
    }

    variant cas-error {
      store-error(error),
      cas-failed(cas),
    }

    increment: func(bucket: borrow<bucket>, key: string, delta: s64) -> result<s64, error>;

    swap: func(cas: cas, value: list<u8>) -> result<_, cas-error>;
  }
  interface batch {
    use store.{bucket, error};

    get-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<list<option<tuple<string, list<u8>>>>, error>;

    set-many: func(bucket: borrow<bucket>, key-values: list<tuple<string, list<u8>>>) -> result<_, error>;

    delete-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<_, error>;
  }
}