Rebranding module to use Valkey instead of Redis (#194)

* Rebranding module to use Valkey instead of Redis

fixes: #5

Signed-off-by: Yana Molodetsky <[email protected]>

Author: yanamolo

src/acl.cc

@@ -211,9 +211,9 @@ bool IsAllowedCommands(
   return allowed;
 }
 
-absl::string_view CallReplyStringToStringView(RedisModuleCallReply *r) {
+absl::string_view CallReplyStringToStringView(ValkeyModuleCallReply *r) {
   size_t l;
-  const char *r_c_str = RedisModule_CallReplyStringPtr(r, &l);
+  const char *r_c_str = ValkeyModule_CallReplyStringPtr(r, &l);
   return {r_c_str, l};
 }
 
@@ -278,18 +278,18 @@ bool IsPrefixAllowed(const absl::string_view &module_prefix,
 
 void GetAclViewFromCallReplyImpl(
     std::vector<acl::ValkeyAclGetUserReplyView> &acl_views,
-    RedisModuleCallReply *reply) {
+    ValkeyModuleCallReply *reply) {
   acl_views.emplace_back(acl::ValkeyAclGetUserReplyView{});
   auto &acl_view = acl_views.back();
 
-  RedisModuleCallReply *map_key;
-  RedisModuleCallReply *map_val;
+  ValkeyModuleCallReply *map_key;
+  ValkeyModuleCallReply *map_val;
   int idx = 0;
 
-  while (RedisModule_CallReplyMapElement(reply, idx, &map_key, &map_val) ==
-         REDISMODULE_OK) {
+  while (ValkeyModule_CallReplyMapElement(reply, idx, &map_key, &map_val) ==
+         VALKEYMODULE_OK) {
     if (map_key &&
-        RedisModule_CallReplyType(map_key) == REDISMODULE_REPLY_STRING) {
+        ValkeyModule_CallReplyType(map_key) == VALKEYMODULE_REPLY_STRING) {
       absl::string_view key = CallReplyStringToStringView(map_key);
 
       if (absl::EqualsIgnoreCase(key, "commands")) {
@@ -298,9 +298,9 @@ void GetAclViewFromCallReplyImpl(
         acl_view.keys = CallReplyStringToStringView(map_val);
       } else if (absl::EqualsIgnoreCase(key, "selectors")) {
         int selector_idx = 0;
-        RedisModuleCallReply *selector_reply;
-        while ((selector_reply =
-                    RedisModule_CallReplyArrayElement(map_val, selector_idx))) {
+        ValkeyModuleCallReply *selector_reply;
+        while ((selector_reply = ValkeyModule_CallReplyArrayElement(
+                    map_val, selector_idx))) {
           GetAclViewFromCallReplyImpl(acl_views, selector_reply);
           selector_idx++;
         }
@@ -313,8 +313,8 @@ void GetAclViewFromCallReplyImpl(
 }  // namespace
 
 absl::StatusOr<std::vector<acl::ValkeyAclGetUserReplyView>>
-GetAclViewFromCallReply(RedisModuleCallReply *reply) {
-  if (!reply || RedisModule_CallReplyType(reply) != REDISMODULE_REPLY_MAP) {
+GetAclViewFromCallReply(ValkeyModuleCallReply *reply) {
+  if (!reply || ValkeyModule_CallReplyType(reply) != VALKEYMODULE_REPLY_MAP) {
     return absl::FailedPreconditionError(
         "Cannot get an ACL from the server, got an invalid response");
   }
@@ -325,15 +325,16 @@ GetAclViewFromCallReply(RedisModuleCallReply *reply) {
 }
 
 absl::Status AclPrefixCheck(
-    RedisModuleCtx *ctx,
+    ValkeyModuleCtx *ctx,
     const absl::flat_hash_set<absl::string_view> &module_allowed_cmds,
     const std::vector<std::string> &module_prefixes) {
   if (!vmsdk::IsRealUserClient(ctx)) {
     return absl::OkStatus();
   }
-  auto username = vmsdk::UniqueRedisString(RedisModule_GetCurrentUserName(ctx));
-  auto reply = vmsdk::UniquePtrRedisCallReply(
-      RedisModule_Call(ctx, "ACL", "cs3", "GETUSER", username.get()));
+  auto username =
+      vmsdk::UniqueValkeyString(ValkeyModule_GetCurrentUserName(ctx));
+  auto reply = vmsdk::UniquePtrValkeyCallReply(
+      ValkeyModule_Call(ctx, "ACL", "cs3", "GETUSER", username.get()));
   VMSDK_ASSIGN_OR_RETURN(auto acl_views, GetAclViewFromCallReply(reply.get()));
 
   auto acl_keys = GetKeysWithAllowedCommands(module_allowed_cmds, acl_views);
@@ -354,7 +355,7 @@ absl::Status AclPrefixCheck(
 }
 
 absl::Status AclPrefixCheck(
-    RedisModuleCtx *ctx,
+    ValkeyModuleCtx *ctx,
     const absl::flat_hash_set<absl::string_view> &module_allowed_cmds,
     const data_model::IndexSchema &index_schema_proto) {
   std::vector<std::string> module_prefixes;

src/acl.h

@@ -29,12 +29,12 @@ Check if
     * according to the ACL rules defined in the server.
 */
 absl::Status AclPrefixCheck(
-    RedisModuleCtx *ctx,
+    ValkeyModuleCtx *ctx,
     const absl::flat_hash_set<absl::string_view> &module_allowed_cmds,
     const std::vector<std::string> &module_prefixes);
 
 absl::Status AclPrefixCheck(
-    RedisModuleCtx *ctx,
+    ValkeyModuleCtx *ctx,
     const absl::flat_hash_set<absl::string_view> &module_allowed_cmds,
     const data_model::IndexSchema &index_schema_proto);
 

src/attribute.h

@@ -1,30 +1,8 @@
 /*
- * Copyright (c) 2025, ValkeySearch contributors
+ * Copyright (c) 2025, valkey-search contributors
  * All rights reserved.
+ * SPDX-License-Identifier: BSD 3-Clause
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef VALKEYSEARCH_SRC_ATTRIBUTE_H_
@@ -57,31 +35,31 @@ class Attribute {
     attribute_proto->set_allocated_index(index_->ToProto().release());
     return attribute_proto;
   }
-  inline int RespondWithInfo(RedisModuleCtx* ctx) const {
-    RedisModule_ReplyWithArray(ctx, REDISMODULE_POSTPONED_LEN);
-    RedisModule_ReplyWithSimpleString(ctx, "identifier");
-    RedisModule_ReplyWithSimpleString(ctx, GetIdentifier().c_str());
-    RedisModule_ReplyWithSimpleString(ctx, "attribute");
-    RedisModule_ReplyWithSimpleString(ctx, GetAlias().c_str());
+  inline int RespondWithInfo(ValkeyModuleCtx* ctx) const {
+    ValkeyModule_ReplyWithArray(ctx, VALKEYMODULE_POSTPONED_LEN);
+    ValkeyModule_ReplyWithSimpleString(ctx, "identifier");
+    ValkeyModule_ReplyWithSimpleString(ctx, GetIdentifier().c_str());
+    ValkeyModule_ReplyWithSimpleString(ctx, "attribute");
+    ValkeyModule_ReplyWithSimpleString(ctx, GetAlias().c_str());
     int added_fields = index_->RespondWithInfo(ctx);
-    RedisModule_ReplySetArrayLength(ctx, added_fields + 4);
+    ValkeyModule_ReplySetArrayLength(ctx, added_fields + 4);
     return 1;
   }
 
-  inline vmsdk::UniqueRedisString DefaultReplyScoreAs() const {
+  inline vmsdk::UniqueValkeyString DefaultReplyScoreAs() const {
     if (!cached_score_as_) {
       cached_score_as_ =
-          vmsdk::MakeUniqueRedisString(absl::StrCat("__", alias_, "_score"));
+          vmsdk::MakeUniqueValkeyString(absl::StrCat("__", alias_, "_score"));
     }
-    return vmsdk::RetainUniqueRedisString(cached_score_as_.get());
+    return vmsdk::RetainUniqueValkeyString(cached_score_as_.get());
   }
 
  private:
   std::string alias_;
   std::string identifier_;
   std::shared_ptr<indexes::IndexBase> index_;
   // Maintaining a cached version
-  mutable vmsdk::UniqueRedisString cached_score_as_;
+  mutable vmsdk::UniqueValkeyString cached_score_as_;
 };
 
 }  // namespace valkey_search

src/attribute_data_type.cc

@@ -1,30 +1,8 @@
 /*
- * Copyright (c) 2025, ValkeySearch contributors
+ * Copyright (c) 2025, valkey-search contributors
  * All rights reserved.
+ * SPDX-License-Identifier: BSD 3-Clause
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "src/attribute_data_type.h"
@@ -45,27 +23,27 @@
 #include "vmsdk/src/valkey_module_api/valkey_module.h"
 
 namespace valkey_search {
-absl::StatusOr<vmsdk::UniqueRedisString> HashAttributeDataType::GetRecord(
-    [[maybe_unused]] RedisModuleCtx *ctx, RedisModuleKey *open_key,
+absl::StatusOr<vmsdk::UniqueValkeyString> HashAttributeDataType::GetRecord(
+    [[maybe_unused]] ValkeyModuleCtx *ctx, ValkeyModuleKey *open_key,
     [[maybe_unused]] absl::string_view key,
     absl::string_view identifier) const {
   vmsdk::VerifyMainThread();
-  RedisModuleString *record{nullptr};
-  RedisModule_HashGet(open_key, REDISMODULE_HASH_CFIELDS, identifier.data(),
-                      &record, nullptr);
+  ValkeyModuleString *record{nullptr};
+  ValkeyModule_HashGet(open_key, VALKEYMODULE_HASH_CFIELDS, identifier.data(),
+                       &record, nullptr);
   if (!record) {
     return absl::NotFoundError("No such record with identifier");
   }
-  return vmsdk::UniqueRedisString(record);
+  return vmsdk::UniqueValkeyString(record);
 }
 
 struct HashScanCallbackData {
   const absl::flat_hash_set<absl::string_view> &identifiers;
   RecordsMap key_value_content;
 };
 
-void HashScanCallback(RedisModuleKey *key, RedisModuleString *field,
-                      RedisModuleString *value, void *privdata) {
+void HashScanCallback(ValkeyModuleKey *key, ValkeyModuleString *field,
+                      ValkeyModuleString *value, void *privdata) {
   vmsdk::VerifyMainThread();
   if (!field || !value) {
     return;
@@ -78,26 +56,27 @@ void HashScanCallback(RedisModuleKey *key, RedisModuleString *field,
   if (callback_data->identifiers.empty() ||
       callback_data->identifiers.contains(field_str)) {
     callback_data->key_value_content.emplace(
-        field_str, RecordsMapValue(vmsdk::RetainUniqueRedisString(field),
-                                   vmsdk::RetainUniqueRedisString(value)));
+        field_str, RecordsMapValue(vmsdk::RetainUniqueValkeyString(field),
+                                   vmsdk::RetainUniqueValkeyString(value)));
   }
 }
 
-bool HashHasRecord(RedisModuleKey *key, absl::string_view identifier) {
+bool HashHasRecord(ValkeyModuleKey *key, absl::string_view identifier) {
   int exists;
-  RedisModule_HashGet(key, REDISMODULE_HASH_CFIELDS | REDISMODULE_HASH_EXISTS,
-                      identifier.data(), &exists, nullptr);
+  ValkeyModule_HashGet(key,
+                       VALKEYMODULE_HASH_CFIELDS | VALKEYMODULE_HASH_EXISTS,
+                       identifier.data(), &exists, nullptr);
   return exists;
 }
 
 absl::StatusOr<RecordsMap> HashAttributeDataType::FetchAllRecords(
-    RedisModuleCtx *ctx, const std::string &vector_identifier,
+    ValkeyModuleCtx *ctx, const std::string &vector_identifier,
     absl::string_view key,
     const absl::flat_hash_set<absl::string_view> &identifiers) const {
   vmsdk::VerifyMainThread();
-  auto key_str = vmsdk::MakeUniqueRedisString(key);
+  auto key_str = vmsdk::MakeUniqueValkeyString(key);
   auto key_obj =
-      vmsdk::MakeUniqueRedisOpenKey(ctx, key_str.get(), REDISMODULE_READ);
+      vmsdk::MakeUniqueValkeyOpenKey(ctx, key_str.get(), VALKEYMODULE_READ);
   if (!key_obj) {
     return absl::NotFoundError(
         absl::StrCat("No such record with key: `", vector_identifier, "`"));
@@ -106,10 +85,10 @@ absl::StatusOr<RecordsMap> HashAttributeDataType::FetchAllRecords(
     return absl::NotFoundError(absl::StrCat("No such record with identifier: `",
                                             vector_identifier, "`"));
   }
-  vmsdk::UniqueRedisScanCursor cursor = vmsdk::MakeUniqueRedisScanCursor();
+  vmsdk::UniqueValkeyScanCursor cursor = vmsdk::MakeUniqueValkeyScanCursor();
   HashScanCallbackData callback_data{identifiers};
-  while (RedisModule_ScanKey(key_obj.get(), cursor.get(), HashScanCallback,
-                             &callback_data)) {
+  while (ValkeyModule_ScanKey(key_obj.get(), cursor.get(), HashScanCallback,
+                              &callback_data)) {
   }
   return std::move(callback_data.key_value_content);
 }
@@ -121,7 +100,7 @@ absl::string_view TrimBrackets(absl::string_view record) {
   return record;
 }
 
-absl::StatusOr<vmsdk::UniqueRedisString> NormalizeJsonRecord(
+absl::StatusOr<vmsdk::UniqueValkeyString> NormalizeJsonRecord(
     absl::string_view record) {
   if (!record.empty() && record[0] != '[') {
     return absl::NotFoundError("Invalid record");
@@ -135,40 +114,40 @@ absl::StatusOr<vmsdk::UniqueRedisString> NormalizeJsonRecord(
   if (record.empty()) {
     return absl::NotFoundError("Empty record");
   }
-  return vmsdk::MakeUniqueRedisString(record);
+  return vmsdk::MakeUniqueValkeyString(record);
 }
 
-absl::StatusOr<vmsdk::UniqueRedisString> JsonAttributeDataType::GetRecord(
-    RedisModuleCtx *ctx, [[maybe_unused]] RedisModuleKey *open_key,
+absl::StatusOr<vmsdk::UniqueValkeyString> JsonAttributeDataType::GetRecord(
+    ValkeyModuleCtx *ctx, [[maybe_unused]] ValkeyModuleKey *open_key,
     absl::string_view key, absl::string_view identifier) const {
   vmsdk::VerifyMainThread();
 
-  auto reply = vmsdk::UniquePtrRedisCallReply(RedisModule_Call(
+  auto reply = vmsdk::UniquePtrValkeyCallReply(ValkeyModule_Call(
       ctx, kJsonCmd.data(), "cc", key.data(), identifier.data()));
   if (reply == nullptr) {
     return absl::NotFoundError(
         absl::StrCat("No such record with identifier: `", identifier, "`"));
   }
-  auto reply_type = RedisModule_CallReplyType(reply.get());
-  if (reply_type == REDISMODULE_REPLY_STRING) {
-    auto reply_str = vmsdk::UniqueRedisString(
-        RedisModule_CreateStringFromCallReply(reply.get()));
+  auto reply_type = ValkeyModule_CallReplyType(reply.get());
+  if (reply_type == VALKEYMODULE_REPLY_STRING) {
+    auto reply_str = vmsdk::UniqueValkeyString(
+        ValkeyModule_CreateStringFromCallReply(reply.get()));
     return NormalizeJsonRecord(vmsdk::ToStringView(reply_str.get()));
   }
   return absl::NotFoundError("Json.get returned a non string value");
 }
 
 absl::StatusOr<RecordsMap> JsonAttributeDataType::FetchAllRecords(
-    RedisModuleCtx *ctx, const std::string &vector_identifier,
+    ValkeyModuleCtx *ctx, const std::string &vector_identifier,
     absl::string_view key,
     const absl::flat_hash_set<absl::string_view> &identifiers) const {
   vmsdk::VerifyMainThread();
   // Validating that a JSON object with the key exists with the vector
   // identifier
-  auto reply = vmsdk::UniquePtrRedisCallReply(RedisModule_Call(
+  auto reply = vmsdk::UniquePtrValkeyCallReply(ValkeyModule_Call(
       ctx, kJsonCmd.data(), "cc", key.data(), vector_identifier.c_str()));
   if (reply == nullptr ||
-      RedisModule_CallReplyType(reply.get()) != REDISMODULE_REPLY_STRING) {
+      ValkeyModule_CallReplyType(reply.get()) != VALKEYMODULE_REPLY_STRING) {
     return absl::NotFoundError(absl::StrCat("No such record with identifier: `",
                                             vector_identifier, "`"));
   }
@@ -179,13 +158,13 @@ absl::StatusOr<RecordsMap> JsonAttributeDataType::FetchAllRecords(
       continue;
     }
     key_value_content.emplace(
-        identifier, RecordsMapValue(vmsdk::MakeUniqueRedisString(identifier),
+        identifier, RecordsMapValue(vmsdk::MakeUniqueValkeyString(identifier),
                                     std::move(str.value())));
   }
   return key_value_content;
 }
 
-bool IsJsonModuleLoaded(RedisModuleCtx *ctx) {
+bool IsJsonModuleLoaded(ValkeyModuleCtx *ctx) {
   return vmsdk::IsModuleLoaded(ctx, "json");
 }
 }  // namespace valkey_search