Introduce HSETEX command to the Spring Data Redis framework

Signed-off-by: viktoriya.kutsarova <viktoriya.kutsarova@redis.com>

Author: viktoriya-kutsarova

src/main/java/org/springframework/data/redis/connection/DefaultStringRedisConnection.java

@@ -24,6 +24,7 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.jetbrains.annotations.NotNull;
+import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
 import org.springframework.core.convert.converter.Converter;
@@ -1620,6 +1621,11 @@ public List<String> hGetEx(String key, Expiration expiration, String... fields)
         return convertAndReturn(delegate.hGetEx(serialize(key), expiration, serializeMulti(fields)), byteListToStringList);
     }
 
+    @Override
+    public Boolean hSetEx(@NonNull String key, @NonNull Map<@NonNull String, String> hashes, HashFieldSetOption condition, Expiration expiration) {
+        return convertAndReturn(delegate.hSetEx(serialize(key), serialize(hashes), condition, expiration), Converters.identityConverter());
+    }
+
 	@Override
 	public Long incr(String key) {
 		return incr(serialize(key));
@@ -2603,6 +2609,11 @@ public List<byte[]> hGetEx(@NotNull byte[] key, Expiration expiration, @NotNull
         return convertAndReturn(delegate.hGetEx(key, expiration, fields), Converters.identityConverter());
     }
 
+    @Override
+    public Boolean hSetEx(@NotNull byte[] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+        return convertAndReturn(delegate.hSetEx(key, hashes, condition, expiration), Converters.identityConverter());
+    }
+
 	public @Nullable List<Long> applyExpiration(String key,
 			org.springframework.data.redis.core.types.Expiration expiration,
 			ExpirationOptions options, String... fields) {

src/main/java/org/springframework/data/redis/connection/DefaultedRedisConnection.java

@@ -1608,6 +1608,13 @@ default List<byte[]> hGetEx(byte[] key, Expiration expiration, byte[]... fields)
         return hashCommands().hGetEx(key, expiration, fields);
     }
 
+    /** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+    @Override
+    @Deprecated
+    default Boolean hSetEx(byte[] key, Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+        return hashCommands().hSetEx(key, hashes, condition, expiration);
+    }
+
 	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
 	@Override
 	@Deprecated

src/main/java/org/springframework/data/redis/connection/ReactiveHashCommands.java

@@ -1410,4 +1410,101 @@ default Mono<List<ByteBuffer>> hGetEx(ByteBuffer key, Expiration expiration, Lis
      * @see <a href="https://redis.io/commands/hgetex">Redis Documentation: HGETEX</a>
      */
     Flux<MultiValueResponse<HGetExCommand, ByteBuffer>> hGetEx(Publisher<HGetExCommand> commands);
+
+    /**
+     * {@literal HSETEX} {@link Command}.
+     *
+     * @author Viktoriya Kutsarova
+     * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+     */
+    class HSetExCommand extends KeyCommand {
+
+        private final Map<ByteBuffer, ByteBuffer> fieldValueMap;
+        private final RedisHashCommands.HashFieldSetOption condition;
+        private final Expiration expiration;
+
+        private HSetExCommand(@Nullable ByteBuffer key, Map<ByteBuffer, ByteBuffer> fieldValueMap,
+                              RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+            super(key);
+            this.fieldValueMap = fieldValueMap;
+            this.condition = condition;
+            this.expiration = expiration;
+        }
+
+        /**
+         * Creates a new {@link HSetExCommand} for setting field-value pairs with condition and expiration.
+         *
+         * @param fieldValueMap the field-value pairs to set; must not be {@literal null}.
+         * @param condition the condition for setting fields; must not be {@literal null}.
+         * @param expiration the expiration to apply; must not be {@literal null}.
+         * @return new instance of {@link HSetExCommand}.
+         */
+        public static HSetExCommand setWithConditionAndExpiration(Map<ByteBuffer, ByteBuffer> fieldValueMap,
+                                                                  RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+            return new HSetExCommand(null, fieldValueMap, condition, expiration);
+        }
+
+        /**
+         * Applies the hash {@literal key}. Constructs a new command instance with all previously configured properties.
+         *
+         * @param key must not be {@literal null}.
+         * @return a new {@link HSetExCommand} with {@literal key} applied.
+         */
+        public HSetExCommand from(ByteBuffer key) {
+            Assert.notNull(key, "Key must not be null");
+            return new HSetExCommand(key, fieldValueMap, condition, expiration);
+        }
+
+        /**
+         * @return the field-value map.
+         */
+        public Map<ByteBuffer, ByteBuffer> getFieldValueMap() {
+            return fieldValueMap;
+        }
+
+        /**
+         * @return the condition for setting fields.
+         */
+        public RedisHashCommands.HashFieldSetOption getCondition() {
+            return condition;
+        }
+
+        /**
+         * @return the expiration to apply.
+         */
+        public Expiration getExpiration() {
+            return expiration;
+        }
+    }
+
+    /**
+     * Set field-value pairs in hash at {@literal key} with condition and expiration.
+     *
+     * @param key must not be {@literal null}.
+     * @param fieldValueMap the field-value pairs to set; must not be {@literal null}.
+     * @param condition the condition for setting fields; must not be {@literal null}.
+     * @param expiration the expiration to apply; must not be {@literal null}.
+     * @return never {@literal null}.
+     * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+     */
+    default Mono<Boolean> hSetEx(ByteBuffer key, Map<ByteBuffer, ByteBuffer> fieldValueMap,
+                                 RedisHashCommands.HashFieldSetOption condition, Expiration expiration) {
+
+        Assert.notNull(key, "Key must not be null");
+        Assert.notNull(fieldValueMap, "Field-value map must not be null");
+        Assert.notNull(condition, "Condition must not be null");
+        Assert.notNull(expiration, "Expiration must not be null");
+
+        return hSetEx(Mono.just(HSetExCommand.setWithConditionAndExpiration(fieldValueMap, condition, expiration).from(key)))
+                .next().map(CommandResponse::getOutput);
+    }
+
+    /**
+     * Set field-value pairs in hash at {@literal key} with condition and expiration.
+     *
+     * @param commands must not be {@literal null}.
+     * @return never {@literal null}.
+     * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+     */
+    Flux<BooleanResponse<HSetExCommand>> hSetEx(Publisher<HSetExCommand> commands);
 }

