diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h b/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/Message.h
@@ -4,6 +4,7 @@
 #include "Nullable.h"
 #include <sqlite3.h>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -11,34 +12,34 @@
 
 struct Message {
   std::string id;
-  std::unique_ptr<std::string> local_id;
+  std::optional<std::string> local_id;
   std::string thread;
   std::string user;
   int type;
-  std::unique_ptr<int> future_type;
-  std::unique_ptr<std::string> content;
+  std::optional<int> future_type;
+  std::optional<std::string> content;
   int64_t time;
 
   static Message fromSQLResult(sqlite3_stmt *sqlRow, int idx) {
     return Message{
         getStringFromSQLRow(sqlRow, idx),
-        getStringPtrFromSQLRow(sqlRow, idx + 1),
+        getOptionalStringFromSQLRow(sqlRow, idx + 1),
         getStringFromSQLRow(sqlRow, idx + 2),
         getStringFromSQLRow(sqlRow, idx + 3),
         getIntFromSQLRow(sqlRow, idx + 4),
-        getIntPtrFromSQLRow(sqlRow, idx + 5),
-        getStringPtrFromSQLRow(sqlRow, idx + 6),
+        getOptionalIntFromSQLRow(sqlRow, idx + 5),
+        getOptionalStringFromSQLRow(sqlRow, idx + 6),
         getInt64FromSQLRow(sqlRow, idx + 7)};
   }
 
   int bindToSQL(sqlite3_stmt *sql, int idx) const {
     bindStringToSQL(id, sql, idx);
-    bindStringPtrToSQL(local_id, sql, idx + 1);
+    bindOptionalStringToSQL(local_id, sql, idx + 1);
     bindStringToSQL(thread, sql, idx + 2);
     bindStringToSQL(user, sql, idx + 3);
     bindIntToSQL(type, sql, idx + 4);
-    bindIntPtrToSQL(future_type, sql, idx + 5);
-    bindStringPtrToSQL(content, sql, idx + 6);
+    bindOptionalIntToSQL(future_type, sql, idx + 5);
+    bindOptionalStringToSQL(content, sql, idx + 6);
     return bindInt64ToSQL(time, sql, idx + 7);
   }
 };
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/Nullable.h b/native/cpp/CommonCpp/DatabaseManagers/entities/Nullable.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/Nullable.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/Nullable.h
@@ -16,6 +16,10 @@
       : value((ptr) ? *ptr : T()), isNull(!ptr) {
   }
 
