hotkv 1.0.0

data/lib/hotkv/commands/sorted_sets.rb

@@ -0,0 +1,258 @@
+# Copyright (c) 2026 HotKV Ltd
+# Licensed under the Apache License, Version 2.0. See LICENSE in the project root.
+
+module HotKV
+  module Commands
+    # Sorted set commands, including the BYSCORE/BYLEX/REV/LIMIT ZRANGE
+    # family and the RESP3 array-of-pairs WITHSCORES shape.
+    module SortedSets
+      # +score_members+ is a Hash {member => score}, or a flat/paired list
+      # of scores and members: zadd("k", 1, "a", 2, "b") or
+      # zadd("k", [1, "a"], [2, "b"]).
+      def zadd(key, *score_members, nx: false, xx: false, gt: false, lt: false, ch: false, incr: false)
+        args = ["ZADD", key]
+        args.push("NX") if nx
+        args.push("XX") if xx
+        args.push("GT") if gt
+        args.push("LT") if lt
+        args.push("CH") if ch
+        args.push("INCR") if incr
+        args.concat(flatten_score_members(score_members))
+        invoke(*args) { |r| incr ? (r.nil? ? nil : Wire.parse_float(r)) : r }
+      end
+
+      def zrem(key, *members)
+        invoke("ZREM", key, *members.flatten)
+      end
+
+      def zscore(key, member)
+        invoke("ZSCORE", key, member) { |r| r.nil? ? nil : Wire.parse_float(r) }
+      end
+
+      def zmscore(key, *members)
+        invoke("ZMSCORE", key, *members.flatten) { |r| r.map { |v| v.nil? ? nil : Wire.parse_float(v) } }
+      end
+
+      def zcard(key)
+        invoke("ZCARD", key)
+      end
+
+      def zcount(key, min, max)
+        invoke("ZCOUNT", key, min, max)
+      end
+
+      def zincrby(key, increment, member)
+        invoke("ZINCRBY", key, increment, member) { |r| Wire.parse_float(r) }
+      end
+
+      # Modern ZRANGE, covering plain index range, BYSCORE, BYLEX, REV and
+      # LIMIT (an [offset, count] pair, only valid with BYSCORE/BYLEX).
+      # With :with_scores, returns an Array of [member, score] pairs
+      # (paired up uniformly regardless of the RESP2/RESP3 wire shape).
+      def zrange(key, start, stop, byscore: false, bylex: false, rev: false, limit: nil, with_scores: false)
+        args = ["ZRANGE", key, start, stop]
+        args.push("BYSCORE") if byscore
+        args.push("BYLEX") if bylex
+        args.push("REV") if rev
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        args.push("WITHSCORES") if with_scores
+        invoke(*args) { |r| with_scores ? Support.pairify(r) : r }
+      end
+
+      def zrangestore(destination, source, start, stop, byscore: false, bylex: false, rev: false, limit: nil)
+        args = ["ZRANGESTORE", destination, source, start, stop]
+        args.push("BYSCORE") if byscore
+        args.push("BYLEX") if bylex
+        args.push("REV") if rev
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        invoke(*args)
+      end
+
+      def zrevrange(key, start, stop, with_scores: false)
+        args = ["ZREVRANGE", key, start, stop]
+        args.push("WITHSCORES") if with_scores
+        invoke(*args) { |r| with_scores ? Support.pairify(r) : r }
+      end
+
+      def zrangebyscore(key, min, max, with_scores: false, limit: nil)
+        args = ["ZRANGEBYSCORE", key, min, max]
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        args.push("WITHSCORES") if with_scores
+        invoke(*args) { |r| with_scores ? Support.pairify(r) : r }
+      end
+
+      def zrevrangebyscore(key, max, min, with_scores: false, limit: nil)
+        args = ["ZREVRANGEBYSCORE", key, max, min]
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        args.push("WITHSCORES") if with_scores
+        invoke(*args) { |r| with_scores ? Support.pairify(r) : r }
+      end
+
+      def zrangebylex(key, min, max, limit: nil)
+        args = ["ZRANGEBYLEX", key, min, max]
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        invoke(*args)
+      end
+
+      def zrevrangebylex(key, max, min, limit: nil)
+        args = ["ZREVRANGEBYLEX", key, max, min]
+        args.push("LIMIT", limit[0], limit[1]) if limit
+        invoke(*args)
+      end
+
+      def zlexcount(key, min, max)
+        invoke("ZLEXCOUNT", key, min, max)
+      end
+
+      def zrank(key, member, with_score: false)
+        args = ["ZRANK", key, member]
+        args.push("WITHSCORE") if with_score
+        invoke(*args) { |r| with_score ? (r.nil? ? nil : [r[0], Wire.parse_float(r[1])]) : r }
+      end
+
+      def zrevrank(key, member, with_score: false)
+        args = ["ZREVRANK", key, member]
+        args.push("WITHSCORE") if with_score
+        invoke(*args) { |r| with_score ? (r.nil? ? nil : [r[0], Wire.parse_float(r[1])]) : r }
+      end
+
+      # No :count -> a single [member, score] Array, or nil if empty.
+      # With :count -> an Array of [member, score] pairs (possibly empty).
+      def zpopmin(key, count = nil)
+        pop("ZPOPMIN", key, count)
+      end
+
+      def zpopmax(key, count = nil)
+        pop("ZPOPMAX", key, count)
+      end
+
+      def zrandmember(key, count = nil, withscores: false)
+        return invoke("ZRANDMEMBER", key) if count.nil?
+
+        args = ["ZRANDMEMBER", key, count]
+        args.push("WITHSCORES") if withscores
+        invoke(*args) { |r| withscores ? Support.pairify(r) : r }
+      end
+
+      def zremrangebyrank(key, start, stop)
+        invoke("ZREMRANGEBYRANK", key, start, stop)
+      end
+
+      def zremrangebyscore(key, min, max)
+        invoke("ZREMRANGEBYSCORE", key, min, max)
+      end
+
+      def zremrangebylex(key, min, max)
+        invoke("ZREMRANGEBYLEX", key, min, max)
+      end
+
+      def zunionstore(destination, keys, weights: nil, aggregate: nil)
+        invoke(*zstore_args("ZUNIONSTORE", destination, keys, weights, aggregate))
+      end
+
+      def zinterstore(destination, keys, weights: nil, aggregate: nil)
+        invoke(*zstore_args("ZINTERSTORE", destination, keys, weights, aggregate))
+      end
+
+      def zdiffstore(destination, keys)
+        invoke("ZDIFFSTORE", destination, keys.length, *keys)
+      end
+
+      def zunion(keys, weights: nil, aggregate: nil, with_scores: false)
+        invoke(*zset_op_args("ZUNION", keys, weights, aggregate, with_scores)) do |r|
+          with_scores ? Support.pairify(r) : r
+        end
+      end
+
+      def zinter(keys, weights: nil, aggregate: nil, with_scores: false)
+        invoke(*zset_op_args("ZINTER", keys, weights, aggregate, with_scores)) do |r|
+          with_scores ? Support.pairify(r) : r
+        end
+      end
+
+      def zdiff(keys, with_scores: false)
+        args = ["ZDIFF", keys.length, *keys]
+        args.push("WITHSCORES") if with_scores
+        invoke(*args) { |r| with_scores ? Support.pairify(r) : r }
+      end
+
+      def zintercard(keys, limit: nil)
+        args = ["ZINTERCARD", keys.length, *keys]
+        args.push("LIMIT", limit) if limit
+        invoke(*args)
+      end
+
+      # Pops from the first non-empty sorted set of +keys+ (ZMPOP). +where+ is
+      # "MIN" or "MAX". Returns [key, [[member, score], ...]] or nil.
+      def zmpop(keys, where, count: nil)
+        args = ["ZMPOP", keys.length, *keys, where]
+        args.push("COUNT", count) if count
+        invoke(*args) { |r| zmpop_reply(r) }
+      end
+
+      # Blocking ZMPOP: waits up to +timeout+ seconds. Same reply as #zmpop.
+      def bzmpop(keys, where, timeout: 0, count: nil)
+        args = ["BZMPOP", timeout, keys.length, *keys, where]
+        args.push("COUNT", count) if count
+        invoke(*args) { |r| zmpop_reply(r) }
+      end
+
+      # Blocking ZPOPMIN across +keys+. Returns [key, member, score] or nil.
+      def bzpopmin(*keys, timeout: 0)
+        invoke("BZPOPMIN", *keys.flatten, timeout) { |r| bzpop_reply(r) }
+      end
+
+      # Blocking ZPOPMAX across +keys+. Returns [key, member, score] or nil.
+      def bzpopmax(*keys, timeout: 0)
+        invoke("BZPOPMAX", *keys.flatten, timeout) { |r| bzpop_reply(r) }
+      end
+
+      private
+
+      def zmpop_reply(reply)
+        return nil if reply.nil?
+
+        key, pairs = reply
+        [key, pairs.map { |(member, score)| [member, Wire.parse_float(score)] }]
+      end
+
+      def bzpop_reply(reply)
+        return nil if reply.nil?
+
+        key, member, score = reply
+        [key, member, Wire.parse_float(score)]
+      end
+
+      def pop(cmd, key, count)
+        if count
+          invoke(cmd, key, count) { |r| Support.pairify(r) }
+        else
+          invoke(cmd, key) { |r| (r.nil? || r.empty?) ? nil : [r[0], Wire.parse_float(r[1])] }
+        end
+      end
+
+      def flatten_score_members(args)
+        if args.length == 1 && args.first.is_a?(Hash)
+          args.first.flat_map { |member, score| [score, member] }
+        else
+          args.flatten
+        end
+      end
+
+      def zstore_args(cmd, destination, keys, weights, aggregate)
+        args = [cmd, destination, keys.length, *keys]
+        args.push("WEIGHTS", *weights) if weights
+        args.push("AGGREGATE", aggregate) if aggregate
+        args
+      end
+
+      def zset_op_args(cmd, keys, weights, aggregate, with_scores)
+        args = [cmd, keys.length, *keys]
+        args.push("WEIGHTS", *weights) if weights
+        args.push("AGGREGATE", aggregate) if aggregate
+        args.push("WITHSCORES") if with_scores
+        args
+      end
+    end
+  end
+end