src/main/java/org/springframework/data/redis/connection/RedisHashCommands.java

@@ -568,4 +568,60 @@ default List<Long> hExpireAt(byte @NonNull [] key, long unixTime, byte @NonNull
     List<byte[]> hGetEx(byte @NonNull [] key, Expiration expiration,
                                 byte @NonNull [] @NonNull... fields);
 
+    /**
+     * Set field-value pairs in hash at {@literal key} with optional condition and expiration.
+     *
+     * @param key must not be {@literal null}.
+     * @param hashes the field-value pairs to set; must not be {@literal null}.
+     * @param hashFieldSetOption the optional condition for setting fields.
+     * @param expiration the optional expiration to apply.
+     * @return never {@literal null}.
+     * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+     */
+    Boolean hSetEx(byte @NonNull [] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption hashFieldSetOption,
+                   Expiration expiration);
+
+    /**
+     * {@code HSETEX} command arguments for {@code FNX}, {@code FXX}.
+     *
+     * @author Viktoriya Kutsarova
+     */
+    enum HashFieldSetOption {
+
+        /**
+         * Do not set any additional command argument.
+         */
+        UPSERT,
+
+        /**
+         * {@code FNX}
+         */
+        IF_NONE_EXIST,
+
+        /**
+         * {@code FXX}
+         */
+        IF_ALL_EXIST;
+
+        /**
+         * Do not set any additional command argument.
+         */
+        public static HashFieldSetOption upsert() {
+            return UPSERT;
+        }
+
+        /**
+         * {@code FNX}
+         */
+        public static HashFieldSetOption ifNoneExist() {
+            return IF_NONE_EXIST;
+        }
+
+        /**
+         * {@code FXX}
+         */
+        public static HashFieldSetOption ifAllExist() {
+            return IF_ALL_EXIST;
+        }
+    }
 }

