diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/DraftStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/DraftStore.cpp
index 45f1c7d54..da02fa727 100644
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/DraftStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/DraftStore.cpp
@@ -1,67 +1,65 @@
 #include "DraftStore.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 
 namespace comm {
 
-using namespace facebook::react;
-
 OperationType DraftStore::UPDATE_DRAFT_OPERATION = "update";
 OperationType DraftStore::MOVE_DRAFT_OPERATION = "move";
 OperationType DraftStore::REMOVE_ALL_DRAFTS_OPERATION = "remove_all";
 
 DraftStore::DraftStore(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
     : BaseDataStore(jsInvoker) {
 }
 
 jsi::Array DraftStore::parseDBDataStore(
     jsi::Runtime &rt,
     std::shared_ptr<std::vector<Draft>> draftsVectorPtr) const {
   size_t numDrafts = count_if(
       draftsVectorPtr->begin(), draftsVectorPtr->end(), [](Draft draft) {
         return !draft.text.empty();
       });
   jsi::Array jsiDrafts = jsi::Array(rt, numDrafts);
 
   size_t writeIndex = 0;
   for (Draft draft : *draftsVectorPtr) {
     if (draft.text.empty()) {
       continue;
     }
     auto jsiDraft = jsi::Object(rt);
     jsiDraft.setProperty(rt, "key", draft.key);
     jsiDraft.setProperty(rt, "text", draft.text);
     jsiDrafts.setValueAtIndex(rt, writeIndex++, jsiDraft);
   }
   return jsiDrafts;
 }
 
 std::vector<std::unique_ptr<DraftStoreOperationBase>>
 DraftStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
     const {
   std::vector<std::unique_ptr<DraftStoreOperationBase>> draftStoreOps;
   for (auto idx = 0; idx < operations.size(rt); idx++) {
     auto op = operations.getValueAtIndex(rt, idx).asObject(rt);
     auto op_type = op.getProperty(rt, "type").asString(rt).utf8(rt);
 
     if (op_type == REMOVE_ALL_DRAFTS_OPERATION) {
       draftStoreOps.push_back(std::make_unique<RemoveAllDraftsOperation>());
       continue;
     }
 
     auto payload_obj = op.getProperty(rt, "payload").asObject(rt);
     if (op_type == UPDATE_DRAFT_OPERATION) {
       draftStoreOps.push_back(
           std::make_unique<UpdateDraftOperation>(rt, payload_obj));
     } else if (op_type == MOVE_DRAFT_OPERATION) {
       draftStoreOps.push_back(
           std::make_unique<MoveDraftOperation>(rt, payload_obj));
     } else {
       throw std::runtime_error("unsupported operation: " + op_type);
     }
   }
   return draftStoreOps;
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
index ef5cae911..666a98285 100644
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
@@ -1,152 +1,150 @@
 #include "MessageStore.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 
 namespace comm {
 
-using namespace facebook::react;
-
 OperationType MessageStore::REKEY_OPERATION = "rekey";
 OperationType MessageStore::REMOVE_OPERATION = "remove";
 OperationType MessageStore::REPLACE_OPERATION = "replace";
 OperationType MessageStore::REMOVE_MSGS_FOR_THREADS_OPERATION =
     "remove_messages_for_threads";
 OperationType MessageStore::REMOVE_ALL_OPERATION = "remove_all";
 
 OperationType MessageStore::REPLACE_MESSAGE_THREADS_OPERATION =
     "replace_threads";
 OperationType MessageStore::REMOVE_MESSAGE_THREADS_OPERATION = "remove_threads";
 OperationType MessageStore::REMOVE_ALL_MESSAGE_THREADS_OPERATION =
     "remove_all_threads";
 
 MessageStore::MessageStore(
     std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
     : BaseDataStore(jsInvoker) {
 }
 
 jsi::Array MessageStore::parseDBDataStore(
     jsi::Runtime &rt,
     std::shared_ptr<std::vector<MessageEntity>> messagesVectorPtr) const {
   size_t numMessages = messagesVectorPtr->size();
   jsi::Array jsiMessages = jsi::Array(rt, numMessages);
   size_t writeIndex = 0;
   for (const auto &[message, media] : *messagesVectorPtr) {
     auto jsiMessage = jsi::Object(rt);
     jsiMessage.setProperty(rt, "id", message.id);
 
     if (message.local_id) {
       auto local_id = message.local_id.get();
       jsiMessage.setProperty(rt, "local_id", *local_id);
     }
 
     jsiMessage.setProperty(rt, "thread", message.thread);
     jsiMessage.setProperty(rt, "user", message.user);
     jsiMessage.setProperty(rt, "type", std::to_string(message.type));
 
     if (message.future_type) {
       auto future_type = message.future_type.get();
       jsiMessage.setProperty(rt, "future_type", std::to_string(*future_type));
     }
 
     if (message.content) {
       auto content = message.content.get();
       jsiMessage.setProperty(rt, "content", *content);
     }
 
     jsiMessage.setProperty(rt, "time", std::to_string(message.time));
 
     size_t media_idx = 0;
     jsi::Array jsiMediaArray = jsi::Array(rt, media.size());
     for (const auto &media_info : media) {
       auto jsiMedia = jsi::Object(rt);
       jsiMedia.setProperty(rt, "id", media_info.id);
       jsiMedia.setProperty(rt, "uri", media_info.uri);
       jsiMedia.setProperty(rt, "type", media_info.type);
       jsiMedia.setProperty(rt, "extras", media_info.extras);
 
       jsiMediaArray.setValueAtIndex(rt, media_idx++, jsiMedia);
     }
 
     jsiMessage.setProperty(rt, "media_infos", jsiMediaArray);
 
     jsiMessages.setValueAtIndex(rt, writeIndex++, jsiMessage);
   }
   return jsiMessages;
 }
 
 std::vector<std::unique_ptr<MessageStoreOperationBase>>
 MessageStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
     const {
 
   std::vector<std::unique_ptr<MessageStoreOperationBase>> messageStoreOps;
 
   for (auto idx = 0; idx < operations.size(rt); idx++) {
     auto op = operations.getValueAtIndex(rt, idx).asObject(rt);
     auto op_type = op.getProperty(rt, "type").asString(rt).utf8(rt);
 
     if (op_type == REMOVE_ALL_OPERATION) {
       messageStoreOps.push_back(std::make_unique<RemoveAllMessagesOperation>());
       continue;
     }
     if (op_type == REMOVE_ALL_MESSAGE_THREADS_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<RemoveAllMessageStoreThreadsOperation>());
       continue;
     }
 
     auto payload_obj = op.getProperty(rt, "payload").asObject(rt);
     if (op_type == REMOVE_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<RemoveMessagesOperation>(rt, payload_obj));
 
     } else if (op_type == REMOVE_MSGS_FOR_THREADS_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<RemoveMessagesForThreadsOperation>(rt, payload_obj));
 
     } else if (op_type == REPLACE_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<ReplaceMessageOperation>(rt, payload_obj));
 
     } else if (op_type == REKEY_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<RekeyMessageOperation>(rt, payload_obj));
 
     } else if (op_type == REPLACE_MESSAGE_THREADS_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<ReplaceMessageThreadsOperation>(rt, payload_obj));
     } else if (op_type == REMOVE_MESSAGE_THREADS_OPERATION) {
       messageStoreOps.push_back(
           std::make_unique<RemoveMessageStoreThreadsOperation>(
               rt, payload_obj));
     } else {
       throw std::runtime_error("unsupported operation: " + op_type);
     }
   }
 
   return messageStoreOps;
 }
 
 jsi::Array MessageStore::parseDBMessageStoreThreads(
     jsi::Runtime &rt,
     std::shared_ptr<std::vector<MessageStoreThread>> threadsVectorPtr) const {
   size_t numThreads = threadsVectorPtr->size();
   jsi::Array jsiThreads = jsi::Array(rt, numThreads);
   size_t writeIdx = 0;
 
   for (const MessageStoreThread &thread : *threadsVectorPtr) {
     jsi::Object jsiThread = jsi::Object(rt);
     jsiThread.setProperty(rt, "id", thread.id);
     jsiThread.setProperty(
         rt, "start_reached", std::to_string(thread.start_reached));
     jsiThread.setProperty(
         rt, "last_navigated_to", std::to_string(thread.last_navigated_to));
     jsiThread.setProperty(
         rt, "last_pruned", std::to_string(thread.last_pruned));
 
     jsiThreads.setValueAtIndex(rt, writeIdx++, jsiThread);
   }
   return jsiThreads;
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ReportStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ReportStore.cpp
index 482d3b7e0..8e45431df 100644
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ReportStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ReportStore.cpp
@@ -1,62 +1,60 @@
 #include "ReportStore.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 
 namespace comm {
 
-using namespace facebook::react;
-
 OperationType ReportStore::REPLACE_REPORT_OPERATION = "replace_report";
 OperationType ReportStore::REMOVE_REPORTS_OPERATION = "remove_reports";
 OperationType ReportStore::REMOVE_ALL_REPORTS_OPERATION = "remove_all_reports";
 
 ReportStore::ReportStore(
     std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
     : BaseDataStore(jsInvoker) {
 }
 
 jsi::Array ReportStore::parseDBDataStore(
     jsi::Runtime &rt,
     std::shared_ptr<std::vector<Report>> reportStoreVectorPtr) const {
   size_t numReports = reportStoreVectorPtr->size();
   jsi::Array jsiReports = jsi::Array(rt, numReports);
   size_t writeIdx = 0;
 
   for (const Report &report : *reportStoreVectorPtr) {
     jsi::Object jsiReport = jsi::Object(rt);
     jsiReport.setProperty(rt, "id", report.id);
     jsiReport.setProperty(rt, "report", report.report);
     jsiReports.setValueAtIndex(rt, writeIdx++, jsiReport);
   }
   return jsiReports;
 }
 
 std::vector<std::unique_ptr<ReportStoreOperationBase>>
 ReportStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
     const {
   std::vector<std::unique_ptr<ReportStoreOperationBase>> reportStoreOps;
   for (auto idx = 0; idx < operations.size(rt); idx++) {
     auto op = operations.getValueAtIndex(rt, idx).asObject(rt);
     auto op_type = op.getProperty(rt, "type").asString(rt).utf8(rt);
 
     if (op_type == REMOVE_ALL_REPORTS_OPERATION) {
       reportStoreOps.push_back(std::make_unique<RemoveAllReportsOperation>());
       continue;
     }
 
     auto payload_obj = op.getProperty(rt, "payload").asObject(rt);
     if (op_type == REPLACE_REPORT_OPERATION) {
       reportStoreOps.push_back(
           std::make_unique<ReplaceReportOperation>(rt, payload_obj));
     } else if (op_type == REMOVE_REPORTS_OPERATION) {
       reportStoreOps.push_back(
           std::make_unique<RemoveReportsOperation>(rt, payload_obj));
     } else {
       throw std::runtime_error{"unsupported operation: " + op_type};
     }
   }
   return reportStoreOps;
 }
 
 } // namespace comm
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
index f23a828bc..d68c3d3cd 100644
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
@@ -1,200 +1,198 @@
 #include "ThreadStore.h"
 
 #include <ReactCommon/TurboModuleUtils.h>
 #include <jsi/jsi.h>
 
 namespace comm {
 
-using namespace facebook::react;
-
 OperationType ThreadStore::REMOVE_OPERATION = "remove";
 OperationType ThreadStore::REMOVE_ALL_OPERATION = "remove_all";
 OperationType ThreadStore::REPLACE_OPERATION = "replace";
 
 ThreadStore::ThreadStore(
     std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
     : BaseDataStore(jsInvoker) {
 }
 
 jsi::Array ThreadStore::parseDBDataStore(
     jsi::Runtime &rt,
     std::shared_ptr<std::vector<Thread>> threadsVectorPtr) const {
   size_t numThreads = threadsVectorPtr->size();
   jsi::Array jsiThreads = jsi::Array(rt, numThreads);
   size_t writeIdx = 0;
   for (const Thread &thread : *threadsVectorPtr) {
     jsi::Object jsiThread = jsi::Object(rt);
     jsiThread.setProperty(rt, "id", thread.id);
     jsiThread.setProperty(rt, "type", thread.type);
     jsiThread.setProperty(
         rt,
         "name",
         thread.name ? jsi::String::createFromUtf8(rt, *thread.name)
                     : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "description",
         thread.description
             ? jsi::String::createFromUtf8(rt, *thread.description)
             : jsi::Value::null());
     jsiThread.setProperty(rt, "color", thread.color);
     jsiThread.setProperty(
         rt, "creationTime", std::to_string(thread.creation_time));
     jsiThread.setProperty(
         rt,
         "parentThreadID",
         thread.parent_thread_id
             ? jsi::String::createFromUtf8(rt, *thread.parent_thread_id)
             : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "containingThreadID",
         thread.containing_thread_id
             ? jsi::String::createFromUtf8(rt, *thread.containing_thread_id)
             : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "community",
         thread.community ? jsi::String::createFromUtf8(rt, *thread.community)
                          : jsi::Value::null());
     jsiThread.setProperty(rt, "members", thread.members);
     jsiThread.setProperty(rt, "roles", thread.roles);
     jsiThread.setProperty(rt, "currentUser", thread.current_user);
     jsiThread.setProperty(
         rt,
         "sourceMessageID",
         thread.source_message_id
             ? jsi::String::createFromUtf8(rt, *thread.source_message_id)
             : jsi::Value::null());
     jsiThread.setProperty(rt, "repliesCount", thread.replies_count);
     jsiThread.setProperty(rt, "pinnedCount", thread.pinned_count);
 
     if (thread.avatar) {
       auto avatar = jsi::String::createFromUtf8(rt, *thread.avatar);
       jsiThread.setProperty(rt, "avatar", avatar);
     }
 
     jsiThreads.setValueAtIndex(rt, writeIdx++, jsiThread);
   }
   return jsiThreads;
 }
 
 std::vector<std::unique_ptr<ThreadStoreOperationBase>>
 ThreadStore::createOperations(jsi::Runtime &rt, const jsi::Array &operations)
     const {
   std::vector<std::unique_ptr<ThreadStoreOperationBase>> threadStoreOps;
 
   for (size_t idx = 0; idx < operations.size(rt); idx++) {
     jsi::Object op = operations.getValueAtIndex(rt, idx).asObject(rt);
     std::string opType = op.getProperty(rt, "type").asString(rt).utf8(rt);
 
     if (opType == REMOVE_OPERATION) {
       std::vector<std::string> threadIDsToRemove;
       jsi::Object payloadObj = op.getProperty(rt, "payload").asObject(rt);
       jsi::Array threadIDs =
           payloadObj.getProperty(rt, "ids").asObject(rt).asArray(rt);
       for (int threadIdx = 0; threadIdx < threadIDs.size(rt); threadIdx++) {
         threadIDsToRemove.push_back(
             threadIDs.getValueAtIndex(rt, threadIdx).asString(rt).utf8(rt));
       }
       threadStoreOps.push_back(std::make_unique<RemoveThreadsOperation>(
           std::move(threadIDsToRemove)));
     } else if (opType == REMOVE_ALL_OPERATION) {
       threadStoreOps.push_back(std::make_unique<RemoveAllThreadsOperation>());
     } else if (opType == REPLACE_OPERATION) {
       jsi::Object threadObj = op.getProperty(rt, "payload").asObject(rt);
       std::string threadID =
           threadObj.getProperty(rt, "id").asString(rt).utf8(rt);
       int type = std::lround(threadObj.getProperty(rt, "type").asNumber());
       jsi::Value maybeName = threadObj.getProperty(rt, "name");
       std::unique_ptr<std::string> name = maybeName.isString()
           ? std::make_unique<std::string>(maybeName.asString(rt).utf8(rt))
           : nullptr;
 
       jsi::Value maybeDescription = threadObj.getProperty(rt, "description");
       std::unique_ptr<std::string> description = maybeDescription.isString()
           ? std::make_unique<std::string>(
                 maybeDescription.asString(rt).utf8(rt))
           : nullptr;
 
       std::string color =
           threadObj.getProperty(rt, "color").asString(rt).utf8(rt);
       int64_t creationTime = std::stoll(
           threadObj.getProperty(rt, "creationTime").asString(rt).utf8(rt));
 
       jsi::Value maybeParentThreadID =
           threadObj.getProperty(rt, "parentThreadID");
       std::unique_ptr<std::string> parentThreadID =
           maybeParentThreadID.isString()
           ? std::make_unique<std::string>(
                 maybeParentThreadID.asString(rt).utf8(rt))
           : nullptr;
 
       jsi::Value maybeContainingThreadID =
           threadObj.getProperty(rt, "containingThreadID");
       std::unique_ptr<std::string> containingThreadID =
           maybeContainingThreadID.isString()
           ? std::make_unique<std::string>(
                 maybeContainingThreadID.asString(rt).utf8(rt))
           : nullptr;
 
       jsi::Value maybeCommunity = threadObj.getProperty(rt, "community");
       std::unique_ptr<std::string> community = maybeCommunity.isString()
           ? std::make_unique<std::string>(maybeCommunity.asString(rt).utf8(rt))
           : nullptr;
 
       std::string members =
           threadObj.getProperty(rt, "members").asString(rt).utf8(rt);
       std::string roles =
           threadObj.getProperty(rt, "roles").asString(rt).utf8(rt);
       std::string currentUser =
           threadObj.getProperty(rt, "currentUser").asString(rt).utf8(rt);
 
       jsi::Value maybeSourceMessageID =
           threadObj.getProperty(rt, "sourceMessageID");
       std::unique_ptr<std::string> sourceMessageID =
           maybeSourceMessageID.isString()
           ? std::make_unique<std::string>(
                 maybeSourceMessageID.asString(rt).utf8(rt))
           : nullptr;
 
       int repliesCount =
           std::lround(threadObj.getProperty(rt, "repliesCount").asNumber());
 
       jsi::Value maybeAvatar = threadObj.getProperty(rt, "avatar");
       std::unique_ptr<std::string> avatar = maybeAvatar.isString()
           ? std::make_unique<std::string>(maybeAvatar.asString(rt).utf8(rt))
           : nullptr;
 
       jsi::Value maybePinnedCount = threadObj.getProperty(rt, "pinnedCount");
       int pinnedCount = maybePinnedCount.isNumber()
           ? std::lround(maybePinnedCount.asNumber())
           : 0;
       Thread thread{
           threadID,
           type,
           std::move(name),
           std::move(description),
           color,
           creationTime,
           std::move(parentThreadID),
           std::move(containingThreadID),
           std::move(community),
           members,
           roles,
           currentUser,
           std::move(sourceMessageID),
           repliesCount,
           std::move(avatar),
           pinnedCount};
 
       threadStoreOps.push_back(
           std::make_unique<ReplaceThreadOperation>(std::move(thread)));
     } else {
       throw std::runtime_error("unsupported operation: " + opType);
     }
   };
   return threadStoreOps;
 }
 
 } // namespace comm