🥮 mooncakes.io
    Sign in

    valkey

    Native async Valkey/Redis client for MoonBit

    Download zip
    Author
    Version
    0.4.1
    License
    Apache-2.0
    Repository
    Last updated
    4 months ago
    Downloads
    158

    Metalymph/valkey does not have a README file

    RespError

    source
    pub suberror RespError {
      InvalidPrefix(Int)
      UnexpectedEndOfStream
      MalformedNumber
      MalformedCrlf
    } derive(ToJson, 
    Debug    )

    RespError represents errors occurring during RESP parsing.

    ValkeyError

    source
    pub suberror ValkeyError {
      ConnectionError(String)
      ProtocolError(String)
    } derive(ToJson, 
    Debug    )

    ValkeyError represents the error types handled by the Valkey driver.

    Client

    source
    pub struct Client {
      conn : 
    Tcp
    }

    Client is a native Valkey/Redis client supporting asynchronous operations.

    Client::connect

    source
    async fn Client::connect(host : String, port : Int) -> Client

    connect opens an asynchronous connection to the specified host and port.

    Client::del

    source
    async fn Client::del(self : Client, key : String) -> Int64

    del removes a key and returns the number of deleted keys.

    Client::exists

    source
    async fn Client::exists(self : Client, key : String) -> Bool

    exists returns true when the key exists.

    Client::get

    source
    async fn Client::get(self : Client, key : String) -> String?

    get returns a string value by key, or None when the key does not exist.

    Client::ping

    source
    async fn Client::ping(self : Client) -> Unit

    ping sends a PING command to the server and expects a PONG response.

    Client::read_response

    source
    async fn Client::read_response(self : Client) -> RespValue

    read_response reads a RESP response from the server.

    Client::request

    source
    async fn Client::request(self : Client, args : Array[String]) -> RespValue

    request sends a command and returns the response.

    Client::send_command

    source
    async fn Client::send_command(self : Client, args : Array[String]) -> Unit

    send_command encodes and sends a RESP command to the server.

    Client::set

    source
    async fn Client::set(self : Client, key : String, value : String) -> Unit

    set stores a string value by key.

    Client::xack

    source
    async fn Client::xack(self : Client, stream : String, group : String, id : String) -> Int64

    xack acknowledges a stream entry and returns the number of acknowledged ids.

    Client::xadd

    source
    async fn Client::xadd(self : Client, stream : String, payload : String) -> String

    xadd appends a payload field to a stream and returns the generated entry id.

    Client::xautoclaim

    source
    async fn Client::xautoclaim(self : Client, stream : String, group : String, consumer : String, min_idle_ms : Int) -> (String, String)?

    xautoclaim claims one pending stream entry and returns its (id, payload).

    Client::xgroup_create

    source
    async fn Client::xgroup_create(self : Client, stream : String, group : String) -> Unit

    xgroup_create creates a consumer group for a stream, creating the stream if needed.

    Client::xpending_count

    source
    async fn Client::xpending_count(self : Client, stream : String, group : String) -> Int64

    xpending_count returns the number of pending entries for a consumer group.

    Client::xreadgroup

    source
    async fn Client::xreadgroup(self : Client, stream : String, group : String, consumer : String, count : Int) -> (String, String)?

    xreadgroup reads one payload entry from a stream consumer group.

    Client::xreadgroup_block

    source
    async fn Client::xreadgroup_block(self : Client, stream : String, group : String, consumer : String, count : Int, block_ms : Int) -> (String, String)?

    xreadgroup_block reads one payload entry from a stream consumer group, blocking for up to block_ms milliseconds.

    RespParser

    source
    pub struct RespParser[R] {
      reader : R
    }

    RespParser handles decoding RESP messages from a stream.

    RespParser::new

    source
    fn[R] RespParser::new(reader : R) -> RespParser[R]

    new creates a new RespParser from an object implementing @io.Reader.

    RespParser::parse_value

    source
    async fn[R : 
    Reader    ] RespParser::parse_value(self : RespParser[R]) -> RespValue

    parse_value decodes a single RespValue from the reader.

    RespValue

    source
    pub enum RespValue {
      SimpleString(String)
      Error(String)
      Integer(Int64)
      BulkString(String?)
      Array(Array[RespValue]?)
    } derive(ToJson, 
    Debug    )

    RespValue represents the different types in the RESP (Redis Serialization Protocol).

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io