diff --git a/changelog.md b/changelog.md
index fe64c62ea..b6ee9f0c8 100644
--- a/changelog.md
+++ b/changelog.md
@@ -20,6 +20,7 @@
 
 * `[system_features]` Sprintf clean up.
 * `[listview]` Added ability to rebuild on provided data offset. 
+* `[messages]` Cleanup of database service API.
 
 ## [0.38.2 2020-09-18]
 
diff --git a/module-apps/application-messages/ApplicationMessages.cpp b/module-apps/application-messages/ApplicationMessages.cpp
index e7df80297..b00d597a6 100644
--- a/module-apps/application-messages/ApplicationMessages.cpp
+++ b/module-apps/application-messages/ApplicationMessages.cpp
@@ -19,6 +19,9 @@
 #include <module-db/queries/sms/QuerySMSAdd.hpp>
 #include <module-db/queries/sms/QuerySMSRemove.hpp>
 #include <module-db/queries/sms/QuerySMSUpdate.hpp>
+#include <module-db/queries/sms/QueryThreadGetByID.hpp>
+#include <module-db/queries/sms/QueryThreadRemove.hpp>
+#include <module-db/queries/phonebook/QueryContactGetByID.hpp>
 
 #include <cassert>
 #include <time/time_conversion.hpp>
@@ -68,49 +71,43 @@ namespace app
             handled = true;
             switch (resp->responseTo) {
             case MessageType::DBThreadGetLimitOffset:
-            case MessageType::DBSMSTemplateGetLimitOffset: {
-
-                if (getCurrentWindow()->onDatabaseMessage(resp))
+                [[fallthrough]];
+            case MessageType::DBSMSTemplateGetLimitOffset:
+                if (getCurrentWindow()->onDatabaseMessage(resp)) {
                     refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
-
+                }
                 break;
-            }
             case MessageType::DBQuery:
-
                 if (auto queryResponse = dynamic_cast<db::QueryResponse *>(resp)) {
                     auto result = queryResponse->getResult();
-
                     if (result->hasListener()) {
                         if (result->handle()) {
                             refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
                         }
                     }
                 }
-
                 break;
             default:
                 break;
             }
         }
 
-        if (handled)
+        if (handled) {
             return std::make_shared<sys::ResponseMessage>();
-        else
-            return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
+        }
+        return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
     }
 
     // Invoked during initialization
     sys::ReturnCodes ApplicationMessages::InitHandler()
     {
-
         auto ret = Application::InitHandler();
-        if (ret != sys::ReturnCodes::Success)
+        if (ret != sys::ReturnCodes::Success) {
             return ret;
+        }
 
         createUserInterface();
-
         setActiveWindow(gui::name::window::main_window);
-
         return ret;
     }
 
@@ -154,67 +151,114 @@ namespace app
         return true;
     }
 
-    bool ApplicationMessages::removeSMS_thread(const ThreadRecord *record)
+    bool ApplicationMessages::removeSmsThread(const ThreadRecord *record)
     {
+        using db::query::ContactGetByID;
+        using db::query::ContactGetByIDResult;
+
         if (record == nullptr) {
-            LOG_ERROR("removing null SMS thread!");
+            LOG_ERROR("Trying to remove a null SMS thread!");
             return false;
         }
-        else {
-            LOG_DEBUG("Removing thread: %" PRIu32, record->ID);
-            auto dialog = dynamic_cast<gui::DialogYesNo *>(windows[gui::name::window::dialog_yes_no]);
-            assert(dialog != nullptr);
-            auto meta   = dialog->meta;
-            meta.action = [=]() -> bool {
-                if (!DBServiceAPI::ThreadRemove(this, record->ID)) {
-                    LOG_ERROR("ThreadRemove id=%" PRIu32 " failed", record->ID);
-                    return false;
-                }
-                this->switchWindow(gui::name::window::main_window);
+        LOG_DEBUG("Removing thread: %" PRIu32, record->ID);
+
+        auto dialog = dynamic_cast<gui::DialogYesNo *>(windows[gui::name::window::dialog_yes_no]);
+        assert(dialog != nullptr);
+
+        auto query = std::make_unique<ContactGetByID>(record->contactID);
+        query->setQueryListener(db::QueryCallback::fromFunction([this, dialog, record](auto response) {
+            auto result = dynamic_cast<ContactGetByIDResult *>(response);
+            if (result != nullptr) {
+                const auto &contact = result->getResult();
+                auto meta           = dialog->meta;
+                meta.action         = [this, record]() { return onRemoveSmsThreadConfirmed(*record); };
+                meta.text           = utils::localize.get("app_messages_thread_delete_confirmation");
+                meta.title          = contact.getFormattedName();
+                meta.icon           = "phonebook_contact_delete_trashcan";
+                dialog->update(meta);
+                switchWindow(dialog->getName());
                 return true;
-            };
-            meta.text       = utils::localize.get("app_messages_thread_delete_confirmation");
-            auto contactRec = DBServiceAPI::ContactGetByID(this, record->contactID);
-            auto cont       = !contactRec->empty() ? contactRec->front() : ContactRecord{};
-            meta.title      = cont.getFormattedName();
-            meta.icon       = "phonebook_contact_delete_trashcan";
-            dialog->update(meta);
-            switchWindow(dialog->getName());
-            return true;
-        }
+            }
+            return false;
+        }));
+        return DBServiceAPI::GetQuery(this, db::Interface::Name::Contact, std::move(query));
     }
 