data/lib/hotkv/commands/streams.rb

@@ -0,0 +1,207 @@
+# Copyright (c) 2026 HotKV Ltd
+# Licensed under the Apache License, Version 2.0. See LICENSE in the project root.
+
+module HotKV
+  module Commands
+    # Stream commands (XADD, consumer groups, claiming, trimming, XINFO).
+    module Streams
+      # +fields+ is a Hash or a flat [field, value, ...] list.
+      #
+      # Idempotent append: :idmp is a [producer, iid] pair, and the
+      # same pair within the stream's IDMP-DURATION adds nothing and returns
+      # the original entry id; :idmpauto is a producer name whose id is derived
+      # from the fields. Both need id "*".
+      def xadd(key, fields, id: "*", maxlen: nil, minid: nil, approx: true, nomkstream: false, limit: nil,
+               idmp: nil, idmpauto: nil)
+        args = ["XADD", key]
+        args.push("NOMKSTREAM") if nomkstream
+        args.push("IDMP", idmp[0], idmp[1]) if idmp
+        args.push("IDMPAUTO", idmpauto) if idmpauto
+        args.concat(trim_clause(maxlen, minid, approx, limit))
+        args.push(id)
+        args.concat(fields.is_a?(Hash) ? fields.flatten(1) : fields.flatten)
+        invoke(*args)
+      end
+
+      # -> Array of [id, {field => value}] entries, oldest first.
+      def xrange(key, start = "-", stop = "+", count: nil)
+        args = ["XRANGE", key, start, stop]
+        args.push("COUNT", count) if count
+        invoke(*args) { |r| entries_to_pairs(r) }
+      end
+
+      def xrevrange(key, stop = "+", start = "-", count: nil)
+        args = ["XREVRANGE", key, stop, start]
+        args.push("COUNT", count) if count
+        invoke(*args) { |r| entries_to_pairs(r) }
+      end
+
+      def xlen(key)
+        invoke("XLEN", key)
+      end
+
+      def xdel(key, *ids)
+        invoke("XDEL", key, *ids.flatten)
+      end
+
+      def xtrim(key, maxlen: nil, minid: nil, approx: true, limit: nil)
+        invoke("XTRIM", key, *trim_clause(maxlen, minid, approx, limit))
+      end
+
+      # +keys+/+ids+ are parallel Arrays. -> Hash {stream_key => entries},
+      # entries shaped like #xrange's result, or nil on timeout/no data.
+      def xread(keys:, ids:, count: nil, block: nil)
+        args = ["XREAD"]
+        args.push("COUNT", count) if count
+        args.push("BLOCK", block) if block
+        args.push("STREAMS", *keys, *ids)
+        invoke(*args) { |r| streams_to_h(r) }
+      end
+
+      def xreadgroup(group, consumer, keys:, ids:, count: nil, block: nil, noack: false)
+        args = ["XREADGROUP", "GROUP", group, consumer]
+        args.push("COUNT", count) if count
+        args.push("BLOCK", block) if block
+        args.push("NOACK") if noack
+        args.push("STREAMS", *keys, *ids)
+        invoke(*args) { |r| streams_to_h(r) }
+      end
+
+      def xack(key, group, *ids)
+        invoke("XACK", key, group, *ids.flatten)
+      end
+
+      def xgroup_create(key, group, id = "$", mkstream: false)
+        args = ["XGROUP", "CREATE", key, group, id]
+        args.push("MKSTREAM") if mkstream
+        invoke(*args) { |r| r == "OK" }
+      end
+
+      def xgroup_destroy(key, group)
+        invoke("XGROUP", "DESTROY", key, group) { |r| r == 1 }
+      end
+
+      def xgroup_createconsumer(key, group, consumer)
+        invoke("XGROUP", "CREATECONSUMER", key, group, consumer) { |r| r == 1 }
+      end
+
+      def xgroup_delconsumer(key, group, consumer)
+        invoke("XGROUP", "DELCONSUMER", key, group, consumer)
+      end
+
+      def xgroup_setid(key, group, id = "$")
+        invoke("XGROUP", "SETID", key, group, id) { |r| r == "OK" }
+      end
+
+      # No :start/:stop/:count -> summary Hash {count:, min_id:, max_id:,
+      # consumers: [[name, pending_count], ...]}. With them -> an Array of
+      # {id:, consumer:, idle_ms:, deliveries:} Hashes (the extended form).
+      def xpending(key, group, start: nil, stop: nil, count: nil, consumer: nil, idle: nil)
+        if start.nil? && stop.nil? && count.nil?
+          invoke("XPENDING", key, group) { |r| pending_summary(r) }
+        else
+          args = ["XPENDING", key, group]
+          args.push("IDLE", idle) if idle
+          args.push(start || "-", stop || "+", count || 10)
+          args.push(consumer) if consumer
+          invoke(*args) { |r| pending_detail(r) }
+        end
+      end
+
+      def xclaim(key, group, consumer, min_idle_time, *ids, idle: nil, time: nil, retrycount: nil, force: false,
+                 justid: false)
+        args = ["XCLAIM", key, group, consumer, min_idle_time, *ids.flatten]
+        args.push("IDLE", idle) if idle
+        args.push("TIME", time) if time
+        args.push("RETRYCOUNT", retrycount) if retrycount
+        args.push("FORCE") if force
+        args.push("JUSTID") if justid
+        invoke(*args) { |r| justid ? r : entries_to_pairs(r) }
+      end
+
+      # -> {cursor:, entries:, deleted:}. +entries+ is shaped like #xrange's
+      # result unless :justid, in which case it is a plain Array of ids.
+      def xautoclaim(key, group, consumer, min_idle_time, start = "0", count: nil, justid: false)
+        args = ["XAUTOCLAIM", key, group, consumer, min_idle_time, start]
+        args.push("COUNT", count) if count
+        args.push("JUSTID") if justid
+        invoke(*args) do |r|
+          cursor, claimed, deleted = r
+          { cursor: cursor, entries: justid ? claimed : entries_to_pairs(claimed), deleted: deleted || [] }
+        end
+      end
+
+      def xinfo_stream(key)
+        invoke("XINFO", "STREAM", key) { |r| to_h_any(r) }
+      end
+
+      def xinfo_groups(key)
+        invoke("XINFO", "GROUPS", key) { |r| r.map { |g| to_h_any(g) } }
+      end
+
+      def xinfo_consumers(key, group)
+        invoke("XINFO", "CONSUMERS", key, group) { |r| r.map { |c| to_h_any(c) } }
+      end
+
+      # Sets the last delivered id of +key+ (and optionally the entries added /
+      # max deleted id counters).
+      def xsetid(key, last_id, entriesadded: nil, maxdeletedid: nil)
+        args = ["XSETID", key, last_id]
+        args.push("ENTRIESADDED", entriesadded) if entriesadded
+        args.push("MAXDELETEDID", maxdeletedid) if maxdeletedid
+        invoke(*args) { |r| r == "OK" }
+      end
+
+      # Sets how long (:idmp_duration seconds) and how many (:idmp_maxsize)
+      # idempotent ids a stream keeps per producer (XCFGSET).
+      def xcfgset(key, idmp_duration: nil, idmp_maxsize: nil)
+        args = ["XCFGSET", key]
+        args.push("IDMP-DURATION", idmp_duration) if idmp_duration
+        args.push("IDMP-MAXSIZE", idmp_maxsize) if idmp_maxsize
+        invoke(*args) { |r| r == "OK" }
+      end
+
+      private
+
+      def trim_clause(maxlen, minid, approx, limit)
+        args = []
+        if maxlen
+          args.push("MAXLEN", approx ? "~" : "=", maxlen)
+        elsif minid
+          args.push("MINID", approx ? "~" : "=", minid)
+        end
+        args.push("LIMIT", limit) if limit && !args.empty?
+        args
+      end
+
+      def entries_to_pairs(entries)
+        return [] if entries.nil?
+
+        entries.map { |(id, flat)| [id, flat.nil? ? nil : to_h_any(flat)] }
+      end
+
+      def streams_to_h(reply)
+        return nil if reply.nil?
+
+        pairs = reply.is_a?(Hash) ? reply.to_a : reply
+        pairs.to_h { |(name, entries)| [name, entries_to_pairs(entries)] }
+      end
+
+      def to_h_any(r)
+        r.is_a?(Hash) ? r : r.each_slice(2).to_h
+      end
+
+      def pending_summary(r)
+        return { count: 0, min_id: nil, max_id: nil, consumers: [] } if r.nil? || r[0] == 0
+
+        count, min_id, max_id, consumers = r
+        { count: count, min_id: min_id, max_id: max_id,
+          consumers: (consumers || []).map { |(name, pending)| [name, pending.to_i] } }
+      end
+
+      def pending_detail(r)
+        (r || []).map { |(id, consumer, idle_ms, deliveries)| { id: id, consumer: consumer, idle_ms: idle_ms, deliveries: deliveries } }
+      end
+    end
+  end
+end