src/main/java/org/springframework/data/redis/connection/StringRedisConnection.java

@@ -2576,6 +2576,20 @@ List<Long> hpExpireAt(@NonNull String key, long unixTimeInMillis, ExpirationOpti
      */
     List<String> hGetEx(@NonNull String key, Expiration expiration, @NonNull String @NonNull... fields);
 
+    /**
+     * Set field-value pairs in hash at {@literal key} with optional condition and expiration.
+     *
+     * @param key must not be {@literal null}.
+     * @param hashes the field-value pairs to set; must not be {@literal null}.
+     * @param condition the optional condition for setting fields.
+     * @param expiration the optional expiration to apply.
+     * @return never {@literal null}.
+     * @see <a href="https://redis.io/commands/hsetex">Redis Documentation: HSETEX</a>
+     * @see RedisHashCommands#hSetEx(byte[], Map, HashFieldSetOption, Expiration)
+     */
+    Boolean hSetEx(@NonNull String key, @NonNull Map<@NonNull String, String> hashes, HashFieldSetOption condition,
+                   Expiration expiration);
+
 	// -------------------------------------------------------------------------
 	// Methods dealing with HyperLogLog
 	// -------------------------------------------------------------------------

src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterHashCommands.java

@@ -441,6 +441,19 @@ public List<byte[]> hGetEx(byte[] key, Expiration expiration, byte[]... fields)
         }
     }
 