+  Nullable(const std::optional<T> &opt)
+      : value(opt.value_or(T())), isNull(!opt.has_value()) {
+  }
+
   Nullable &operator=(const std::unique_ptr<T> &ptr) {
     if (ptr) {
       value = *ptr;
@@ -27,8 +31,19 @@
     return *this;
   }
 
-  std::unique_ptr<T> resetValue() const {
-    return isNull ? nullptr : std::make_unique<T>(value);
+  Nullable &operator=(const std::optional<T> &opt) {
+    if (opt.has_value()) {
+      value = *opt;
+      isNull = false;
+    } else {
+      value = T();
+      isNull = true;
+    }
+    return *this;
+  }
+
+  std::optional<T> resetValue() const {
+    return isNull ? std::nullopt : std::optional<T>(value);
   }
 };
 
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.h b/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.h
@@ -2,26 +2,27 @@
 
 #include <sqlite3.h>
 #include <memory>
+#include <optional>
 #include <string>
 
 namespace comm {
 // getting data from SQL statement result row
 std::string getStringFromSQLRow(sqlite3_stmt *sqlRow, int idx);
 int getIntFromSQLRow(sqlite3_stmt *sqlRow, int idx);
-std::unique_ptr<std::string>
-getStringPtrFromSQLRow(sqlite3_stmt *sqlRow, int idx);
-std::unique_ptr<int> getIntPtrFromSQLRow(sqlite3_stmt *sqlRow, int idx);
+std::optional<std::string>
+getOptionalStringFromSQLRow(sqlite3_stmt *sqlRow, int idx);
+std::optional<int> getOptionalIntFromSQLRow(sqlite3_stmt *sqlRow, int idx);
 int64_t getInt64FromSQLRow(sqlite3_stmt *sqlRow, int idx);
 
 // binding data to SQL statement
 int bindStringToSQL(const std::string &data, sqlite3_stmt *sql, int idx);
-int bindStringPtrToSQL(
-    const std::unique_ptr<std::string> &data,
+int bindOptionalStringToSQL(
+    const std::optional<std::string> &data,
     sqlite3_stmt *sql,
     int idx);
 int bindIntToSQL(int data, sqlite3_stmt *sql, int idx);
-int bindIntPtrToSQL(
-    const std::unique_ptr<int> &data,
+int bindOptionalIntToSQL(
+    const std::optional<int> &data,
     sqlite3_stmt *sql,
     int idx);
 int bindInt64ToSQL(int64_t data, sqlite3_stmt *sql, int idx);
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.cpp b/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.cpp
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.cpp
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/SQLiteDataConverters.cpp
@@ -9,21 +9,21 @@
   return sqlite3_column_int(sqlRow, idx);
 }
 
-std::unique_ptr<std::string>
-getStringPtrFromSQLRow(sqlite3_stmt *sqlRow, int idx) {
+std::optional<std::string>
+getOptionalStringFromSQLRow(sqlite3_stmt *sqlRow, int idx) {
   const char *maybeString =
       reinterpret_cast<const char *>(sqlite3_column_text(sqlRow, idx));
   if (!maybeString) {
-    return nullptr;
+    return std::nullopt;
   }
-  return std::make_unique<std::string>(maybeString);
+  return std::string(maybeString);
 }
 
-std::unique_ptr<int> getIntPtrFromSQLRow(sqlite3_stmt *sqlRow, int idx) {
+std::optional<int> getOptionalIntFromSQLRow(sqlite3_stmt *sqlRow, int idx) {
   if (sqlite3_column_type(sqlRow, idx) == SQLITE_NULL) {
-    return nullptr;
+    return std::nullopt;
   }
-  return std::make_unique<int>(sqlite3_column_int(sqlRow, idx));
+  return sqlite3_column_int(sqlRow, idx);
 }
 
 int64_t getInt64FromSQLRow(sqlite3_stmt *sqlRow, int idx) {
@@ -34,11 +34,11 @@
   return sqlite3_bind_text(sql, idx, data.c_str(), -1, SQLITE_TRANSIENT);
 }
 
-int bindStringPtrToSQL(
-    const std::unique_ptr<std::string> &data,
+int bindOptionalStringToSQL(
+    const std::optional<std::string> &data,
     sqlite3_stmt *sql,
     int idx) {
-  if (data == nullptr) {
+  if (!data.has_value()) {
     return sqlite3_bind_null(sql, idx);
   }
   return sqlite3_bind_text(sql, idx, data->c_str(), -1, SQLITE_TRANSIENT);
@@ -48,11 +48,11 @@
   return sqlite3_bind_int(sql, idx, data);
 }
 
-int bindIntPtrToSQL(
-    const std::unique_ptr<int> &data,
+int bindOptionalIntToSQL(
+    const std::optional<int> &data,
     sqlite3_stmt *sql,
     int idx) {
-  if (data == nullptr) {
+  if (!data.has_value()) {
     return sqlite3_bind_null(sql, idx);
   }
   return sqlite3_bind_int(sql, idx, *data);
diff --git a/native/cpp/CommonCpp/DatabaseManagers/entities/Thread.h b/native/cpp/CommonCpp/DatabaseManagers/entities/Thread.h
--- a/native/cpp/CommonCpp/DatabaseManagers/entities/Thread.h
+++ b/native/cpp/CommonCpp/DatabaseManagers/entities/Thread.h
@@ -2,6 +2,7 @@
 
 #include <sqlite3.h>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "Nullable.h"
@@ -12,62 +13,62 @@
 struct Thread {
   std::string id;
   int type;
-  std::unique_ptr<std::string> name;
-  std::unique_ptr<std::string> description;
+  std::optional<std::string> name;
+  std::optional<std::string> description;
   std::string color;
   int64_t creation_time;
-  std::unique_ptr<std::string> parent_thread_id;
-  std::unique_ptr<std::string> containing_thread_id;
-  std::unique_ptr<std::string> community;
+  std::optional<std::string> parent_thread_id;
+  std::optional<std::string> containing_thread_id;
+  std::optional<std::string> community;
   std::string members;
   std::string roles;
   std::string current_user;
-  std::unique_ptr<std::string> source_message_id;
+  std::optional<std::string> source_message_id;
   int replies_count;
-  std::unique_ptr<std::string> avatar;
+  std::optional<std::string> avatar;
   int pinned_count;
-  std::unique_ptr<std::string> timestamps;
+  std::optional<std::string> timestamps;
 
   static Thread fromSQLResult(sqlite3_stmt *sqlRow, int idx) {
     return Thread{
         getStringFromSQLRow(sqlRow, idx),
         getIntFromSQLRow(sqlRow, idx + 1),
-        getStringPtrFromSQLRow(sqlRow, idx + 2),
-        getStringPtrFromSQLRow(sqlRow, idx + 3),
+        getOptionalStringFromSQLRow(sqlRow, idx + 2),
+        getOptionalStringFromSQLRow(sqlRow, idx + 3),
         getStringFromSQLRow(sqlRow, idx + 4),
         getInt64FromSQLRow(sqlRow, idx + 5),
-        getStringPtrFromSQLRow(sqlRow, idx + 6),
-        getStringPtrFromSQLRow(sqlRow, idx + 7),
-        getStringPtrFromSQLRow(sqlRow, idx + 8),
+        getOptionalStringFromSQLRow(sqlRow, idx + 6),
+        getOptionalStringFromSQLRow(sqlRow, idx + 7),
+        getOptionalStringFromSQLRow(sqlRow, idx + 8),
         getStringFromSQLRow(sqlRow, idx + 9),
         getStringFromSQLRow(sqlRow, idx + 10),
         getStringFromSQLRow(sqlRow, idx + 11),
-        getStringPtrFromSQLRow(sqlRow, idx + 12),
+        getOptionalStringFromSQLRow(sqlRow, idx + 12),
         getIntFromSQLRow(sqlRow, idx + 13),
-        getStringPtrFromSQLRow(sqlRow, idx + 14),
+        getOptionalStringFromSQLRow(sqlRow, idx + 14),
         getIntFromSQLRow(sqlRow, idx + 15),
-        getStringPtrFromSQLRow(sqlRow, idx + 16),
+        getOptionalStringFromSQLRow(sqlRow, idx + 16),
     };
   }
 
   int bindToSQL(sqlite3_stmt *sql, int idx) const {
     bindStringToSQL(id, sql, idx);
     bindIntToSQL(type, sql, idx + 1);
-    bindStringPtrToSQL(name, sql, idx + 2);
-    bindStringPtrToSQL(description, sql, idx + 3);
+    bindOptionalStringToSQL(name, sql, idx + 2);
+    bindOptionalStringToSQL(description, sql, idx + 3);
     bindStringToSQL(color, sql, idx + 4);
     bindInt64ToSQL(creation_time, sql, idx + 5);
-    bindStringPtrToSQL(parent_thread_id, sql, idx + 6);
-    bindStringPtrToSQL(containing_thread_id, sql, idx + 7);
-    bindStringPtrToSQL(community, sql, idx + 8);
+    bindOptionalStringToSQL(parent_thread_id, sql, idx + 6);
+    bindOptionalStringToSQL(containing_thread_id, sql, idx + 7);
+    bindOptionalStringToSQL(community, sql, idx + 8);
     bindStringToSQL(members, sql, idx + 9);
     bindStringToSQL(roles, sql, idx + 10);
     bindStringToSQL(current_user, sql, idx + 11);
-    bindStringPtrToSQL(source_message_id, sql, idx + 12);
+    bindOptionalStringToSQL(source_message_id, sql, idx + 12);
     bindIntToSQL(replies_count, sql, idx + 13);
-    bindStringPtrToSQL(avatar, sql, idx + 14);
+    bindOptionalStringToSQL(avatar, sql, idx + 14);
     bindIntToSQL(pinned_count, sql, idx + 15);
-    return bindStringPtrToSQL(timestamps, sql, idx + 16);
+    return bindOptionalStringToSQL(timestamps, sql, idx + 16);
   }
 };
 
diff --git a/native/cpp/CommonCpp/NativeModules/MessageStoreOperations.h b/native/cpp/CommonCpp/NativeModules/MessageStoreOperations.h
--- a/native/cpp/CommonCpp/NativeModules/MessageStoreOperations.h
+++ b/native/cpp/CommonCpp/NativeModules/MessageStoreOperations.h
@@ -4,6 +4,7 @@
 #include "../DatabaseManagers/entities/Message.h"
 #include "DBOperationBase.h"
 #include "DatabaseManager.h"
+#include <optional>
 #include <vector>
 
 namespace comm {
@@ -61,9 +62,9 @@
     auto msg_id = payload.getProperty(rt, "id").asString(rt).utf8(rt);
 
     auto maybe_local_id = payload.getProperty(rt, "local_id");
-    auto local_id = maybe_local_id.isString()
-        ? std::make_unique<std::string>(maybe_local_id.asString(rt).utf8(rt))
-        : nullptr;
+    std::optional<std::string> local_id = maybe_local_id.isString()
+        ? std::optional<std::string>(maybe_local_id.asString(rt).utf8(rt))
+        : std::nullopt;
 
     auto thread = payload.getProperty(rt, "thread").asString(rt).utf8(rt);
     auto user = payload.getProperty(rt, "user").asString(rt).utf8(rt);
@@ -71,28 +72,20 @@
         std::stoi(payload.getProperty(rt, "type").asString(rt).utf8(rt));
 
     auto maybe_future_type = payload.getProperty(rt, "future_type");
-    auto future_type = maybe_future_type.isString()
-        ? std::make_unique<int>(
-              std::stoi(maybe_future_type.asString(rt).utf8(rt)))
-        : nullptr;
+    std::optional<int> future_type = maybe_future_type.isString()
+        ? std::optional<int>(std::stoi(maybe_future_type.asString(rt).utf8(rt)))
+        : std::nullopt;
 
     auto maybe_content = payload.getProperty(rt, "content");
-    auto content = maybe_content.isString()
-        ? std::make_unique<std::string>(maybe_content.asString(rt).utf8(rt))
-        : nullptr;
+    std::optional<std::string> content = maybe_content.isString()
+        ? std::optional<std::string>(maybe_content.asString(rt).utf8(rt))
+        : std::nullopt;
 
     auto time =
         std::stoll(payload.getProperty(rt, "time").asString(rt).utf8(rt));
 
     this->msg = std::make_unique<Message>(Message{
-        msg_id,
-        std::move(local_id),
-        thread,
-        user,
-        type,
-        std::move(future_type),
-        std::move(content),
-        time});
+        msg_id, local_id, thread, user, type, future_type, content, time});
 
     if (payload.getProperty(rt, "media_infos").isObject()) {
       auto media_infos =
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/MessageStore.cpp
@@ -42,23 +42,21 @@
     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);
+    if (message.local_id.has_value()) {
+      jsiMessage.setProperty(rt, "local_id", message.local_id.value());
     }
 
     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.future_type.has_value()) {
+      int future_type = message.future_type.value();
+      jsiMessage.setProperty(rt, "future_type", std::to_string(future_type));
     }
 
-    if (message.content) {
-      auto content = message.content.get();
-      jsiMessage.setProperty(rt, "content", *content);
+    if (message.content.has_value()) {
+      jsiMessage.setProperty(rt, "content", message.content.value());
     }
 
     jsiMessage.setProperty(rt, "time", std::to_string(message.time));
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/ThreadStore.cpp
@@ -28,13 +28,14 @@
     jsiThread.setProperty(
         rt,
         "name",
-        thread.name ? jsi::String::createFromUtf8(rt, *thread.name)
-                    : jsi::Value::null());
+        thread.name.has_value()
+            ? jsi::String::createFromUtf8(rt, thread.name.value())
+            : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "description",
-        thread.description
-            ? jsi::String::createFromUtf8(rt, *thread.description)
+        thread.description.has_value()
+            ? jsi::String::createFromUtf8(rt, thread.description.value())
             : jsi::Value::null());
     jsiThread.setProperty(rt, "color", thread.color);
     jsiThread.setProperty(
@@ -42,39 +43,42 @@
     jsiThread.setProperty(
         rt,
         "parentThreadID",
-        thread.parent_thread_id
-            ? jsi::String::createFromUtf8(rt, *thread.parent_thread_id)
+        thread.parent_thread_id.has_value()
+            ? jsi::String::createFromUtf8(rt, thread.parent_thread_id.value())
             : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "containingThreadID",
-        thread.containing_thread_id
-            ? jsi::String::createFromUtf8(rt, *thread.containing_thread_id)
+        thread.containing_thread_id.has_value()
+            ? jsi::String::createFromUtf8(
+                  rt, thread.containing_thread_id.value())
             : jsi::Value::null());
     jsiThread.setProperty(
         rt,
         "community",
-        thread.community ? jsi::String::createFromUtf8(rt, *thread.community)
-                         : jsi::Value::null());
+        thread.community.has_value()
+            ? jsi::String::createFromUtf8(rt, thread.community.value())
+            : 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)
+        thread.source_message_id.has_value()
+            ? jsi::String::createFromUtf8(rt, thread.source_message_id.value())
             : 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);
+    if (thread.avatar.has_value()) {
+      auto avatar = jsi::String::createFromUtf8(rt, thread.avatar.value());
       jsiThread.setProperty(rt, "avatar", avatar);
     }
 
-    if (thread.timestamps) {
-      auto timestamps = jsi::String::createFromUtf8(rt, *thread.timestamps);
+    if (thread.timestamps.has_value()) {
+      auto timestamps =
+          jsi::String::createFromUtf8(rt, thread.timestamps.value());
       jsiThread.setProperty(rt, "timestamps", timestamps);
     }
 
@@ -111,15 +115,14 @@
           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;
+      std::optional<std::string> name = maybeName.isString()
+          ? std::optional<std::string>(maybeName.asString(rt).utf8(rt))
+          : std::nullopt;
 
       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::optional<std::string> description = maybeDescription.isString()
+          ? std::optional<std::string>(maybeDescription.asString(rt).utf8(rt))
+          : std::nullopt;
 
       std::string color =
           threadObj.getProperty(rt, "color").asString(rt).utf8(rt);
@@ -128,24 +131,23 @@
 
       jsi::Value maybeParentThreadID =
           threadObj.getProperty(rt, "parentThreadID");
-      std::unique_ptr<std::string> parentThreadID =
-          maybeParentThreadID.isString()
-          ? std::make_unique<std::string>(
+      std::optional<std::string> parentThreadID = maybeParentThreadID.isString()
+          ? std::optional<std::string>(
                 maybeParentThreadID.asString(rt).utf8(rt))
-          : nullptr;
+          : std::nullopt;
 
       jsi::Value maybeContainingThreadID =
           threadObj.getProperty(rt, "containingThreadID");
-      std::unique_ptr<std::string> containingThreadID =
+      std::optional<std::string> containingThreadID =
           maybeContainingThreadID.isString()
-          ? std::make_unique<std::string>(
+          ? std::optional<std::string>(
                 maybeContainingThreadID.asString(rt).utf8(rt))
-          : nullptr;
+          : std::nullopt;
 
       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::optional<std::string> community = maybeCommunity.isString()
+          ? std::optional<std::string>(maybeCommunity.asString(rt).utf8(rt))
+          : std::nullopt;
 
       std::string members =
           threadObj.getProperty(rt, "members").asString(rt).utf8(rt);
@@ -156,19 +158,19 @@
 
       jsi::Value maybeSourceMessageID =
           threadObj.getProperty(rt, "sourceMessageID");
-      std::unique_ptr<std::string> sourceMessageID =
+      std::optional<std::string> sourceMessageID =
           maybeSourceMessageID.isString()
-          ? std::make_unique<std::string>(
+          ? std::optional<std::string>(
                 maybeSourceMessageID.asString(rt).utf8(rt))
-          : nullptr;
+          : std::nullopt;
 
       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;
+      std::optional<std::string> avatar = maybeAvatar.isString()
+          ? std::optional<std::string>(maybeAvatar.asString(rt).utf8(rt))
+          : std::nullopt;
 
       jsi::Value maybePinnedCount = threadObj.getProperty(rt, "pinnedCount");
       int pinnedCount = maybePinnedCount.isNumber()
@@ -176,27 +178,27 @@
           : 0;
 
       jsi::Value maybeTimestamps = threadObj.getProperty(rt, "timestamps");
-      std::unique_ptr<std::string> timestamps = maybeTimestamps.isString()
-          ? std::make_unique<std::string>(maybeTimestamps.asString(rt).utf8(rt))
-          : nullptr;
+      std::optional<std::string> timestamps = maybeTimestamps.isString()
+          ? std::optional<std::string>(maybeTimestamps.asString(rt).utf8(rt))
+          : std::nullopt;
       Thread thread{
           threadID,
           type,
-          std::move(name),
-          std::move(description),
+          name,
+          description,
           color,
           creationTime,
-          std::move(parentThreadID),
-          std::move(containingThreadID),
-          std::move(community),
+          parentThreadID,
+          containingThreadID,
+          community,
           members,
           roles,
           currentUser,
-          std::move(sourceMessageID),
+          sourceMessageID,
           repliesCount,
-          std::move(avatar),
+          avatar,
           pinnedCount,
-          std::move(timestamps)};
+          timestamps};
 
       threadStoreOps.push_back(
           std::make_unique<ReplaceThreadOperation>(std::move(thread)));
diff --git a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/MessageOperationsUtilities/MessageOperationsUtilities.cpp b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/MessageOperationsUtilities/MessageOperationsUtilities.cpp
--- a/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/MessageOperationsUtilities/MessageOperationsUtilities.cpp
+++ b/native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/MessageOperationsUtilities/MessageOperationsUtilities.cpp
@@ -4,6 +4,7 @@
 
 #include <folly/String.h>
 #include <folly/json.h>
+#include <optional>
 #include <stdexcept>
 
 namespace comm {
@@ -16,26 +17,27 @@
   std::string thread = rawMessageInfo["threadID"].asString();
   std::string user = rawMessageInfo["creatorID"].asString();
 
-  std::unique_ptr<std::string> localID = nullptr;
+  std::optional<std::string> localID = std::nullopt;
   if (rawMessageInfo.count("localID")) {
-    localID =
-        std::make_unique<std::string>(rawMessageInfo["localID"].asString());
+    localID = rawMessageInfo["localID"].asString();
   }
 
   int type = rawMessageInfo["type"].asInt();
   MessageType messageType = static_cast<MessageType>(type);
   int64_t time = rawMessageInfo["time"].asInt();
 
-  std::unique_ptr<int> futureType = nullptr;
+  std::optional<int> futureType = std::nullopt;
   if (messageType == MessageType::UNSUPPORTED) {
-    futureType = std::make_unique<int>(
-        rawMessageInfo["unsupportedMessageInfo"]["type"].asInt());
+    futureType = rawMessageInfo["unsupportedMessageInfo"]["type"].asInt();
   }
 
-  std::unique_ptr<std::string> content = nullptr;
+  std::optional<std::string> content = std::nullopt;
   if (messageSpecsHolder.find(messageType) != messageSpecsHolder.end()) {
-    content = messageSpecsHolder.at(messageType)
-                  ->messageContentForClientDB(rawMessageInfo);
+    auto contentPtr = messageSpecsHolder.at(messageType)
+                          ->messageContentForClientDB(rawMessageInfo);
+    if (contentPtr) {
+      content = *contentPtr;
+    }
   }
   std::vector<Media> mediaVector;
   if (messageType == MessageType::IMAGES ||
diff --git a/web/shared-worker/_generated/comm_query_executor.wasm b/web/shared-worker/_generated/comm_query_executor.wasm
index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
GIT binary patch
literal 0
Hc$@<O00001

literal 0
Hc$@<O00001