data/lib/hotkv/commands/strings.rb

@@ -0,0 +1,178 @@
+# Copyright (c) 2026 HotKV Ltd
+# Licensed under the Apache License, Version 2.0. See LICENSE in the project root.
+
+module HotKV
+  module Commands
+    # String commands: GET/SET and friends.
+    module Strings
+      # Fetches the value of +key+, or nil when it does not exist.
+      def get(key)
+        invoke("GET", key)
+      end
+
+      # Sets +key+ to +value+. Options mirror the SET command: :ex/:px
+      # (relative TTL, seconds/milliseconds), :exat/:pxat (absolute TTL,
+      # unix seconds/milliseconds), :keepttl (keep the current TTL),
+      # :nx/:xx (only set if absent/present), :get (return the previous
+      # value instead of "OK"). :ifeq/:ifne compare the current string value
+      # and :ifdeq/:ifdne its digest (see #digest); the write is skipped when
+      # the condition fails. Returns "OK", the previous value (with :get), or
+      # nil when :nx/:xx/:if* prevented the write.
+      def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, keepttl: false, nx: false, xx: false, get: false,
+              ifeq: nil, ifne: nil, ifdeq: nil, ifdne: nil)
+        args = ["SET", key, value]
+        args.push("EX", ex) if ex
+        args.push("PX", px) if px
+        args.push("EXAT", exat) if exat
+        args.push("PXAT", pxat) if pxat
+        args.push("KEEPTTL") if keepttl
+        args.push("NX") if nx
+        args.push("XX") if xx
+        args.push("IFEQ", ifeq) unless ifeq.nil?
+        args.push("IFNE", ifne) unless ifne.nil?
+        args.push("IFDEQ", ifdeq) unless ifdeq.nil?
+        args.push("IFDNE", ifdne) unless ifdne.nil?
+        args.push("GET") if get
+        invoke(*args)
+      end
+
+      def setnx(key, value)
+        invoke("SETNX", key, value) { |r| r == 1 }
+      end
+
+      def setex(key, seconds, value)
+        invoke("SETEX", key, seconds, value)
+      end
+
+      def psetex(key, milliseconds, value)
+        invoke("PSETEX", key, milliseconds, value)
+      end
+
+      def getset(key, value)
+        invoke("GETSET", key, value)
+      end
+
+      def getdel(key)
+        invoke("GETDEL", key)
+      end
+
+      def getex(key, ex: nil, px: nil, exat: nil, pxat: nil, persist: false)
+        args = ["GETEX", key]
+        args.push("EX", ex) if ex
+        args.push("PX", px) if px
+        args.push("EXAT", exat) if exat
+        args.push("PXAT", pxat) if pxat
+        args.push("PERSIST") if persist
+        invoke(*args)
+      end
+
+      def append(key, value)
+        invoke("APPEND", key, value)
+      end
+
+      def strlen(key)
+        invoke("STRLEN", key)
+      end
+
+      def incr(key)
+        invoke("INCR", key)
+      end
+
+      def decr(key)
+        invoke("DECR", key)
+      end
+
+      def incrby(key, amount)
+        invoke("INCRBY", key, amount)
+      end
+
+      def decrby(key, amount)
+        invoke("DECRBY", key, amount)
+      end
+
+      def incrbyfloat(key, amount)
+        invoke("INCRBYFLOAT", key, Wire.finite(amount)) { |r| Wire.parse_float(r) }
+      end
+
+      def mget(*keys)
+        invoke("MGET", *keys.flatten)
+      end
+
+      # Accepts either a Hash or an already flat [key, value, key, value...]
+      # list.
+      def mset(hash_or_pairs)
+        invoke("MSET", *flatten_pairs(hash_or_pairs)) { |r| r == "OK" }
+      end
+
+      def msetnx(hash_or_pairs)
+        invoke("MSETNX", *flatten_pairs(hash_or_pairs)) { |r| r == 1 }
+      end
+
+      def getrange(key, start, stop)
+        invoke("GETRANGE", key, start, stop)
+      end
+
+      def setrange(key, offset, value)
+        invoke("SETRANGE", key, offset, value)
+      end
+
+      # Deprecated alias of #getrange.
+      def substr(key, start, stop)
+        invoke("SUBSTR", key, start, stop)
+      end
+
+      # Longest common subsequence of two string keys. Without options returns
+      # the subsequence; :len returns its length; :idx returns a Hash
+      # {"matches" => [[[a_start, a_end], [b_start, b_end], (len)], ...],
+      # "len" => n} (the match positions, with :withmatchlen the lengths;
+      # :minmatchlen drops shorter matches).
+      def lcs(key1, key2, len: false, idx: false, minmatchlen: nil, withmatchlen: false)
+        args = ["LCS", key1, key2]
+        args.push("LEN") if len
+        args.push("IDX") if idx
+        args.push("MINMATCHLEN", minmatchlen) if minmatchlen
+        args.push("WITHMATCHLEN") if withmatchlen
+        invoke(*args) { |r| idx && r.is_a?(Array) ? r.each_slice(2).to_h : r }
+      end
+
+      # Sets several keys in one step with one TTL (MSETEX). +pairs+
+      # is a Hash or a flat [key, value, ...] list. Options: :nx/:xx (all or
+      # none), and one of :ex/:px/:exat/:pxat/:keepttl. Returns true when the
+      # keys were set, false when :nx/:xx prevented it.
+      def msetex(pairs, nx: false, xx: false, ex: nil, px: nil, exat: nil, pxat: nil, keepttl: false)
+        flat = flatten_pairs(pairs)
+        args = ["MSETEX", flat.length / 2, *flat]
+        args.push("NX") if nx
+        args.push("XX") if xx
+        args.push("EX", ex) if ex
+        args.push("PX", px) if px
+        args.push("EXAT", exat) if exat
+        args.push("PXAT", pxat) if pxat
+        args.push("KEEPTTL") if keepttl
+        invoke(*args) { |r| r == 1 }
+      end
+
+      # Deletes +key+, or only when its string value meets a condition
+      # (:ifeq/:ifne value, :ifdeq/:ifdne digest). Returns true when deleted.
+      def delex(key, ifeq: nil, ifne: nil, ifdeq: nil, ifdne: nil)
+        args = ["DELEX", key]
+        args.push("IFEQ", ifeq) unless ifeq.nil?
+        args.push("IFNE", ifne) unless ifne.nil?
+        args.push("IFDEQ", ifdeq) unless ifdeq.nil?
+        args.push("IFDNE", ifdne) unless ifdne.nil?
+        invoke(*args) { |r| r == 1 }
+      end
+
+      # The XXH3-64 digest of the string at +key+ as 16 hex digits, or nil.
+      def digest(key)
+        invoke("DIGEST", key)
+      end
+
+      private
+
+      def flatten_pairs(hash_or_pairs)
+        hash_or_pairs.is_a?(Hash) ? hash_or_pairs.flatten(1) : hash_or_pairs.flatten(1)
+      end
+    end
+  end
+end