-    bool ApplicationMessages::removeSMS(const SMSRecord &record)
+    bool ApplicationMessages::onRemoveSmsThreadConfirmed(const ThreadRecord &record)
+    {
+        using db::query::ThreadRemove;
+        using db::query::ThreadRemoveResult;
+
+        auto query = std::make_unique<ThreadRemove>(record.ID);
+        query->setQueryListener(db::QueryCallback::fromFunction([this, threadId = record.ID](auto response) {
+            const auto result = dynamic_cast<ThreadRemoveResult *>(response);
+            if ((result != nullptr) && result->success()) {
+                switchWindow(gui::name::window::main_window);
+                return true;
+            }
+            LOG_ERROR("ThreadRemove id=%" PRIu32 " failed", threadId);
+            return false;
+        }));
+
+        if (const auto ok = DBServiceAPI::GetQuery(this, db::Interface::Name::SMSThread, std::move(query)); !ok) {
+            LOG_ERROR("Unable to query DBServiceAPI");
+            return false;
+        }
+        return true;
+    }
+
+    bool ApplicationMessages::removeSms(const SMSRecord &record)
     {
         LOG_DEBUG("Removing sms: %" PRIu32, record.ID);
         auto dialog = dynamic_cast<gui::DialogYesNo *>(windows[gui::name::window::dialog_yes_no]);
         assert(dialog != nullptr);
 
         auto meta   = dialog->meta;
-        meta.action = [=]() -> bool {
-            if (!DBServiceAPI::SMSRemove(this, record)) {
-                LOG_ERROR("sSMSRemove id=%" PRIu32 " failed", record.ID);
-                return false;
-            }
-            // if this was the last message in the thread, there won't be no thread. goto main window
-            std::unique_ptr<ThreadRecord> threadDetails = DBServiceAPI::ThreadGet(this, record.threadID);
-            if (threadDetails == nullptr || !threadDetails->isValid()) {
-                this->switchWindow(gui::name::window::main_window);
-                return true;
-            }
-            else {
-                this->switchWindow(gui::name::window::thread_view);
-                return true;
-            }
-        };
-        meta.text  = utils::localize.get("app_messages_message_delete_confirmation");
-        meta.title = record.body;
-        meta.icon  = "phonebook_contact_delete_trashcan";
+        meta.action = [this, record] { return onRemoveSmsConfirmed(record); };
+        meta.text   = utils::localize.get("app_messages_message_delete_confirmation");
+        meta.title  = record.body;
+        meta.icon   = "phonebook_contact_delete_trashcan";
+
         dialog->update(meta);
         switchWindow(dialog->getName());
         return true;
     }
 
+    bool ApplicationMessages::onRemoveSmsConfirmed(const SMSRecord &record)
+    {
+        using db::query::SMSRemove;
+        using db::query::SMSRemoveResult;
+        using db::query::ThreadGetByID;
+        using db::query::ThreadGetByIDResult;
+
+        auto query = std::make_unique<SMSRemove>(record.ID);
+        query->setQueryListener(db::QueryCallback::fromFunction([this, record](auto response) {
+            auto result = dynamic_cast<SMSRemoveResult *>(response);
+            if (result != nullptr && result->getResults()) {
+                auto query = std::make_unique<ThreadGetByID>(record.threadID);
+                query->setQueryListener(db::QueryCallback::fromFunction([this](auto response) {
+                    const auto result = dynamic_cast<ThreadGetByIDResult *>(response);
+                    if (result != nullptr) {
+                        const auto thread = result->getRecord();
+                        if (thread.has_value()) {
+                            this->switchWindow(gui::name::window::thread_view);
+                        }
+                        else {
+                            this->switchWindow(gui::name::window::main_window);
+                        }
+                        return true;
+                    }
+                    return false;
+                }));
+                return DBServiceAPI::GetQuery(this, db::Interface::Name::SMSThread, std::move(query));
+            }
+            LOG_ERROR("sSMSRemove id=%" PRIu32 " failed", record.ID);
+            return false;
+        }));
+
+        return DBServiceAPI::GetQuery(this, db::Interface::Name::SMS, std::move(query));
+    }
+
     bool ApplicationMessages::searchEmpty(const std::string &query)
     {
         auto dialog = dynamic_cast<gui::Dialog *>(windows[gui::name::window::dialog]);
@@ -297,15 +341,21 @@ namespace app
         record.body   = body;
         record.type   = SMSType::QUEUED;
         record.date   = utils::time::getCurrentTimestamp().getTime();
-        return DBServiceAPI::SMSAdd(this, record) != DB_ID_NONE;
+
+        using db::query::SMSAdd;
+        return DBServiceAPI::GetQuery(this, db::Interface::Name::SMS, std::make_unique<SMSAdd>(record));
     }
+
     bool ApplicationMessages::resendSms(const SMSRecord &record)
     {
         auto resendRecord = record;
         resendRecord.type = SMSType::QUEUED;
-        // update date sent - it will display an old, failed sms at the the bottom, but this is correct
-        resendRecord.date = utils::time::getCurrentTimestamp().getTime();
-        return DBServiceAPI::SMSUpdate(this, resendRecord);
+        resendRecord.date =
+            utils::time::getCurrentTimestamp().getTime(); // update date sent - it will display an old, failed sms at
+                                                          // the the bottom, but this is correct
+
+        using db::query::SMSUpdate;
+        return DBServiceAPI::GetQuery(this, db::Interface::Name::SMS, std::make_unique<SMSUpdate>(resendRecord));
     }
 
     bool ApplicationMessages::handleSendSmsFromThread(const utils::PhoneNumber::View &number, const UTF8 &body)
diff --git a/module-apps/application-messages/ApplicationMessages.hpp b/module-apps/application-messages/ApplicationMessages.hpp
index ab66922ef..f62bd77eb 100644
--- a/module-apps/application-messages/ApplicationMessages.hpp
+++ b/module-apps/application-messages/ApplicationMessages.hpp
@@ -51,8 +51,8 @@ namespace app
         void createUserInterface() override;
         void destroyUserInterface() override;
 
-        bool removeSMS(const SMSRecord &record);
-        bool removeSMS_thread(const ThreadRecord *record);
+        bool removeSms(const SMSRecord &record);
+        bool removeSmsThread(const ThreadRecord *record);
         bool markSmsThreadAsRead(const uint32_t id);
         bool markSmsThreadAsUnread(const uint32_t id);
         /// show dialog with big search icon and text which was used for query
@@ -68,6 +68,9 @@ namespace app
         bool updateDraft(SMSRecord &record, const UTF8 &body);
         bool removeDraft(const SMSRecord &record);
 
+        bool onRemoveSmsThreadConfirmed(const ThreadRecord &record);
+        bool onRemoveSmsConfirmed(const SMSRecord &record);
+
         // used by sms template items
         std::function<bool(std::shared_ptr<SMSTemplateRecord> templ)> templatesCallback;
     };
