🥮 mooncakes.io
    Sign in

    valkey

    Native async Valkey/Redis client for MoonBit

    Download zip
    Author
    Version
    0.5.0
    License
    MIT
    Repository
    Last updated
    4 months ago
    Downloads
    158

    #Valkey

    Native async Valkey/Redis client for MoonBit.

    Valkey provides a lightweight RESP implementation, TCP networking support, typed Redis helpers, Redis Streams support, and Consumer Group operations.

    Built on top of the moonbitlang/async runtime.

    #Features

    • Native RESP protocol implementation
    • Async TCP client
    • Typed Redis/Valkey commands
    • Redis Streams support
    • Consumer Groups
    • Pending message inspection
    • Message recovery helpers
    • MoonBit-native APIs

    #Installation

    {
  "deps": {
    "Metalymph/valkey": "0.5.0"
  }
}

    example moon.pkg:
    {
  "import": [
    "Metalymph/valkey"
  ]
}

    let client =
      @valkey.Client::connect(
        "127.0.0.1",
        6379,
      )

    let pong = client.ping()
    println(pong)

    #Relay Adapter

    This package also provides a backend adapter for Metalymph/relay.

    Add the dependency to your moon.pkg:
    {
  "import": [
    "Metalymph/relay/core",
    "Metalymph/valkey/relay"
  ]
}

    Usage:
    let backend = @relay.ValkeyStreamBackend::new(client, "my_stream", "my_group", "consumer_1")
    let queue = backend.to_relay_queue()

    Supported Features

    Core Commands

    • GET
    • SET
    • DEL
    • EXISTS
    • INCR
    • DECR
    • EXPIRE
    • TTL
    • PING

    Streams

    • XADD
    • XGROUP CREATE
    • XREADGROUP
    • XACK
    • XPENDING
    • XAUTOCLAIM

    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