feat: implement HEXPIRE command

CHANGELOG.md

@@ -1,7 +1,13 @@
 ## Changelog
 
 
+## v2.37.0
+
+- suport HEXPIRE (thanks @mojixcoder)
+
+
 ## v2.36.1
+
 - support CLUSTER SHARDS (thanks @dadrus)
 
 

cmd_hash.go

@@ -3,9 +3,11 @@
 package miniredis
 
 import (
+	"fmt"
 	"math/big"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/alicebob/miniredis/v2/server"
 )
@@ -28,6 +30,7 @@ func commandsHash(m *Miniredis) {
 	m.srv.Register("HVALS", m.cmdHvals, server.ReadOnlyOption())
 	m.srv.Register("HSCAN", m.cmdHscan, server.ReadOnlyOption())
 	m.srv.Register("HRANDFIELD", m.cmdHrandfield, server.ReadOnlyOption())
+	m.srv.Register("HEXPIRE", m.cmdHexpire)
 }
 
 // HSET
@@ -641,6 +644,151 @@ func (m *Miniredis) cmdHrandfield(c *server.Peer, cmd string, args []string) {
 	})
 }
 
+// HEXPIRE
+func (m *Miniredis) cmdHexpire(c *server.Peer, cmd string, args []string) {
+	if !m.isValidCMD(c, cmd, args, atLeast(5)) {
+		return
+	}
+
+	opts, err := parseHExpireArgs(args)
+	if err != "" {
+		setDirty(c)
+		c.WriteError(err)
+		return
+	}
+
+	withTx(m, c, func(peer *server.Peer, ctx *connCtx) {
+		db := m.db(ctx.selectedDB)
+
+		if _, ok := db.keys[opts.key]; !ok {
+			c.WriteLen(len(opts.fields))
+			for range opts.fields {
+				c.WriteInt(-2)
+			}
+			return
+		}
+
+		if db.t(opts.key) != keyTypeHash {
+			c.WriteError(msgWrongType)
+			return
+		}
+
+		fieldTTLs := db.hashTTLs[opts.key]
+		if fieldTTLs == nil {
+			fieldTTLs = map[string]time.Duration{}
+			db.hashTTLs[opts.key] = fieldTTLs
+		}
+
+		c.WriteLen(len(opts.fields))
+		for _, field := range opts.fields {
+			if _, ok := db.hashKeys[opts.key][field]; !ok {
+				c.WriteInt(-2)
+				continue
+			}
+
+			currentTtl, ok := fieldTTLs[field]
+			newTTL := time.Duration(opts.ttl) * time.Second
+
+			// NX -- For each specified field,
+			// set expiration only when the field has no expiration.
+			if opts.nx && ok {
+				c.WriteInt(0)
+				continue
+			}
+
+			// XX -- For each specified field,
+			// set expiration only when the field has an existing expiration.
+			if opts.xx && !ok {
+				c.WriteInt(0)
+				continue
+			}
+
+			// GT -- For each specified field,
+			// set expiration only when the new expiration is greater than current one.
+			if opts.gt && (!ok || newTTL <= currentTtl) {
+				c.WriteInt(0)
+				continue
+			}
+
+			// LT -- For each specified field,
+			// set expiration only when the new expiration is less than current one.
+			if opts.lt && ok && newTTL >= currentTtl {
+				c.WriteInt(0)
+				continue
+			}
+
+			fieldTTLs[field] = newTTL
+			c.WriteInt(1)
+		}
+	})
+}
+
+type hexpireOpts struct {
+	key    string
+	ttl    int
+	nx     bool
+	xx     bool
+	gt     bool
+	lt     bool
+	fields []string
+}
+
+func parseHExpireArgs(args []string) (hexpireOpts, string) {
+	var opts hexpireOpts
+	opts.key = args[0]
+
+	if err := optIntSimple(args[1], &opts.ttl); err != nil {
+		return hexpireOpts{}, err.Error()
+	}
+
+	args = args[2:]
+
+	for len(args) > 0 {
+		switch strings.ToLower(args[0]) {
+		case "nx":
+			opts.nx = true
+			args = args[1:]
+		case "xx":
+			opts.xx = true
+			args = args[1:]
+		case "gt":
+			opts.gt = true
+			args = args[1:]
+		case "lt":
+			opts.lt = true
+			args = args[1:]
+		case "fields":
+			var numFields int
+			if err := optIntSimple(args[1], &numFields); err != nil {
+				return hexpireOpts{}, msgNumFieldsInvalid
+			}
+			if numFields <= 0 {
+				return hexpireOpts{}, msgNumFieldsInvalid
+			}
+
+			// FIELDS numFields field1 field2 ...
+			if len(args) < 2+numFields {
+				return hexpireOpts{}, msgNumFieldsParameter
+			}
+
+			opts.fields = append([]string{}, args[2:2+numFields]...)
+			args = args[2+numFields:]
+		default:
+			return hexpireOpts{}, fmt.Sprintf(msgMandatoryArgument, "FIELDS")
+		}
+	}
+
+	if opts.gt && opts.lt {
+		return hexpireOpts{}, msgGTandLT
+	}
+
+	if opts.nx && (opts.xx || opts.gt || opts.lt) {
+		return hexpireOpts{}, msgNXandXXGTLT
+	}
+
+	return opts, ""
+}
+
 func abs(n int) int {
 	if n < 0 {
 		return -n