diff --git a/module-apps/application-messages/models/BaseThreadsRecordModel.hpp b/module-apps/application-messages/models/BaseThreadsRecordModel.hpp
index 2c5f37f1f..d002cb004 100644
--- a/module-apps/application-messages/models/BaseThreadsRecordModel.hpp
+++ b/module-apps/application-messages/models/BaseThreadsRecordModel.hpp
@@ -8,9 +8,7 @@
 
 #include <vector>
 
-class BaseThreadsRecordModel : public app::DatabaseModel<ThreadRecord>,
-                               public gui::ListItemProvider,
-                               public db::QueryListener
+class BaseThreadsRecordModel : public app::DatabaseModel<ThreadRecord>, public gui::ListItemProvider
 {
   public:
     BaseThreadsRecordModel() = delete;
diff --git a/module-apps/application-messages/models/ThreadsModel.cpp b/module-apps/application-messages/models/ThreadsModel.cpp
index 1a0e1b88e..dc9da7279 100644
--- a/module-apps/application-messages/models/ThreadsModel.cpp
+++ b/module-apps/application-messages/models/ThreadsModel.cpp
@@ -9,12 +9,12 @@
 ThreadsModel::ThreadsModel(app::Application *app) : BaseThreadsRecordModel(app)
 {}
 
-unsigned int ThreadsModel::getMinimalItemHeight() const
+auto ThreadsModel::getMinimalItemHeight() const -> unsigned int
 {
     return style::window::messages::sms_thread_item_h;
 }
 
-gui::ListItem *ThreadsModel::getItem(gui::Order order)
+auto ThreadsModel::getItem(gui::Order order) -> gui::ListItem *
 {
     std::shared_ptr<ThreadRecord> thread = getRecord(order);
 
@@ -54,7 +54,8 @@ gui::ListItem *ThreadsModel::getItem(gui::Order order)
 void ThreadsModel::requestRecords(uint32_t offset, uint32_t limit)
 {
     auto query = std::make_unique<db::query::SMSThreadsGet>(offset, limit);
-    query->setQueryListener(this);
+    query->setQueryListener(
+        db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
     DBServiceAPI::GetQuery(getApplication(), db::Interface::Name::SMSThread, std::move(query));
 }
 
@@ -65,6 +66,5 @@ auto ThreadsModel::handleQueryResponse(db::QueryResult *queryResult) -> bool
 
     auto records_data = msgResponse->getResults();
     auto records      = std::make_unique<std::vector<ThreadRecord>>(records_data.begin(), records_data.end());
-
     return this->updateRecords(std::move(records));
 }
diff --git a/module-apps/application-messages/models/ThreadsModel.hpp b/module-apps/application-messages/models/ThreadsModel.hpp
index f6db8ed12..4c48b9b28 100644
--- a/module-apps/application-messages/models/ThreadsModel.hpp
+++ b/module-apps/application-messages/models/ThreadsModel.hpp
@@ -5,12 +5,11 @@
 class ThreadsModel : public BaseThreadsRecordModel
 {
   public:
-    ThreadsModel(app::Application *app);
-
-    // virtual method for db::QueryListener
-    auto handleQueryResponse(db::QueryResult *) -> bool override;
+    explicit ThreadsModel(app::Application *app);
 
     void requestRecords(uint32_t offset, uint32_t limit) override;
-    unsigned int getMinimalItemHeight() const override;
-    gui::ListItem *getItem(gui::Order order) override;
+    [[nodiscard]] auto getMinimalItemHeight() const -> unsigned int override;
+    [[nodiscard]] auto getItem(gui::Order order) -> gui::ListItem * override;
+
+    auto handleQueryResponse(db::QueryResult *queryResult) -> bool;
 };
diff --git a/module-apps/application-messages/models/ThreadsSearchResultsModel.cpp b/module-apps/application-messages/models/ThreadsSearchResultsModel.cpp
index e4fe9e2b8..781ce43f1 100644
--- a/module-apps/application-messages/models/ThreadsSearchResultsModel.cpp
+++ b/module-apps/application-messages/models/ThreadsSearchResultsModel.cpp
@@ -13,12 +13,12 @@ namespace gui::model
     ThreadsSearchResultsModel::ThreadsSearchResultsModel(app::Application *app) : BaseThreadsRecordModel(app)
     {}
 
-    unsigned int ThreadsSearchResultsModel::getMinimalItemHeight() const
+    auto ThreadsSearchResultsModel::getMinimalItemHeight() const -> unsigned int
     {
         return style::window::messages::sms_thread_item_h;
     }
 
-    gui::ListItem *ThreadsSearchResultsModel::getItem(gui::Order order)
+    auto ThreadsSearchResultsModel::getItem(gui::Order order) -> gui::ListItem *
     {
 
         std::shared_ptr<ThreadRecord> thread = getRecord(order);
@@ -46,7 +46,8 @@ namespace gui::model
     {
         if (std::string(search_value).compare("") != 0) {
             auto query = std::make_unique<db::query::SMSSearch>(search_value, offset, limit);
-            query->setQueryListener(this);
+            query->setQueryListener(
+                db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
             DBServiceAPI::GetQuery(getApplication(), db::Interface::Name::SMSThread, std::move(query));
         }
     }
diff --git a/module-apps/application-messages/models/ThreadsSearchResultsModel.hpp b/module-apps/application-messages/models/ThreadsSearchResultsModel.hpp
index f20bd14d8..a4256fabd 100644
--- a/module-apps/application-messages/models/ThreadsSearchResultsModel.hpp
+++ b/module-apps/application-messages/models/ThreadsSearchResultsModel.hpp
@@ -13,14 +13,13 @@ namespace gui::model
       public:
         ThreadsSearchResultsModel(app::Application *app);
 
-        unsigned int getMinimalItemHeight() const override;
-        ListItem *getItem(Order order) override;
+        auto getMinimalItemHeight() const -> unsigned int override;
+        auto getItem(Order order) -> ListItem * override;
         /// empty, size get in requestRecords
         void requestRecords(uint32_t offset, uint32_t limit) override;
         /// set what we need to search
         void setSearchValue(const UTF8 &search_value);
 
-        // virtual method for db::QueryListener
-        auto handleQueryResponse(db::QueryResult *) -> bool override;
+        auto handleQueryResponse(db::QueryResult *) -> bool;
     };
 }; // namespace gui::model
diff --git a/module-apps/application-messages/windows/MessagesMainWindow.cpp b/module-apps/application-messages/windows/MessagesMainWindow.cpp
index 129c79653..6259ba84b 100644
--- a/module-apps/application-messages/windows/MessagesMainWindow.cpp
+++ b/module-apps/application-messages/windows/MessagesMainWindow.cpp
@@ -12,7 +12,9 @@
 #include <application-phonebook/data/PhonebookItemData.hpp>
 #include <Style.hpp>
 #include <log/log.hpp>
+
 #include <module-db/queries/notifications/QueryNotificationsClear.hpp>
+#include <module-db/queries/sms/QueryThreadGetByContactID.hpp>
 
 #include <memory>
 #include <cassert>
@@ -20,7 +22,6 @@
 
 namespace gui
 {
-
     MessagesMainWindow::MessagesMainWindow(app::Application *app) : AppWindow(app, gui::name::window::main_window)
     {
         buildInterface();
@@ -28,17 +29,19 @@ namespace gui
 
     void MessagesMainWindow::rebuild()
     {
+        if (list == nullptr) {
+            return;
+        }
         list->rebuildList(style::listview::RebuildType::InPlace);
     }
 
     void MessagesMainWindow::buildInterface()
     {
-
         namespace msgThreadStyle = style::messages::threads;
 
         AppWindow::buildInterface();
 
-        threadsModel = std::make_shared<ThreadsModel>(this->application);
+        threadsModel = std::make_shared<ThreadsModel>(application);
 
         list = new gui::ListView(this,
                                  msgThreadStyle::listPositionX,
@@ -73,7 +76,7 @@ namespace gui
                                  utils::localize.get("app_messages_no_messages"));
 
         list->setVisible(true);
-        list->focusChangedCallback = [=](gui::Item & /*item*/) {
+        list->focusChangedCallback = [this]([[maybe_unused]] gui::Item &item) {
             bottomBar->setActive(BottomBar::Side::LEFT, true);
             bottomBar->setActive(BottomBar::Side::CENTER, true);
             rightArrowImage->setVisible(true);
@@ -81,32 +84,39 @@ namespace gui
             return true;
         };
 
-        setFocusItem(list);
-
         emptyListIcon->setVisible(false);
-        emptyListIcon->focusChangedCallback = [=](gui::Item & /*item*/) {
+        emptyListIcon->focusChangedCallback = [this]([[maybe_unused]] gui::Item &item) {
             bottomBar->setActive(BottomBar::Side::LEFT, false);
             bottomBar->setActive(BottomBar::Side::CENTER, false);
             rightArrowImage->setVisible(false);
             searchImage->setVisible(false);
             return true;
         };
+
+        setFocusItem(list);
     }
 
     void MessagesMainWindow::onBeforeShow(ShowMode mode, SwitchData *data)
     {
-
         LOG_INFO("Data: %s", data ? data->getDescription().c_str() : "");
         {
-            if (auto pdata = dynamic_cast<PhonebookSearchReuqest *>(data)) {
-                auto thread = DBServiceAPI::ThreadGetByContact(application, pdata->result->ID);
-                if (thread) {
-                    application->switchWindow(gui::name::window::thread_view,
-                                              std::make_unique<SMSThreadData>(std::move(thread)));
-                }
-                else {
+            auto pdata = dynamic_cast<PhonebookSearchReuqest *>(data);
+            if (pdata != nullptr) {
+                using db::query::ThreadGetByContactID;
+                auto query = std::make_unique<ThreadGetByContactID>(pdata->result->ID);
+                query->setQueryListener(db::QueryCallback::fromFunction([app = application](auto response) {
+                    using db::query::ThreadGetByContactIDResult;
+                    const auto result = dynamic_cast<ThreadGetByContactIDResult *>(response);
+                    if ((result != nullptr) && result->getRecord().has_value()) {
+                        auto thread = result->getRecord().value();
+                        app->switchWindow(gui::name::window::thread_view,
+                                          std::make_unique<SMSThreadData>(std::make_unique<ThreadRecord>(thread)));
+                        return true;
+                    }
                     LOG_FATAL("No thread and thread not created!");
-                }
+                    return false;
+                }));
+                DBServiceAPI::GetQuery(application, db::Interface::Name::Contact, std::move(query));
             }
         }
 
@@ -128,24 +138,22 @@ namespace gui
     {
         auto app = dynamic_cast<app::ApplicationMessages *>(application);
         assert(app);
+
         // check if any of the lower inheritance onInput methods catch the event
         if (AppWindow::onInput(inputEvent)) {
             return true;
         }
-        else {
-            if (inputEvent.state == InputEvent::State::keyReleasedShort) {
-                switch (inputEvent.keyCode) {
-                case gui::KeyCode::KEY_LEFT:
-                    application->switchWindow(gui::name::window::new_sms, nullptr);
-                    return true;
-                case gui::KeyCode::KEY_RIGHT: {
-                    app->switchWindow(gui::name::window::thread_sms_search, nullptr);
-                    return true;
-                } break;
-                default:
-                    LOG_DEBUG("SMS main window not handled key: %d", static_cast<int>(inputEvent.keyCode));
-                    break;
-                }
+        if (inputEvent.state == InputEvent::State::keyReleasedShort) {
+            switch (inputEvent.keyCode) {
+            case gui::KeyCode::KEY_LEFT:
+                application->switchWindow(gui::name::window::new_sms, nullptr);
+                return true;
+            case gui::KeyCode::KEY_RIGHT:
+                app->switchWindow(gui::name::window::thread_sms_search, nullptr);
+                return true;
+            default:
+                LOG_DEBUG("SMS main window not handled key: %d", static_cast<int>(inputEvent.keyCode));
+                break;
             }
         }
         return false;
@@ -157,16 +165,12 @@ namespace gui
         if (msgNotification != nullptr) {
             if (msgNotification->interface == db::Interface::Name::SMSThread ||
                 msgNotification->interface == db::Interface::Name::SMS) {
-
                 if (msgNotification->dataModified()) {
-
                     rebuild();
-
                     return true;
                 }
             }
         }
         return false;
-    } // namespace gui
-
-} /* namespace gui */
+    }
+} // namespace gui
diff --git a/module-apps/application-messages/windows/MessagesMainWindow.hpp b/module-apps/application-messages/windows/MessagesMainWindow.hpp
index 458b6a88a..1dea68c82 100644
--- a/module-apps/application-messages/windows/MessagesMainWindow.hpp
+++ b/module-apps/application-messages/windows/MessagesMainWindow.hpp
@@ -17,27 +17,23 @@ namespace gui
     class MessagesMainWindow : public AppWindow
     {
       protected:
-        Image *leftArrowImage  = nullptr;
-        Image *rightArrowImage = nullptr;
-        Image *newMessageImage = nullptr;
-        Image *searchImage     = nullptr;
-
+        Image *leftArrowImage                      = nullptr;
+        Image *rightArrowImage                     = nullptr;
+        Image *newMessageImage                     = nullptr;
+        Image *searchImage                         = nullptr;
+        Icon *emptyListIcon                        = nullptr;
         std::shared_ptr<ThreadsModel> threadsModel = nullptr;
-        gui::ListView *list                      = nullptr;
-
-        Icon *emptyListIcon = nullptr;
+        gui::ListView *list                        = nullptr;
 
       public:
-        MessagesMainWindow(app::Application *app);
+        explicit MessagesMainWindow(app::Application *app);
 
         // virtual methods
         bool onInput(const InputEvent &inputEvent) override;
         void onBeforeShow(ShowMode mode, SwitchData *data) override;
-
         bool onDatabaseMessage(sys::Message *msgl) override;
 
         void rebuild() override;
         void buildInterface() override;
     };
-
 } /* namespace gui */
diff --git a/module-apps/application-messages/windows/OptionsMessages.cpp b/module-apps/application-messages/windows/OptionsMessages.cpp
index 932cc4178..8dcb1f920 100644
--- a/module-apps/application-messages/windows/OptionsMessages.cpp
+++ b/module-apps/application-messages/windows/OptionsMessages.cpp
@@ -44,7 +44,7 @@ std::list<gui::Item *> smsWindowOptions(app::ApplicationMessages *app, const SMS
         }}.build());
     options.push_back(gui::Option{
         UTF8(utils::localize.get("sms_delete_message")), [=](gui::Item &item) {
-            return app->removeSMS(record);
+            return app->removeSms(record);
         }}.build());
 
     return options;
diff --git a/module-apps/application-messages/windows/ThreadWindowOptions.cpp b/module-apps/application-messages/windows/ThreadWindowOptions.cpp
index 6e14a32a9..b72695056 100644
--- a/module-apps/application-messages/windows/ThreadWindowOptions.cpp
+++ b/module-apps/application-messages/windows/ThreadWindowOptions.cpp
@@ -34,7 +34,7 @@ std::list<gui::Option> threadWindowOptions(app::ApplicationMessages *app, const
 
     options.emplace_back(gui::Option{utils::localize.get("sms_delete_conversation"), [=](gui::Item &item) {
                                          LOG_INFO("Removing sms thread!");
-                                         return app->removeSMS_thread(record);
+                                         return app->removeSmsThread(record);
                                      }});
 
     // TODO
diff --git a/module-apps/application-phonebook/models/PhonebookModel.cpp b/module-apps/application-phonebook/models/PhonebookModel.cpp
index 68529a25b..076fd904d 100644
--- a/module-apps/application-phonebook/models/PhonebookModel.cpp
+++ b/module-apps/application-phonebook/models/PhonebookModel.cpp
@@ -45,7 +45,8 @@ auto PhonebookModel::requestRecordsCount() -> unsigned int
 void PhonebookModel::requestRecords(const uint32_t offset, const uint32_t limit)
 {
     auto query = std::make_unique<db::query::ContactGet>(offset, limit, queryFilter, queryGroupFilter);
-    query->setQueryListener(this);
+    query->setQueryListener(
+        db::QueryCallback::fromFunction([this](auto response) { return handleQueryResponse(response); }));
     DBServiceAPI::GetQuery(application, db::Interface::Name::Contact, std::move(query));
 }
 
diff --git a/module-apps/application-phonebook/models/PhonebookModel.hpp b/module-apps/application-phonebook/models/PhonebookModel.hpp
index 5a01943bc..fc8f6269a 100644
--- a/module-apps/application-phonebook/models/PhonebookModel.hpp
+++ b/module-apps/application-phonebook/models/PhonebookModel.hpp
@@ -13,7 +13,7 @@
 
 #include <string>
 
-class PhonebookModel : public app::DatabaseModel<ContactRecord>, public gui::ListItemProvider, public db::QueryListener
+class PhonebookModel : public app::DatabaseModel<ContactRecord>, public gui::ListItemProvider
 {
   private:
     std::string queryFilter;
@@ -31,8 +31,7 @@ class PhonebookModel : public app::DatabaseModel<ContactRecord>, public gui::Lis
     [[nodiscard]] auto getMinimalItemHeight() const -> unsigned int override;
     auto getItem(gui::Order order) -> gui::ListItem * override;
 
-    // virtual method for db::QueryListener
-    auto handleQueryResponse(db::QueryResult *) -> bool override;
+    auto handleQueryResponse(db::QueryResult *) -> bool;
 
     [[nodiscard]] auto requestRecordsCount() -> unsigned int override;
 
diff --git a/module-db/CMakeLists.txt b/module-db/CMakeLists.txt
index 21622650b..d896942c6 100644
--- a/module-db/CMakeLists.txt
+++ b/module-db/CMakeLists.txt
@@ -78,7 +78,10 @@ set(SOURCES
         queries/sms/QuerySMSTemplateGetCount.cpp
         queries/sms/QuerySMSTemplateRemove.cpp
         queries/sms/QuerySMSTemplateUpdate.cpp
+        queries/sms/QueryThreadGetByID.cpp
         queries/sms/QueryThreadGetByNumber.cpp
+        queries/sms/QueryThreadGetByContactID.cpp
+        queries/sms/QueryThreadRemove.cpp
         queries/calllog/QueryCalllogSetAllRead.cpp
         queries/calllog/QueryCalllogGet.cpp
         queries/calllog/QueryCalllogGetCount.cpp
diff --git a/module-db/Common/Query.cpp b/module-db/Common/Query.cpp
index 0e0dc383e..94eb70c77 100644
--- a/module-db/Common/Query.cpp
+++ b/module-db/Common/Query.cpp
@@ -5,29 +5,53 @@
 
 using namespace db;
 
-Query::Query(Type type, QueryListener *listener) : type(type), queryListener(listener)
+std::unique_ptr<QueryCallback> QueryCallback::fromFunction(QueryCallbackFunction &&callbackFunction)
+{
+    return std::make_unique<QueryCallback>(std::move(callbackFunction));
+}
+
+QueryCallback::QueryCallback(QueryCallbackFunction &&_callback) : callback{std::move(_callback)}
+{}
+
+bool QueryCallback::handleQueryResponse(QueryResult *response)
+{
+    return callback(response);
+}
+
+EndpointListener::EndpointListener(EndpointQueryCallbackFunction &&_callback, Context &_context)
+    : callback{std::move(_callback)}, context{_context}
+{}
+
+bool EndpointListener::handleQueryResponse(db::QueryResult *response)
+{
+    if (callback) {
+        LOG_DEBUG("Executing callback...");
+        const auto ret = callback(response, context);
+        LOG_DEBUG("Callback finished");
+        return ret;
+    }
+
+    LOG_ERROR("callback is nullptr!");
+    return false;
+}
+
+Query::Query(Type type) : type(type)
 {}
 
 QueryListener *Query::getQueryListener() const noexcept
 {
-    return queryListener;
+    return queryListener.get();
 }
 
-void Query::setQueryListener(QueryListener *listener) noexcept
+void Query::setQueryListener(std::unique_ptr<QueryListener> &&listener) noexcept
 {
-    queryListener = listener;
-}
-
-void Query::setQueryListener(std::unique_ptr<QueryListener> listener) noexcept
-{
-    queryListenerUniqueptr = std::move(listener);
-    queryListener          = dynamic_cast<QueryListener *>(queryListenerUniqueptr.get());
+    queryListener = std::move(listener);
 }
 
 QueryResult::QueryResult(std::shared_ptr<Query> requestQuery) : requestQuery(std::move(requestQuery))
 {}
 
-void QueryResult::setRequestQuery(std::shared_ptr<Query> requestQueryToSet)
+void QueryResult::setRequestQuery(const std::shared_ptr<Query> &requestQueryToSet)
 {
     requestQuery = requestQueryToSet;
 }
@@ -39,14 +63,13 @@ std::shared_ptr<Query> QueryResult::getRequestQuery() const noexcept
 
 bool QueryResult::hasListener() const noexcept
 {
-    return !(requestQuery == nullptr || requestQuery->getQueryListener() == nullptr);
+    return requestQuery && (requestQuery->getQueryListener() != nullptr);
 }
 
 bool QueryResult::handle()
 {
-    if (requestQuery == nullptr || requestQuery->getQueryListener() == nullptr) {
+    if (!hasListener()) {
         throw std::runtime_error("No listener to handle query");
     }
-
     return requestQuery->getQueryListener()->handleQueryResponse(this);
 }
diff --git a/module-db/Common/Query.hpp b/module-db/Common/Query.hpp
index 527b71c33..3f56ed04d 100644
--- a/module-db/Common/Query.hpp
+++ b/module-db/Common/Query.hpp
@@ -10,41 +10,42 @@ using namespace parserFSM;
 
 namespace db
 {
-    class QueryResult;
+    class QueryResult; // Forward declaration
+    using QueryCallbackFunction         = std::function<bool(db::QueryResult *)>;
+    using EndpointQueryCallbackFunction = std::function<bool(db::QueryResult *, Context &)>;
 
     class QueryListener
     {
       public:
-        virtual bool handleQueryResponse(QueryResult *) = 0;
-        virtual ~QueryListener()                        = default;
+        virtual ~QueryListener() = default;
+
+        virtual bool handleQueryResponse(QueryResult *response) = 0;
     };
 
-    using QueryCallback = std::function<bool(db::QueryResult *, Context &)>;
+    class QueryCallback : public db::QueryListener
+    {
+      public:
+        static std::unique_ptr<QueryCallback> fromFunction(QueryCallbackFunction &&callbackFunction);
+
+        explicit QueryCallback(QueryCallbackFunction &&_callback);
+
+        bool handleQueryResponse(QueryResult *response) override;
+
+      private:
+        QueryCallbackFunction callback;
+    };
 
     class EndpointListener : public db::QueryListener
     {
-      private:
-        Context context = Context();
-
       public:
-        EndpointListener(QueryCallback callback, Context &context)
-            : context(std::move(context)), callback(std::move(callback)){};
-        EndpointListener() : callback(nullptr){};
-        ~EndpointListener()    = default;
-        QueryCallback callback = nullptr;
-        auto handleQueryResponse(db::QueryResult *result) -> bool override
-        {
-            if (callback != nullptr) {
-                LOG_DEBUG("Executing callback...");
-                auto ret = callback(result, context);
-                LOG_DEBUG("Callback finished");
-                return ret;
-            }
-            else {
-                LOG_ERROR("callback is nullptr!");
-                return false;
-            }
-        }
+        EndpointListener() = default;
+        EndpointListener(EndpointQueryCallbackFunction &&_callback, Context &_context);
+
+        bool handleQueryResponse(db::QueryResult *result) override;
+
+      private:
+        EndpointQueryCallbackFunction callback;
+        Context context;
     };
 
     /// virtual query input interface
@@ -59,34 +60,31 @@ namespace db
             Delete
         };
 
-        Query() = delete;
-        Query(Type type, QueryListener *listener = nullptr);
+        explicit Query(Type type);
         virtual ~Query() = default;
 
         QueryListener *getQueryListener() const noexcept;
-        void setQueryListener(QueryListener *queryListener) noexcept;
-        void setQueryListener(std::unique_ptr<QueryListener> listener) noexcept;
-
-        const Type type;
+        void setQueryListener(std::unique_ptr<QueryListener> &&listener) noexcept;
 
         [[nodiscard]] virtual auto debugInfo() const -> std::string = 0;
 
+        const Type type;
+
       private:
-        QueryListener *queryListener                          = nullptr;
-        std::unique_ptr<QueryListener> queryListenerUniqueptr = nullptr;
+        std::unique_ptr<QueryListener> queryListener;
     };
 
     /// virtual query output (result) interface
     class QueryResult
     {
       public:
-        QueryResult(std::shared_ptr<Query> requestQuery = nullptr);
+        explicit QueryResult(std::shared_ptr<Query> requestQuery = nullptr);
         virtual ~QueryResult() = default;
 
-        void setRequestQuery(std::shared_ptr<Query> requestQueryToSet);
+        void setRequestQuery(const std::shared_ptr<Query> &requestQueryToSet);
         std::shared_ptr<Query> getRequestQuery() const noexcept;
 
-        virtual bool handle();
+        bool handle();
 
         [[nodiscard]] bool hasListener() const noexcept;
         [[nodiscard]] virtual auto debugInfo() const -> std::string = 0;
diff --git a/module-db/Interface/ThreadRecord.cpp b/module-db/Interface/ThreadRecord.cpp
index afbd26527..9c4902ad7 100644
--- a/module-db/Interface/ThreadRecord.cpp
+++ b/module-db/Interface/ThreadRecord.cpp
@@ -2,7 +2,10 @@
 #include "SMSRecord.hpp"
 #include "ContactRecord.hpp"
 
+#include <queries/sms/QueryThreadGetByID.hpp>
 #include <queries/sms/QueryThreadGetByNumber.hpp>
+#include <queries/sms/QueryThreadGetByContactID.hpp>
+#include <queries/sms/QueryThreadRemove.hpp>
 
 #include <cassert>
 #include <log/log.hpp>
@@ -175,12 +178,35 @@ std::unique_ptr<db::QueryResult> ThreadRecordInterface::runQuery(std::shared_ptr
         return response;
     }
 
+    if (const auto local_query = dynamic_cast<const db::query::ThreadGetByID *>(query.get())) {
+        const auto ret = GetByID(local_query->id);
+        auto response  = std::make_unique<db::query::ThreadGetByIDResult>(
+            ret.isValid() ? std::optional<ThreadRecord>{ret} : std::nullopt);
+        response->setRequestQuery(query);
+        return response;
+    }
+
     if (const auto local_query = dynamic_cast<const db::query::ThreadGetByNumber *>(query.get())) {
         auto response = std::make_unique<db::query::ThreadGetByNumberResult>(GetByNumber(local_query->getNumber()));
         response->setRequestQuery(query);
         return response;
     }
 
+    if (const auto local_query = dynamic_cast<const db::query::ThreadGetByContactID *>(query.get())) {
+        const auto thread = GetByContact(local_query->id);
+        auto response     = std::make_unique<db::query::ThreadGetByContactIDResult>(
+            thread.isValid() ? std::optional<ThreadRecord>(thread) : std::nullopt);
+        response->setRequestQuery(query);
+        return response;
+    }
+
+    if (const auto local_query = dynamic_cast<const db::query::ThreadRemove *>(query.get())) {
+        const auto ret = RemoveByID(local_query->id);
+        auto response  = std::make_unique<db::query::ThreadRemoveResult>(ret);
+        response->setRequestQuery(query);
+        return response;
+    }
+
     return nullptr;
 }
 
diff --git a/module-db/queries/sms/QueryThreadGetByContactID.cpp b/module-db/queries/sms/QueryThreadGetByContactID.cpp
new file mode 100644
index 000000000..6b445d7e0
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadGetByContactID.cpp
@@ -0,0 +1,27 @@
+#include "QueryThreadGetByContactID.hpp"
+
+using namespace std::string_literals;
+
+namespace db::query
+{
+    ThreadGetByContactID::ThreadGetByContactID(unsigned int _id) : Query{Query::Type::Read}, id{_id}
+    {}
+
+    std::string ThreadGetByContactID::debugInfo() const
+    {
+        return "ThreadGetByContactID"s;
+    }
+
+    ThreadGetByContactIDResult::ThreadGetByContactIDResult(const std::optional<ThreadRecord> &_record) : record{_record}
+    {}
+
+    std::optional<ThreadRecord> ThreadGetByContactIDResult::getRecord() const noexcept
+    {
+        return record;
+    }
+
+    std::string ThreadGetByContactIDResult::debugInfo() const
+    {
+        return "ThreadGetByContactIDResult"s;
+    }
+} // namespace db::query
diff --git a/module-db/queries/sms/QueryThreadGetByContactID.hpp b/module-db/queries/sms/QueryThreadGetByContactID.hpp
new file mode 100644
index 000000000..330e06d60
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadGetByContactID.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+#include <optional>
+
+#include <Common/Query.hpp>
+#include <Interface/ThreadRecord.hpp>
+
+namespace db::query
+{
+    class ThreadGetByContactID : public Query
+    {
+      public:
+        explicit ThreadGetByContactID(unsigned int _id);
+
+        [[nodiscard]] std::string debugInfo() const override;
+
+        unsigned int id;
+    };
+
+    class ThreadGetByContactIDResult : public QueryResult
+    {
+      public:
+        explicit ThreadGetByContactIDResult(const std::optional<ThreadRecord> &_record);
+
+        std::optional<ThreadRecord> getRecord() const noexcept;
+        [[nodiscard]] std::string debugInfo() const override;
+
+      private:
+        std::optional<ThreadRecord> record;
+    };
+} // namespace db::query
diff --git a/module-db/queries/sms/QueryThreadGetByID.cpp b/module-db/queries/sms/QueryThreadGetByID.cpp
new file mode 100644
index 000000000..5a8d825b2
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadGetByID.cpp
@@ -0,0 +1,27 @@
+#include "QueryThreadGetByID.hpp"
+
+using namespace std::string_literals;
+
+namespace db::query
+{
+    ThreadGetByID::ThreadGetByID(unsigned int _id) : Query{Query::Type::Read}, id{_id}
+    {}
+
+    std::string ThreadGetByID::debugInfo() const
+    {
+        return "ThreadGetByID"s;
+    }
+
+    ThreadGetByIDResult::ThreadGetByIDResult(const std::optional<ThreadRecord> &_record) : record{_record}
+    {}
+
+    std::optional<ThreadRecord> ThreadGetByIDResult::getRecord() const noexcept
+    {
+        return record;
+    }
+
+    std::string ThreadGetByIDResult::debugInfo() const
+    {
+        return "ThreadGetByIDResult"s;
+    }
+} // namespace db::query
diff --git a/module-db/queries/sms/QueryThreadGetByID.hpp b/module-db/queries/sms/QueryThreadGetByID.hpp
new file mode 100644
index 000000000..784ab0c1c
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadGetByID.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+#include <optional>
+
+#include <Common/Query.hpp>
+#include <Interface/ThreadRecord.hpp>
+
+namespace db::query
+{
+    class ThreadGetByID : public Query
+    {
+      public:
+        explicit ThreadGetByID(unsigned int _id);
+
+        [[nodiscard]] std::string debugInfo() const override;
+
+        unsigned int id;
+    };
+
+    class ThreadGetByIDResult : public QueryResult
+    {
+      public:
+        explicit ThreadGetByIDResult(const std::optional<ThreadRecord> &_record);
+
+        std::optional<ThreadRecord> getRecord() const noexcept;
+        [[nodiscard]] std::string debugInfo() const override;
+
+      private:
+        std::optional<ThreadRecord> record;
+    };
+} // namespace db::query
diff --git a/module-db/queries/sms/QueryThreadRemove.cpp b/module-db/queries/sms/QueryThreadRemove.cpp
new file mode 100644
index 000000000..d7076ef8f
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadRemove.cpp
@@ -0,0 +1,27 @@
+#include "QueryThreadRemove.hpp"
+
+using namespace std::string_literals;
+
+namespace db::query
+{
+    ThreadRemove::ThreadRemove(unsigned int _id) : Query{Query::Type::Delete}, id{_id}
+    {}
+
+    std::string ThreadRemove::debugInfo() const
+    {
+        return "ThreadRemove"s;
+    }
+
+    ThreadRemoveResult::ThreadRemoveResult(bool _result) : result{_result}
+    {}
+
+    bool ThreadRemoveResult::success() const noexcept
+    {
+        return result;
+    }
+
+    std::string ThreadRemoveResult::debugInfo() const
+    {
+        return "ThreadRemoveResult"s;
+    }
+} // namespace db::query
diff --git a/module-db/queries/sms/QueryThreadRemove.hpp b/module-db/queries/sms/QueryThreadRemove.hpp
new file mode 100644
index 000000000..403fe9c0a
--- /dev/null
+++ b/module-db/queries/sms/QueryThreadRemove.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+
+#include <Common/Query.hpp>
+#include <Interface/ThreadRecord.hpp>
+
+namespace db::query
+{
+    class ThreadRemove : public Query
+    {
+      public:
+        explicit ThreadRemove(unsigned int _id);
+
+        [[nodiscard]] std::string debugInfo() const override;
+
+        unsigned int id;
+    };
+
+    class ThreadRemoveResult : public QueryResult
+    {
+      public:
+        explicit ThreadRemoveResult(bool _result);
+
+        [[nodiscard]] bool success() const noexcept;
+        [[nodiscard]] std::string debugInfo() const override;
+
+      private:
+        bool result;
+    };
+} // namespace db::query
diff --git a/module-db/tests/ThreadRecord_tests.cpp b/module-db/tests/ThreadRecord_tests.cpp
index 0bf140ba5..9bcb0a140 100644
--- a/module-db/tests/ThreadRecord_tests.cpp
+++ b/module-db/tests/ThreadRecord_tests.cpp
@@ -1,4 +1,3 @@
-
 #include <catch2/catch.hpp>
 
 #include "Database/Database.hpp"
@@ -9,6 +8,9 @@
 #include "Interface/ThreadRecord.hpp"
 #include "queries/sms/QuerySmsThreadMarkAsRead.hpp"
 #include "queries/sms/QuerySMSSearch.hpp"
+#include "queries/sms/QueryThreadGetByID.hpp"
+#include "queries/sms/QueryThreadGetByContactID.hpp"
+#include "queries/sms/QueryThreadRemove.hpp"
 #include "vfs.hpp"
 
 #include <algorithm>
@@ -108,6 +110,25 @@ TEST_CASE("Thread Record tests")
         }
     }
 
+    SECTION("Get record by id with query")
+    {
+        auto query  = std::make_shared<db::query::ThreadGetByID>(1);
+        auto ret    = threadRecordInterface1.runQuery(query);
+        auto result = dynamic_cast<db::query::ThreadGetByIDResult *>(ret.get());
+
+        REQUIRE(result->getRecord().has_value());
+    }
+
+    SECTION("Get record by contact id")
+    {
+        auto query  = std::make_shared<db::query::ThreadGetByContactID>(contactIDTest);
+        auto ret    = threadRecordInterface1.runQuery(query);
+        auto result = dynamic_cast<db::query::ThreadGetByContactIDResult *>(ret.get());
+
+        REQUIRE(result->getRecord().has_value());
+        REQUIRE(result->getRecord()->contactID == contactIDTest);
+    }
+
     SECTION("Remove records one by one")
     {
         REQUIRE(threadRecordInterface1.RemoveByID(1));
@@ -117,6 +138,22 @@ TEST_CASE("Thread Record tests")
         REQUIRE(threadRecordInterface1.GetCount() == 0);
     }
 
+    SECTION("Remove records with query")
+    {
+        auto query1  = std::make_shared<db::query::ThreadRemove>(1);
+        auto ret1    = threadRecordInterface1.runQuery(query1);
+        auto result1 = dynamic_cast<db::query::ThreadRemoveResult *>(ret1.get());
+        REQUIRE(result1->success());
+
+        auto query2  = std::make_shared<db::query::ThreadRemove>(2);
+        auto ret2    = threadRecordInterface1.runQuery(query2);
+        auto result2 = dynamic_cast<db::query::ThreadRemoveResult *>(ret2.get());
+        REQUIRE(result2->success());
+
+        // SMS database should not contain any records
+        REQUIRE(threadRecordInterface1.GetCount() == 0);
+    }
+
     SECTION("Test updating record")
     {
         // REQUIRE(threadRecordInterface1.Add(recordIN));