From 35a825ce4fa7521b83ff6fc21c0a8c1c53fd8940 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Thu, 15 Aug 2024 12:34:28 -0400 Subject: [PATCH 1/8] initial algebra --- .../profunktor/redis4cats/algebra/json.scala | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala new file mode 100644 index 00000000..8551c410 --- /dev/null +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -0,0 +1,62 @@ +/* + * Copyright 2018-2021 ProfunKtor + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package dev.profunktor.redis4cats.algebra + +trait JsonPath +trait JsonValue[K,V] + +trait Json[F[_],K,V] extends JsonArray[F,K,V] with JsonGet[F,K,V] with JsonSet[F,K,V] with JsonNumber[F,K,V] with JsonString[F,K,V] with JsonBoolean[F,K,V] { + def clear(key: K,path: JsonPath): F[Long] + def del(key: K,path: JsonPath): F[Long] + def jsonType(key: K,path: JsonPath): F[V] + def jsonToggle(key: K,path: JsonPath): F[Long] + def get(key: K,path: JsonPath): F[JsonValue[K,V]] + +} +trait JsonGet[F[_],K,V] { + def get(key: K,path: JsonPath): F[JsonValue[K,V]] + def objKeys(key: K,path: JsonPath): F[List[K]] + def objLen(key: K,path: JsonPath): F[Long] + def mget(key: K,paths: JsonPath*): F[List[JsonValue[K,V]]] +} +trait JsonSet[F[_],K,V] { + def mset(key: K,values: (JsonPath,JsonValue[K,V])*): F[Unit] + def set(key: K,path: JsonPath,value: JsonValue[K,V]): F[Unit] + def setnx(key: K,path: JsonPath,value: JsonValue[K,V]): F[Boolean] + def setxx(key: K,path: JsonPath,value: JsonValue[K,V]): F[Boolean] + def jsonMerge(key:K, jsonPath: JsonPath, value: JsonValue[K,V]): F[Boolean]; +} +trait JsonNumber[F[_],K,V] { + def numIncrBy(key: K,path: JsonPath,number: Number): F[List[Number]] +} +trait JsonString[F[_],K,V] { + def strAppend(key: K,path: JsonPath,value: JsonValue[K,V]): F[Long] + def strLen(key: K,path: JsonPath): F[Long] +} +trait JsonBoolean[F[_],K,V] { + def toggle(key: K,path: JsonPath): F[Boolean] +} + +trait JsonArray[F[_],K,V] { + def arrAppend(key: K,path: JsonPath,value: JsonValue[K,V]*): F[Unit] + def arrIndex(key: K,path: JsonPath,value: JsonValue[K,V],range: JsonRangeArgs): F[List[Long]] + def arrInsert(key: K,path: JsonPath,index: Int,value: JsonValue[K,V]*): F[List[Long]] + def arrLen(key: K,path: JsonPath): F[List[Long]] + def arrPop(key: K,path: JsonPath,index: Int): F[List[JsonValue[K,V]]] + def arrTrim(key: K,path: JsonPath,range: JsonRangeArgs): F[List[Long]] + +} From a2094f9e3a6d56dd61b1b917a498382bc5ccd481 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Thu, 15 Aug 2024 13:08:14 -0400 Subject: [PATCH 2/8] initial algebra --- .../main/scala/dev/profunktor/redis4cats/algebra/json.scala | 3 --- 1 file changed, 3 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala index 8551c410..6c4d5dcf 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -23,9 +23,6 @@ trait Json[F[_],K,V] extends JsonArray[F,K,V] with JsonGet[F,K,V] with JsonSet[F def clear(key: K,path: JsonPath): F[Long] def del(key: K,path: JsonPath): F[Long] def jsonType(key: K,path: JsonPath): F[V] - def jsonToggle(key: K,path: JsonPath): F[Long] - def get(key: K,path: JsonPath): F[JsonValue[K,V]] - } trait JsonGet[F[_],K,V] { def get(key: K,path: JsonPath): F[JsonValue[K,V]] From d9bcbdf80c2af90db99a23b99d230140ec340c85 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Tue, 3 Dec 2024 14:14:27 -0500 Subject: [PATCH 3/8] additional fuinctions --- .../profunktor/redis4cats/algebra/json.scala | 70 ++++++++++-------- .../dev/profunktor/redis4cats/commands.scala | 1 + .../dev/profunktor/redis4cats/redis.scala | 73 +++++++++++++++++++ 3 files changed, 113 insertions(+), 31 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala index 6c4d5dcf..c0772e14 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -16,44 +16,52 @@ package dev.profunktor.redis4cats.algebra -trait JsonPath -trait JsonValue[K,V] +import io.lettuce.core.json.arguments.JsonRangeArgs +import io.lettuce.core.json.{ JsonPath, JsonType, JsonValue } -trait Json[F[_],K,V] extends JsonArray[F,K,V] with JsonGet[F,K,V] with JsonSet[F,K,V] with JsonNumber[F,K,V] with JsonString[F,K,V] with JsonBoolean[F,K,V] { - def clear(key: K,path: JsonPath): F[Long] - def del(key: K,path: JsonPath): F[Long] - def jsonType(key: K,path: JsonPath): F[V] +trait JsonCommands[F[_], K, V] + extends JsonArray[F, K, V] + with JsonGet[F, K, V] + with JsonSet[F, K, V] + with JsonNumber[F, K, V] + with JsonString[F, K, V] + with JsonBoolean[F, K, V] { + def clear(key: K, path: JsonPath): F[Long] + // def debug(key: K, path: JsonPath): F[String] + def del(key: K, path: JsonPath): F[Long] +// def forget(key: K, path: JsonPath): F[Long] + def jsonType(key: K, path: JsonPath): F[List[JsonType]] } -trait JsonGet[F[_],K,V] { - def get(key: K,path: JsonPath): F[JsonValue[K,V]] - def objKeys(key: K,path: JsonPath): F[List[K]] - def objLen(key: K,path: JsonPath): F[Long] - def mget(key: K,paths: JsonPath*): F[List[JsonValue[K,V]]] +trait JsonGet[F[_], K, V] { + def get(key: K, path: JsonPath): F[List[JsonValue]] + def mget(key: K, paths: JsonPath*): F[List[JsonValue]] + def objKeys(key: K, path: JsonPath): F[List[K]] + def objLen(key: K, path: JsonPath): F[Long] } -trait JsonSet[F[_],K,V] { - def mset(key: K,values: (JsonPath,JsonValue[K,V])*): F[Unit] - def set(key: K,path: JsonPath,value: JsonValue[K,V]): F[Unit] - def setnx(key: K,path: JsonPath,value: JsonValue[K,V]): F[Boolean] - def setxx(key: K,path: JsonPath,value: JsonValue[K,V]): F[Boolean] - def jsonMerge(key:K, jsonPath: JsonPath, value: JsonValue[K,V]): F[Boolean]; +trait JsonSet[F[_], K, V] { + def mset(key: K, values: (JsonPath, JsonValue)*): F[Unit] + def set(key: K, path: JsonPath, value: JsonValue): F[Unit] + def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] + def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] + def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[Boolean]; } -trait JsonNumber[F[_],K,V] { - def numIncrBy(key: K,path: JsonPath,number: Number): F[List[Number]] +trait JsonNumber[F[_], K, V] { + def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] } -trait JsonString[F[_],K,V] { - def strAppend(key: K,path: JsonPath,value: JsonValue[K,V]): F[Long] - def strLen(key: K,path: JsonPath): F[Long] +trait JsonString[F[_], K, V] { + def strAppend(key: K, path: JsonPath, value: JsonValue): F[Long] + def strLen(key: K, path: JsonPath): F[Long] } -trait JsonBoolean[F[_],K,V] { - def toggle(key: K,path: JsonPath): F[Boolean] +trait JsonBoolean[F[_], K, V] { + def toggle(key: K, path: JsonPath): F[Boolean] } -trait JsonArray[F[_],K,V] { - def arrAppend(key: K,path: JsonPath,value: JsonValue[K,V]*): F[Unit] - def arrIndex(key: K,path: JsonPath,value: JsonValue[K,V],range: JsonRangeArgs): F[List[Long]] - def arrInsert(key: K,path: JsonPath,index: Int,value: JsonValue[K,V]*): F[List[Long]] - def arrLen(key: K,path: JsonPath): F[List[Long]] - def arrPop(key: K,path: JsonPath,index: Int): F[List[JsonValue[K,V]]] - def arrTrim(key: K,path: JsonPath,range: JsonRangeArgs): F[List[Long]] +trait JsonArray[F[_], K, V] { + def arrAppend(key: K, path: JsonPath, value: JsonValue*): F[Unit] + def arrIndex(key: K, path: JsonPath, value: JsonValue, range: JsonRangeArgs): F[List[Long]] + def arrInsert(key: K, path: JsonPath, index: Int, value: JsonValue*): F[List[Long]] + def arrLen(key: K, path: JsonPath): F[List[Long]] + def arrPop(key: K, path: JsonPath, index: Int): F[List[JsonValue]] + def arrTrim(key: K, path: JsonPath, range: JsonRangeArgs): F[List[Long]] } diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/commands.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/commands.scala index 9e8c3826..2b6446ba 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/commands.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/commands.scala @@ -22,6 +22,7 @@ import dev.profunktor.redis4cats.effect.Log trait RedisCommands[F[_], K, V] extends StringCommands[F, K, V] + with JsonCommands[F, K, V] with HashCommands[F, K, V] with SetCommands[F, K, V] with SortedSetCommands[F, K, V] diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index ccbc89ea..d12b10fd 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -34,10 +34,13 @@ import io.lettuce.core.XReadArgs.StreamOffset import io.lettuce.core.api.async.RedisAsyncCommands import io.lettuce.core.cluster.api.async.RedisClusterAsyncCommands import io.lettuce.core.cluster.api.sync.{ RedisClusterCommands => RedisClusterSyncCommands } +import io.lettuce.core.json.arguments.{ JsonMsetArgs, JsonRangeArgs, JsonSetArgs } +import io.lettuce.core.json.{ JsonPath, JsonType, JsonValue } import io.lettuce.core.{ BitFieldArgs, ClientOptions, CopyArgs => JCopyArgs, + CopyArgs => JCopyArgs, ExpireArgs => JExpireArgs, FlushMode => JFlushMode, FunctionRestoreMode => JFunctionRestoreMode, @@ -65,6 +68,7 @@ import org.typelevel.keypool.KeyPool import java.time.Instant import java.util +import java.util import java.util.concurrent.TimeUnit import scala.concurrent.duration._ @@ -759,6 +763,75 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def mSetNx(keyValues: Map[K, V]): F[Boolean] = async.flatMap(_.msetnx(keyValues.asJava).futureLift.map(x => Boolean.box(x))) + /** ***************************** JSON API ********************************* */ + override def jsonType(key: K, path: JsonPath): F[List[JsonType]] = + async.flatMap(_.jsonType(key, path).futureLift.map(_.asScala.toList)) + + override def get(key: K, path: JsonPath): F[List[JsonValue]] = + async.flatMap(_.jsonGet(key, path).futureLift.map(_.asScala.toList)) + + override def clear(key: K, path: JsonPath): F[Long] = + async.flatMap(_.jsonClear(key, path).futureLift.map(x => Long.box(x))) + + override def del(key: K, path: JsonPath): F[Long] = + async.flatMap(_.jsonDel(key, path).futureLift.map(x => Long.box(x))) + + override def arrAppend(key: K, path: JsonPath, value: JsonValue*): F[Unit] = + async.flatMap(_.jsonArrappend(key, path, value: _*).futureLift.void) + + override def arrIndex(key: K, path: JsonPath, value: JsonValue, range: JsonRangeArgs): F[List[Long]] = + async.flatMap(_.jsonArrindex(key, path, value, range).futureLift.map(_.asScala.toList.map(Long.box(_)))) + + override def arrInsert(key: K, path: JsonPath, index: Int, value: JsonValue*): F[List[Long]] = + async.flatMap(_.jsonArrinsert(key, path, index, value: _*).futureLift.map(_.asScala.toList.map(Long.box(_)))) + + override def arrLen(key: K, path: JsonPath): F[List[Long]] = + async.flatMap(_.jsonArrlen(key, path).futureLift.map(_.asScala.toList.map(Long.box(_)))) + + override def arrPop(key: K, path: JsonPath, index: Int): F[List[JsonValue]] = + async.flatMap(_.jsonArrpop(key, path, index).futureLift.map(_.asScala.toList)) + + override def arrTrim(key: K, path: JsonPath, range: JsonRangeArgs): F[List[Long]] = + async.flatMap(_.jsonArrtrim(key, path, range).futureLift.map(_.asScala.toList.map(Long.box(_)))) + + override def toggle(key: K, path: JsonPath): F[Boolean] = + async.flatMap(_.jsonToggle(key, path).futureLift.map(x => Boolean.box(x))) + + override def mget(key: K, paths: JsonPath*): F[List[JsonValue]] = + async.flatMap(_.jsonMGet(key, paths: _*).futureLift.map(_.asScala.toList)) + + override def objKeys(key: K, path: JsonPath): F[List[K]] = + async.flatMap(_.jsonObjkeys(key, path).futureLift.map(_.asScala.toList)) + + override def objLen(key: K, path: JsonPath): F[Long] = + async.flatMap(_.jsonObjlen(key, path).futureLift.map(x => Long.unbox(x))) + + override def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] = + async.flatMap(_.jsonNumincrby(key, path, number).futureLift.map(_.asScala.toList)) + + override def mset(key: K, values: (JsonPath, JsonValue)*): F[Unit] = { + val jValues = values.map { case (path, value) => new JsonMsetArgs(key, path, value) }.asJava + async.flatMap(_.jsonMSet(jValues).futureLift.void) + } + + override def set(key: K, path: JsonPath, value: JsonValue): F[Unit] = + async.flatMap(_.jsonSet(key, path, value).futureLift.void) + + override def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().nx()).futureLift.map(x => x == "OK")) + + override def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().xx()).futureLift.map(x => x == "OK")) + + override def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[Boolean] = + async.flatMap(_.jsonMerge(key, jsonPath, value).futureLift.map(x => Boolean.box(x))) + + override def strAppend(key: K, path: JsonPath, value: JsonValue): F[Long] = + async.flatMap(_.jsonStrappend(key, path, value).futureLift.map(x => Long.box(x))) + + override def strLen(key: K, path: JsonPath): F[Long] = + async.flatMap(_.jsonStrlen(key, path).futureLift.map(x => Long.unbox(x))) + // format: off /******************************* Hashes API **********************************/ // format: on From 54f50baa79f53787ea115760e9d5868ca9b2a950 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Mon, 23 Dec 2024 12:38:56 -0500 Subject: [PATCH 4/8] doc --- .../effects/src/main/scala/dev/profunktor/redis4cats/redis.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index d12b10fd..0d999c21 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -776,6 +776,7 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def del(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonDel(key, path).futureLift.map(x => Long.box(x))) + /*** JSON ARRAY ***/ override def arrAppend(key: K, path: JsonPath, value: JsonValue*): F[Unit] = async.flatMap(_.jsonArrappend(key, path, value: _*).futureLift.void) From ccd4fdcad203bc7643079311c697e9c0eb8f8e7a Mon Sep 17 00:00:00 2001 From: YisraelU Date: Mon, 23 Dec 2024 16:15:19 -0500 Subject: [PATCH 5/8] compiles --- .../profunktor/redis4cats/algebra/json.scala | 54 +++++++++--- .../dev/profunktor/redis4cats/redis.scala | 88 ++++++++++++------- 2 files changed, 100 insertions(+), 42 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala index c0772e14..410fdd72 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -16,7 +16,8 @@ package dev.profunktor.redis4cats.algebra -import io.lettuce.core.json.arguments.JsonRangeArgs +import dev.profunktor.redis4cats.algebra.json.JsonGetArgs +import io.lettuce.core.json.arguments.{ JsonRangeArgs, JsonGetArgs => LJsonGetArgs } import io.lettuce.core.json.{ JsonPath, JsonType, JsonValue } trait JsonCommands[F[_], K, V] @@ -26,34 +27,47 @@ trait JsonCommands[F[_], K, V] with JsonNumber[F, K, V] with JsonString[F, K, V] with JsonBoolean[F, K, V] { + + /** + * Clear container values (arrays/objects) and set numeric values to 0 + * @return Long the number of values removed plus all the matching JSON numerical values that are zeroed. + */ def clear(key: K, path: JsonPath): F[Long] - // def debug(key: K, path: JsonPath): F[String] + def clear(key: K): F[Long] + + /** + * Deletes a value inside the JSON document at a given JsonPath + * @return Long the number of values removed (0 or more). + */ def del(key: K, path: JsonPath): F[Long] -// def forget(key: K, path: JsonPath): F[Long] + def del(key: K): F[Long] + def jsonType(key: K, path: JsonPath): F[List[JsonType]] + def jsonType(key: K): F[List[JsonType]] } trait JsonGet[F[_], K, V] { - def get(key: K, path: JsonPath): F[List[JsonValue]] - def mget(key: K, paths: JsonPath*): F[List[JsonValue]] - def objKeys(key: K, path: JsonPath): F[List[K]] + def get(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] + def get(key: K, arg: JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] + def mget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] + def objKeys(key: K, path: JsonPath): F[List[V]] def objLen(key: K, path: JsonPath): F[Long] } trait JsonSet[F[_], K, V] { - def mset(key: K, values: (JsonPath, JsonValue)*): F[Unit] - def set(key: K, path: JsonPath, value: JsonValue): F[Unit] + def mset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] + def set(key: K, path: JsonPath, value: JsonValue): F[Boolean] def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] - def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[Boolean]; + def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[String]; } trait JsonNumber[F[_], K, V] { def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] } trait JsonString[F[_], K, V] { - def strAppend(key: K, path: JsonPath, value: JsonValue): F[Long] + def strAppend(key: K, path: JsonPath, value: JsonValue): F[List[Long]] def strLen(key: K, path: JsonPath): F[Long] } trait JsonBoolean[F[_], K, V] { - def toggle(key: K, path: JsonPath): F[Boolean] + def toggle(key: K, path: JsonPath): F[List[Long]] } trait JsonArray[F[_], K, V] { @@ -65,3 +79,21 @@ trait JsonArray[F[_], K, V] { def arrTrim(key: K, path: JsonPath, range: JsonRangeArgs): F[List[Long]] } + +object json { + final case class JsonGetArgs( + indent: Option[String], + newline: Option[String], + space: Option[String] + ) { + def underlying: LJsonGetArgs = { + val args = new LJsonGetArgs() + indent.foreach(args.indent) + newline.foreach(args.newline) + space.foreach(args.space) + args + } + } + + object JsonGetArgs +} diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index 0d999c21..c517314d 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -20,7 +20,7 @@ import cats._ import cats.data.NonEmptyList import cats.effect.kernel._ import cats.syntax.all._ -import dev.profunktor.redis4cats.algebra.BitCommandOperation +import dev.profunktor.redis4cats.algebra.{ json, BitCommandOperation } import dev.profunktor.redis4cats.algebra.BitCommandOperation.Overflows import dev.profunktor.redis4cats.config.Redis4CatsConfig import dev.profunktor.redis4cats.connection._ @@ -697,7 +697,7 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( case SetArg.Ttl.Keep => jSetArgs.keepttl() } - async.flatMap(_.set(key, value, jSetArgs).futureLift.map(_ == "OK")) + async.flatMap(_.set(key, value, jSetArgs).futureLift.map(_.isSuccess)) } override def setNx(key: K, value: V): F[Boolean] = @@ -767,15 +767,42 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def jsonType(key: K, path: JsonPath): F[List[JsonType]] = async.flatMap(_.jsonType(key, path).futureLift.map(_.asScala.toList)) - override def get(key: K, path: JsonPath): F[List[JsonValue]] = - async.flatMap(_.jsonGet(key, path).futureLift.map(_.asScala.toList)) + override def jsonType(key: K): F[List[JsonType]] = async.flatMap(_.jsonType(key).futureLift.map(_.asScala.toList)) override def clear(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonClear(key, path).futureLift.map(x => Long.box(x))) + override def clear(key: K): F[Long] = + async.flatMap(_.jsonClear(key).futureLift.map(x => Long.box(x))) + override def del(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonDel(key, path).futureLift.map(x => Long.box(x))) + override def del(key: K): F[Long] = async.flatMap(_.jsonDel(key).futureLift.map(x => Long.box(x))) + + /*** JSON GETTERS ***/ + override def get(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { + val all = path +: paths + async.flatMap(_.jsonGet(key, all: _*).futureLift.map(_.asScala.toList)) + } + + override def get(key: K, arg: json.JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { + val all = path +: paths + val options = arg.underlying + async.flatMap(_.jsonGet(key, options, all: _*).futureLift.map(_.asScala.toList)) + } + + override def mget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] = { + val all = key +: keys + async.flatMap(_.jsonMGet(path, all: _*).futureLift.map(_.asScala.toList)) + } + + override def objKeys(key: K, path: JsonPath): F[List[V]] = + async.flatMap(_.jsonObjkeys(key, path).futureLift.map(_.asScala.toList)) + + override def objLen(key: K, path: JsonPath): F[Long] = + async.flatMap(_.jsonObjlen(key, path).futureLift.map(x => Long.unbox(x))) + /*** JSON ARRAY ***/ override def arrAppend(key: K, path: JsonPath, value: JsonValue*): F[Unit] = async.flatMap(_.jsonArrappend(key, path, value: _*).futureLift.void) @@ -795,40 +822,35 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def arrTrim(key: K, path: JsonPath, range: JsonRangeArgs): F[List[Long]] = async.flatMap(_.jsonArrtrim(key, path, range).futureLift.map(_.asScala.toList.map(Long.box(_)))) - override def toggle(key: K, path: JsonPath): F[Boolean] = - async.flatMap(_.jsonToggle(key, path).futureLift.map(x => Boolean.box(x))) - - override def mget(key: K, paths: JsonPath*): F[List[JsonValue]] = - async.flatMap(_.jsonMGet(key, paths: _*).futureLift.map(_.asScala.toList)) - - override def objKeys(key: K, path: JsonPath): F[List[K]] = - async.flatMap(_.jsonObjkeys(key, path).futureLift.map(_.asScala.toList)) - - override def objLen(key: K, path: JsonPath): F[Long] = - async.flatMap(_.jsonObjlen(key, path).futureLift.map(x => Long.unbox(x))) + override def toggle(key: K, path: JsonPath): F[List[Long]] = + async.flatMap(_.jsonToggle(key, path).futureLift.map(_.asScala.toList.map(Long.box(_)))) override def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] = async.flatMap(_.jsonNumincrby(key, path, number).futureLift.map(_.asScala.toList)) - override def mset(key: K, values: (JsonPath, JsonValue)*): F[Unit] = { - val jValues = values.map { case (path, value) => new JsonMsetArgs(key, path, value) }.asJava - async.flatMap(_.jsonMSet(jValues).futureLift.void) + override def mset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] = { + val jValues: util.List[JsonMsetArgs[K, V]] = + values + .map { case (path, value) => new JsonMsetArgs(key, path, value) } + .asJava + .asInstanceOf[util.List[JsonMsetArgs[K, V]]] + async.flatMap(_.jsonMSet(jValues).futureLift.map(_.isSuccess)) } - override def set(key: K, path: JsonPath, value: JsonValue): F[Unit] = - async.flatMap(_.jsonSet(key, path, value).futureLift.void) + override def set(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + async.flatMap(_.jsonSet(key, path, value).futureLift).map(Option(_).exists(_.isSuccess)) override def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = - async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().nx()).futureLift.map(x => x == "OK")) + async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().nx()).futureLift.map(_.isSuccess)) override def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = - async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().xx()).futureLift.map(x => x == "OK")) + async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().xx()).futureLift.map(_.isSuccess)) - override def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[Boolean] = - async.flatMap(_.jsonMerge(key, jsonPath, value).futureLift.map(x => Boolean.box(x))) + override def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[String] = + async.flatMap(_.jsonMerge(key, jsonPath, value).futureLift) - override def strAppend(key: K, path: JsonPath, value: JsonValue): F[Long] = - async.flatMap(_.jsonStrappend(key, path, value).futureLift.map(x => Long.box(x))) + override def strAppend(key: K, path: JsonPath, value: JsonValue): F[List[Long]] = + async.flatMap(_.jsonStrappend(key, path, value).futureLift.map(_.asScala.toList.map(x => Long.box(x)))) override def strLen(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonStrlen(key, path).futureLift.map(x => Long.unbox(x))) @@ -1463,13 +1485,13 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( conn.async.flatMap(_.select(index).futureLift.void) override def auth(password: CharSequence): F[Boolean] = - async.flatMap(_.auth(password).futureLift.map(_ == "OK")) + async.flatMap(_.auth(password).futureLift.map(_.isSuccess)) override def auth(username: String, password: CharSequence): F[Boolean] = - async.flatMap(_.auth(username, password).futureLift.map(_ == "OK")) + async.flatMap(_.auth(username, password).futureLift.map(_.isSuccess)) override def setClientName(name: K): F[Boolean] = - async.flatMap(_.clientSetname(name).futureLift.map(_ == "OK")) + async.flatMap(_.clientSetname(name).futureLift.map(_.isSuccess)) override def getClientName(): F[Option[K]] = async.flatMap(_.clientGetname().futureLift).map(Option.apply) @@ -1478,10 +1500,10 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( async.flatMap(_.clientId().futureLift.map(Long.unbox)) override def setLibName(name: String): F[Boolean] = - async.flatMap(_.clientSetinfo("LIB-NAME", name).futureLift.map(_ == "OK")) + async.flatMap(_.clientSetinfo("LIB-NAME", name).futureLift.map(_.isSuccess)) override def setLibVersion(version: String): F[Boolean] = - async.flatMap(_.clientSetinfo("LIB-VER", version).futureLift.map(_ == "OK")) + async.flatMap(_.clientSetinfo("LIB-VER", version).futureLift.map(_.isSuccess)) override def getClientInfo: F[Map[String, String]] = async.flatMap( @@ -1998,6 +2020,10 @@ private[redis4cats] trait RedisConversionOps { } } + private[redis4cats] implicit class ResponseOps(str: String) { + def isSuccess: Boolean = str == "OK" + } + } private[redis4cats] class Redis[F[_]: FutureLift: MonadThrow: Log, K, V]( From 2048f903fb4536cf1056b5475035e37b0a297a05 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Tue, 21 Jan 2025 22:27:40 -0500 Subject: [PATCH 6/8] fix boxing --- .../main/scala/dev/profunktor/redis4cats/redis.scala | 12 ++++++------ .../profunktor/redis4cats/Redis4CatsFunSuite.scala | 2 ++ 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index c517314d..21ebd62c 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -808,22 +808,22 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( async.flatMap(_.jsonArrappend(key, path, value: _*).futureLift.void) override def arrIndex(key: K, path: JsonPath, value: JsonValue, range: JsonRangeArgs): F[List[Long]] = - async.flatMap(_.jsonArrindex(key, path, value, range).futureLift.map(_.asScala.toList.map(Long.box(_)))) + async.flatMap(_.jsonArrindex(key, path, value, range).futureLift.map(_.asScala.toList.map(Long.unbox(_)))) override def arrInsert(key: K, path: JsonPath, index: Int, value: JsonValue*): F[List[Long]] = - async.flatMap(_.jsonArrinsert(key, path, index, value: _*).futureLift.map(_.asScala.toList.map(Long.box(_)))) + async.flatMap(_.jsonArrinsert(key, path, index, value: _*).futureLift.map(_.asScala.toList.map(Long.unbox(_)))) override def arrLen(key: K, path: JsonPath): F[List[Long]] = - async.flatMap(_.jsonArrlen(key, path).futureLift.map(_.asScala.toList.map(Long.box(_)))) + async.flatMap(_.jsonArrlen(key, path).futureLift.map(_.asScala.toList.map(Long.unbox(_)))) override def arrPop(key: K, path: JsonPath, index: Int): F[List[JsonValue]] = async.flatMap(_.jsonArrpop(key, path, index).futureLift.map(_.asScala.toList)) override def arrTrim(key: K, path: JsonPath, range: JsonRangeArgs): F[List[Long]] = - async.flatMap(_.jsonArrtrim(key, path, range).futureLift.map(_.asScala.toList.map(Long.box(_)))) + async.flatMap(_.jsonArrtrim(key, path, range).futureLift.map(_.asScala.toList.map(Long.unbox(_)))) override def toggle(key: K, path: JsonPath): F[List[Long]] = - async.flatMap(_.jsonToggle(key, path).futureLift.map(_.asScala.toList.map(Long.box(_)))) + async.flatMap(_.jsonToggle(key, path).futureLift.map(_.asScala.toList.map(Long.unbox(_)))) override def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] = async.flatMap(_.jsonNumincrby(key, path, number).futureLift.map(_.asScala.toList)) @@ -850,7 +850,7 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( async.flatMap(_.jsonMerge(key, jsonPath, value).futureLift) override def strAppend(key: K, path: JsonPath, value: JsonValue): F[List[Long]] = - async.flatMap(_.jsonStrappend(key, path, value).futureLift.map(_.asScala.toList.map(x => Long.box(x)))) + async.flatMap(_.jsonStrappend(key, path, value).futureLift.map(_.asScala.toList.map(x => Long.unbox(x)))) override def strLen(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonStrlen(key, path).futureLift.map(x => Long.unbox(x))) diff --git a/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala b/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala index 4a2360b8..d836a151 100644 --- a/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala +++ b/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala @@ -30,6 +30,8 @@ import munit.{ Compare, Location } import scala.concurrent.duration.{ Duration, DurationInt, FiniteDuration } import scala.concurrent.{ Await, Future } +import dev.profunktor.redis4cats.pubsub.{ PubSub, PubSubCommands } +import dev.profunktor.redis4cats.Redis4CatsFunSuite.Fs2PubSub abstract class Redis4CatsFunSuite(isCluster: Boolean) extends IOSuite { From 09c8861f7a115575af8888c5af907e4f28484a3b Mon Sep 17 00:00:00 2001 From: YisraelU Date: Mon, 16 Jun 2025 21:42:34 -0400 Subject: [PATCH 7/8] merge --- .../dev/profunktor/redis4cats/algebra/json.scala | 16 ++++++++-------- .../scala/dev/profunktor/redis4cats/redis.scala | 11 ++++++----- .../redis4cats/Redis4CatsFunSuite.scala | 3 +-- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala index 410fdd72..8cd0501d 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -1,5 +1,5 @@ /* - * Copyright 2018-2021 ProfunKtor + * Copyright 2018-2025 ProfunKtor * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +17,7 @@ package dev.profunktor.redis4cats.algebra import dev.profunktor.redis4cats.algebra.json.JsonGetArgs -import io.lettuce.core.json.arguments.{ JsonRangeArgs, JsonGetArgs => LJsonGetArgs } +import io.lettuce.core.json.arguments.{ JsonGetArgs => LJsonGetArgs, JsonRangeArgs } import io.lettuce.core.json.{ JsonPath, JsonType, JsonValue } trait JsonCommands[F[_], K, V] @@ -28,16 +28,16 @@ trait JsonCommands[F[_], K, V] with JsonString[F, K, V] with JsonBoolean[F, K, V] { - /** - * Clear container values (arrays/objects) and set numeric values to 0 - * @return Long the number of values removed plus all the matching JSON numerical values that are zeroed. + /** Clear container values (arrays/objects) and set numeric values to 0 + * @return + * Long the number of values removed plus all the matching JSON numerical values that are zeroed. */ def clear(key: K, path: JsonPath): F[Long] def clear(key: K): F[Long] - /** - * Deletes a value inside the JSON document at a given JsonPath - * @return Long the number of values removed (0 or more). + /** Deletes a value inside the JSON document at a given JsonPath + * @return + * Long the number of values removed (0 or more). */ def del(key: K, path: JsonPath): F[Long] def del(key: K): F[Long] diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index 21ebd62c..27148a23 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -40,7 +40,6 @@ import io.lettuce.core.{ BitFieldArgs, ClientOptions, CopyArgs => JCopyArgs, - CopyArgs => JCopyArgs, ExpireArgs => JExpireArgs, FlushMode => JFlushMode, FunctionRestoreMode => JFunctionRestoreMode, @@ -68,7 +67,6 @@ import org.typelevel.keypool.KeyPool import java.time.Instant import java.util -import java.util import java.util.concurrent.TimeUnit import scala.concurrent.duration._ @@ -763,7 +761,8 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def mSetNx(keyValues: Map[K, V]): F[Boolean] = async.flatMap(_.msetnx(keyValues.asJava).futureLift.map(x => Boolean.box(x))) - /** ***************************** JSON API ********************************* */ + /** ***************************** JSON API ********************************* + */ override def jsonType(key: K, path: JsonPath): F[List[JsonType]] = async.flatMap(_.jsonType(key, path).futureLift.map(_.asScala.toList)) @@ -780,7 +779,8 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def del(key: K): F[Long] = async.flatMap(_.jsonDel(key).futureLift.map(x => Long.box(x))) - /*** JSON GETTERS ***/ + /** * JSON GETTERS ** + */ override def get(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { val all = path +: paths async.flatMap(_.jsonGet(key, all: _*).futureLift.map(_.asScala.toList)) @@ -803,7 +803,8 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def objLen(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonObjlen(key, path).futureLift.map(x => Long.unbox(x))) - /*** JSON ARRAY ***/ + /** * JSON ARRAY ** + */ override def arrAppend(key: K, path: JsonPath, value: JsonValue*): F[Unit] = async.flatMap(_.jsonArrappend(key, path, value: _*).futureLift.void) diff --git a/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala b/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala index d836a151..49a94d17 100644 --- a/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala +++ b/modules/tests/src/test/scala/dev/profunktor/redis4cats/Redis4CatsFunSuite.scala @@ -18,12 +18,11 @@ package dev.profunktor.redis4cats import cats.effect._ import cats.syntax.all._ -import dev.profunktor.redis4cats.Redis4CatsFunSuite.{ Fs2PubSub, Fs2Streaming } +import dev.profunktor.redis4cats.Redis4CatsFunSuite.Fs2Streaming import dev.profunktor.redis4cats.connection._ import dev.profunktor.redis4cats.data.{ RedisChannel, RedisCodec } import dev.profunktor.redis4cats.effect.Log.NoOp._ import dev.profunktor.redis4cats.pubsub.data.Subscription -import dev.profunktor.redis4cats.pubsub.{ PubSub, PubSubCommands } import dev.profunktor.redis4cats.streams.{ RedisStream, Streaming } import io.lettuce.core.{ ClientOptions, TimeoutOptions } import munit.{ Compare, Location } From ff97b6395b08a1591388448c0e87dc334ef134c9 Mon Sep 17 00:00:00 2001 From: YisraelU Date: Mon, 16 Jun 2025 22:02:06 -0400 Subject: [PATCH 8/8] avoid name collision for json --- .../profunktor/redis4cats/algebra/json.scala | 26 +++++++++---------- .../dev/profunktor/redis4cats/redis.scala | 26 +++++++++---------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala index 8cd0501d..d910182c 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/algebra/json.scala @@ -32,31 +32,31 @@ trait JsonCommands[F[_], K, V] * @return * Long the number of values removed plus all the matching JSON numerical values that are zeroed. */ - def clear(key: K, path: JsonPath): F[Long] - def clear(key: K): F[Long] + def jClear(key: K, path: JsonPath): F[Long] + def jClear(key: K): F[Long] /** Deletes a value inside the JSON document at a given JsonPath * @return * Long the number of values removed (0 or more). */ - def del(key: K, path: JsonPath): F[Long] - def del(key: K): F[Long] + def jDel(key: K, path: JsonPath): F[Long] + def jDel(key: K): F[Long] def jsonType(key: K, path: JsonPath): F[List[JsonType]] def jsonType(key: K): F[List[JsonType]] } trait JsonGet[F[_], K, V] { - def get(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] - def get(key: K, arg: JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] - def mget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] - def objKeys(key: K, path: JsonPath): F[List[V]] - def objLen(key: K, path: JsonPath): F[Long] + def jGet(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] + def jGet(key: K, arg: JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] + def jMget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] + def jObjKeys(key: K, path: JsonPath): F[List[V]] + def jObjLen(key: K, path: JsonPath): F[Long] } trait JsonSet[F[_], K, V] { - def mset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] - def set(key: K, path: JsonPath, value: JsonValue): F[Boolean] - def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] - def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] + def jMset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] + def jSet(key: K, path: JsonPath, value: JsonValue): F[Boolean] + def jSetnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] + def jSetxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[String]; } trait JsonNumber[F[_], K, V] { diff --git a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala index 27148a23..c8f3da04 100644 --- a/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala +++ b/modules/effects/src/main/scala/dev/profunktor/redis4cats/redis.scala @@ -768,39 +768,39 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def jsonType(key: K): F[List[JsonType]] = async.flatMap(_.jsonType(key).futureLift.map(_.asScala.toList)) - override def clear(key: K, path: JsonPath): F[Long] = + override def jClear(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonClear(key, path).futureLift.map(x => Long.box(x))) - override def clear(key: K): F[Long] = + override def jClear(key: K): F[Long] = async.flatMap(_.jsonClear(key).futureLift.map(x => Long.box(x))) - override def del(key: K, path: JsonPath): F[Long] = + override def jDel(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonDel(key, path).futureLift.map(x => Long.box(x))) - override def del(key: K): F[Long] = async.flatMap(_.jsonDel(key).futureLift.map(x => Long.box(x))) + override def jDel(key: K): F[Long] = async.flatMap(_.jsonDel(key).futureLift.map(x => Long.box(x))) /** * JSON GETTERS ** */ - override def get(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { + override def jGet(key: K, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { val all = path +: paths async.flatMap(_.jsonGet(key, all: _*).futureLift.map(_.asScala.toList)) } - override def get(key: K, arg: json.JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { + override def jGet(key: K, arg: json.JsonGetArgs, path: JsonPath, paths: JsonPath*): F[List[JsonValue]] = { val all = path +: paths val options = arg.underlying async.flatMap(_.jsonGet(key, options, all: _*).futureLift.map(_.asScala.toList)) } - override def mget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] = { + override def jMget(path: JsonPath, key: K, keys: K*): F[List[JsonValue]] = { val all = key +: keys async.flatMap(_.jsonMGet(path, all: _*).futureLift.map(_.asScala.toList)) } - override def objKeys(key: K, path: JsonPath): F[List[V]] = + override def jObjKeys(key: K, path: JsonPath): F[List[V]] = async.flatMap(_.jsonObjkeys(key, path).futureLift.map(_.asScala.toList)) - override def objLen(key: K, path: JsonPath): F[Long] = + override def jObjLen(key: K, path: JsonPath): F[Long] = async.flatMap(_.jsonObjlen(key, path).futureLift.map(x => Long.unbox(x))) /** * JSON ARRAY ** @@ -829,7 +829,7 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( override def numIncrBy(key: K, path: JsonPath, number: Number): F[List[Number]] = async.flatMap(_.jsonNumincrby(key, path, number).futureLift.map(_.asScala.toList)) - override def mset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] = { + override def jMset(key: K, values: (JsonPath, JsonValue)*): F[Boolean] = { val jValues: util.List[JsonMsetArgs[K, V]] = values .map { case (path, value) => new JsonMsetArgs(key, path, value) } @@ -838,13 +838,13 @@ private[redis4cats] class BaseRedis[F[_]: FutureLift: MonadThrow: Log, K, V]( async.flatMap(_.jsonMSet(jValues).futureLift.map(_.isSuccess)) } - override def set(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + override def jSet(key: K, path: JsonPath, value: JsonValue): F[Boolean] = async.flatMap(_.jsonSet(key, path, value).futureLift).map(Option(_).exists(_.isSuccess)) - override def setnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + override def jSetnx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().nx()).futureLift.map(_.isSuccess)) - override def setxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = + override def jSetxx(key: K, path: JsonPath, value: JsonValue): F[Boolean] = async.flatMap(_.jsonSet(key, path, value, new JsonSetArgs().xx()).futureLift.map(_.isSuccess)) override def jsonMerge(key: K, jsonPath: JsonPath, value: JsonValue): F[String] =