+    @Override
+    public Boolean hSetEx(byte[] key, Map<byte[], byte[]> hashes, HashFieldSetOption condition, Expiration expiration) {
+
+        Assert.notNull(key, "Key must not be null");
+        Assert.notNull(hashes, "Fields must not be null");
+
+        try {
+            return JedisConverters.toBoolean(connection.getCluster().hsetex(key, JedisConverters.toHSetExParams(condition, expiration), hashes));
+        } catch (Exception ex) {
+            throw convertJedisAccessException(ex);
+        }
+    }
+
 	@Nullable
 	@Override
 	public Long hStrLen(byte[] key, byte[] field) {

src/main/java/org/springframework/data/redis/connection/jedis/JedisConverters.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.redis.connection.jedis;
 
+import org.springframework.data.redis.connection.*;
 import redis.clients.jedis.GeoCoordinate;
 import redis.clients.jedis.HostAndPort;
 import redis.clients.jedis.Protocol;
@@ -47,26 +48,19 @@
 import org.springframework.data.geo.Metric;
 import org.springframework.data.geo.Metrics;
 import org.springframework.data.geo.Point;
-import org.springframework.data.redis.connection.BitFieldSubCommands;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldIncrBy;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldSet;
 import org.springframework.data.redis.connection.BitFieldSubCommands.BitFieldSubCommand;
-import org.springframework.data.redis.connection.RedisGeoCommands;
 import org.springframework.data.redis.connection.RedisGeoCommands.DistanceUnit;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs;
 import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs.Flag;
 import org.springframework.data.redis.connection.RedisListCommands.Position;
-import org.springframework.data.redis.connection.RedisNode;
-import org.springframework.data.redis.connection.RedisServer;
-import org.springframework.data.redis.connection.RedisServerCommands;
 import org.springframework.data.redis.connection.RedisStringCommands.BitOperation;
 import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
 import org.springframework.data.redis.connection.RedisZSetCommands.ZAddArgs;
-import org.springframework.data.redis.connection.SortParameters;
 import org.springframework.data.redis.connection.SortParameters.Order;
 import org.springframework.data.redis.connection.SortParameters.Range;
-import org.springframework.data.redis.connection.ValueEncoding;
 import org.springframework.data.redis.connection.convert.Converters;
 import org.springframework.data.redis.connection.convert.ListConverter;
 import org.springframework.data.redis.connection.convert.StringToRedisClientInfoConverter;
@@ -392,6 +386,67 @@ static GetExParams toGetExParams(Expiration expiration, GetExParams params) {
 				: params.ex(expiration.getConverted(TimeUnit.SECONDS));
 	}
 
+	/**
+	 * Converts a given {@link RedisHashCommands.HashFieldSetOption} and {@link Expiration} to the according
+	 * {@code HSETEX} command argument.
+	 * <dl>
+	 * <dt>{@link RedisHashCommands.HashFieldSetOption#ifNoneExist()}</dt>
+	 * <dd>{@code FNX}</dd>
+	 * <dt>{@link RedisHashCommands.HashFieldSetOption#ifAllExist()}</dt>
+	 * <dd>{@code FXX}</dd>
+	 * <dt>{@link RedisHashCommands.HashFieldSetOption#upsert()}</dt>
+	 * <dd>no condition flag</dd>
+	 * </dl>
+	 * <dl>
+	 * <dt>{@link TimeUnit#MILLISECONDS}</dt>
+	 * <dd>{@code PX|PXAT}</dd>
+	 * <dt>{@link TimeUnit#SECONDS}</dt>
+	 * <dd>{@code EX|EXAT}</dd>
+	 * </dl>
+	 *
+	 * @param condition can be {@literal null}.
+	 * @param expiration can be {@literal null}.
+	 * @since 4.0
+	 */
+	static HSetExParams toHSetExParams(RedisHashCommands.@Nullable HashFieldSetOption condition, @Nullable Expiration expiration) {
+		return toHSetExParams(condition, expiration, new HSetExParams());
+	}
+
+	static HSetExParams toHSetExParams(RedisHashCommands.@Nullable HashFieldSetOption condition, @Nullable Expiration expiration, HSetExParams params) {
+
+		if (condition == null && expiration == null) {
+			return params;
+		}
+
+		if (condition != null) {
+			if (condition.equals(RedisHashCommands.HashFieldSetOption.ifNoneExist())) {
+				params.fnx();
+			} else if (condition.equals(RedisHashCommands.HashFieldSetOption.ifAllExist())) {
+				params.fxx();
+			}
+		}
+
+		if (expiration == null) {
+			return params;
+		}
+
+		if (expiration.isKeepTtl()) {
+			return params.keepTtl();
+		}
+
+		if (expiration.isPersistent()) {
+			return params;
+		}
+
+		if (expiration.getTimeUnit() == TimeUnit.MILLISECONDS) {
+			return expiration.isUnixTimestamp() ? params.pxAt(expiration.getExpirationTime())
+					: params.px(expiration.getExpirationTime());
+		}
+
+		return expiration.isUnixTimestamp() ? params.exAt(expiration.getConverted(TimeUnit.SECONDS))
+				: params.ex(expiration.getConverted(TimeUnit.SECONDS));
+	}
+
     /**
      * Converts a given {@link Expiration} to the according {@code HGETEX} command argument depending on
      * {@link Expiration#isUnixTimestamp()}.
@@ -411,6 +466,10 @@ static HGetExParams toHGetExParams(Expiration expiration) {
 
     static HGetExParams toHGetExParams(Expiration expiration, HGetExParams params) {
 
+        if (expiration == null) {
+            return params;
+        }
+
         if (expiration.isPersistent()) {
             return params.persist();
         }

src/main/java/org/springframework/data/redis/connection/jedis/JedisHashCommands.java

@@ -351,6 +351,18 @@ public List<byte[]> hGetEx(byte @NonNull [] key, Expiration expiration, byte @No
         return connection.invoke().just(Jedis::hgetex, PipelineBinaryCommands::hgetex, key, JedisConverters.toHGetExParams(expiration), fields);
     }
 
+    @Override
+    public Boolean hSetEx(byte @NonNull [] key, @NonNull Map<byte[], byte[]> hashes, HashFieldSetOption condition,
+                          Expiration expiration) {
+
+        Assert.notNull(key, "Key must not be null");
+        Assert.notNull(hashes, "Hashes must not be null");
+
+        return connection.invoke().from(Jedis::hsetex, PipelineBinaryCommands::hsetex, key,
+                JedisConverters.toHSetExParams(condition, expiration), hashes)
+                .get(Converters::toBoolean);
+    }
+
 	@Nullable
 	@Override
 	public Long hStrLen(byte[] key, byte[] field) {