Merge branch 'master' into f/batch-send

src/Simplex/Chat/Archive.hs

@@ -17,12 +17,14 @@ import qualified Codec.Archive.Zip as Z
 import Control.Monad
 import Control.Monad.Except
 import Control.Monad.Reader
+import qualified Data.ByteArray as BA
 import Data.Functor (($>))
+import Data.Maybe (fromMaybe)
 import qualified Data.Text as T
 import qualified Database.SQLite3 as SQL
 import Simplex.Chat.Controller
 import Simplex.Messaging.Agent.Client (agentClientStore)
-import Simplex.Messaging.Agent.Store.SQLite (SQLiteStore (..), closeSQLiteStore, sqlString)
+import Simplex.Messaging.Agent.Store.SQLite (SQLiteStore (..), closeSQLiteStore, keyString, sqlString, storeKey)
 import Simplex.Messaging.Util
 import System.FilePath
 import UnliftIO.Directory
@@ -118,7 +120,7 @@ storageFiles = do
   pure StorageFiles {chatStore, agentStore, filesPath}
 
 sqlCipherExport :: forall m. ChatMonad m => DBEncryptionConfig -> m ()
-sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = DBEncryptionKey key'} =
+sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = DBEncryptionKey key', keepKey} =
   when (key /= key') $ do
     fs <- storageFiles
     checkFile `withDBs` fs
@@ -134,15 +136,15 @@ sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = D
     backup f = copyFile f (f <> ".bak")
     restore f = copyFile (f <> ".bak") f
     checkFile f = unlessM (doesFileExist f) $ throwDBError $ DBErrorNoFile f
-    checkEncryption SQLiteStore {dbEncrypted} = do
-      enc <- readTVarIO dbEncrypted
-      when (enc && null key) $ throwDBError DBErrorEncrypted
-      when (not enc && not (null key)) $ throwDBError DBErrorPlaintext
+    checkEncryption SQLiteStore {dbKey} = do
+      enc <- maybe True (not . BA.null) <$> readTVarIO dbKey
+      when (enc && BA.null key) $ throwDBError DBErrorEncrypted
+      when (not enc && not (BA.null key)) $ throwDBError DBErrorPlaintext
     exported = (<> ".exported")
     removeExported f = whenM (doesFileExist $ exported f) $ removeFile (exported f)
-    moveExported SQLiteStore {dbFilePath = f, dbEncrypted} = do
+    moveExported SQLiteStore {dbFilePath = f, dbKey} = do
       renameFile (exported f) f
-      atomically $ writeTVar dbEncrypted $ not (null key')
+      atomically $ writeTVar dbKey $ storeKey key' (fromMaybe False keepKey)
     export f = do
       withDB f (`SQL.exec` exportSQL) DBErrorExport
       withDB (exported f) (`SQL.exec` testSQL) DBErrorOpen
@@ -161,7 +163,7 @@ sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = D
         exportSQL =
           T.unlines $
             keySQL key
-              <> [ "ATTACH DATABASE " <> sqlString (f <> ".exported") <> " AS exported KEY " <> sqlString key' <> ";",
+              <> [ "ATTACH DATABASE " <> sqlString (T.pack f <> ".exported") <> " AS exported KEY " <> keyString key' <> ";",
                    "SELECT sqlcipher_export('exported');",
                    "DETACH DATABASE exported;"
                  ]
@@ -172,7 +174,7 @@ sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = D
                    "PRAGMA secure_delete = ON;",
                    "SELECT count(*) FROM sqlite_master;"
                  ]
-        keySQL k = ["PRAGMA key = " <> sqlString k <> ";" | not (null k)]
+        keySQL k = ["PRAGMA key = " <> keyString k <> ";" | not (BA.null k)]
 
 withDBs :: Monad m => (FilePath -> m b) -> StorageFiles -> m b
 action `withDBs` StorageFiles {chatStore, agentStore} = action (dbFilePath chatStore) >> action (dbFilePath agentStore)

src/Simplex/Chat/Controller.hs

@@ -29,6 +29,8 @@ import qualified Data.Aeson.TH as JQ
 import qualified Data.Aeson.Types as JT
 import qualified Data.Attoparsec.ByteString.Char8 as A
 import Data.Bifunctor (first)
+import Data.ByteArray (ScrubbedBytes)
+import qualified Data.ByteArray as BA
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
 import Data.Char (ord)
@@ -39,7 +41,9 @@ import Data.Map.Strict (Map)
 import qualified Data.Map.Strict as M
 import Data.String
 import Data.Text (Text)
+import Data.Text.Encoding (decodeLatin1)
 import Data.Time (NominalDiffTime, UTCTime)
+import Data.Time.Clock.System (systemToUTCTime)
 import Data.Version (showVersion)
 import Data.Word (Word16)
 import Language.Haskell.TH (Exp, Q, runIO)
@@ -69,7 +73,7 @@ import qualified Simplex.Messaging.Crypto.File as CF
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Notifications.Protocol (DeviceToken (..), NtfTknStatus)
 import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON, parseAll, parseString, sumTypeJSON)
-import Simplex.Messaging.Protocol (AProtoServerWithAuth, AProtocolType (..), CorrId, MsgFlags, NtfServer, ProtoServerWithAuth, ProtocolTypeI, QueueId, SProtocolType, SubscriptionMode (..), UserProtocol, XFTPServerWithAuth, userProtocol)
+import Simplex.Messaging.Protocol (AProtoServerWithAuth, AProtocolType (..), CorrId, NtfServer, ProtoServerWithAuth, ProtocolTypeI, QueueId, SMPMsgMeta (..), SProtocolType, SubscriptionMode (..), UserProtocol, XFTPServerWithAuth, userProtocol)
 import Simplex.Messaging.TMap (TMap)
 import Simplex.Messaging.Transport (TLS, simplexMQVersion)
 import Simplex.Messaging.Transport.Client (TransportHost)
@@ -230,7 +234,7 @@ data ChatCommand
   | DeleteUser UserName Bool (Maybe UserPwd)
   | StartChat {subscribeConnections :: Bool, enableExpireChatItems :: Bool, startXFTPWorkers :: Bool}
   | APIStopChat
-  | APIActivateChat
+  | APIActivateChat {restoreChat :: Bool}
   | APISuspendChat {suspendTimeout :: Int}
   | ResubscribeAllConnections
   | SetTempFolder FilePath
@@ -455,7 +459,7 @@ allowRemoteCommand :: ChatCommand -> Bool -- XXX: consider using Relay/Block/For
 allowRemoteCommand = \case
   StartChat {} -> False
   APIStopChat -> False
-  APIActivateChat -> False
+  APIActivateChat _ -> False
   APISuspendChat _ -> False
   QuitChat -> False
   SetTempFolder _ -> False
@@ -656,7 +660,8 @@ data ChatResponse
   | CRUserContactLinkSubError {chatError :: ChatError} -- TODO delete
   | CRNtfTokenStatus {status :: NtfTknStatus}
   | CRNtfToken {token :: DeviceToken, status :: NtfTknStatus, ntfMode :: NotificationsMode}
-  | CRNtfMessages {user_ :: Maybe User, connEntity :: Maybe ConnectionEntity, msgTs :: Maybe UTCTime, ntfMessages :: [NtfMsgInfo]}
+  | CRNtfMessages {user_ :: Maybe User, connEntity_ :: Maybe ConnectionEntity, msgTs :: Maybe UTCTime, ntfMessages :: [NtfMsgInfo]}
+  | CRNtfMessage {user :: User, connEntity :: ConnectionEntity, ntfMessage :: NtfMsgInfo}
   | CRContactConnectionDeleted {user :: User, connection :: PendingContactConnection}
   | CRRemoteHostList {remoteHosts :: [RemoteHostInfo]}
   | CRCurrentRemoteHost {remoteHost_ :: Maybe RemoteHostInfo}
@@ -848,17 +853,17 @@ deriving instance Show AUserProtoServers
 data ArchiveConfig = ArchiveConfig {archivePath :: FilePath, disableCompression :: Maybe Bool, parentTempDirectory :: Maybe FilePath}
   deriving (Show)
 
-data DBEncryptionConfig = DBEncryptionConfig {currentKey :: DBEncryptionKey, newKey :: DBEncryptionKey}
+data DBEncryptionConfig = DBEncryptionConfig {currentKey :: DBEncryptionKey, newKey :: DBEncryptionKey, keepKey :: Maybe Bool}
   deriving (Show)
 
-newtype DBEncryptionKey = DBEncryptionKey String
+newtype DBEncryptionKey = DBEncryptionKey ScrubbedBytes
   deriving (Show)
 
 instance IsString DBEncryptionKey where fromString = parseString $ parseAll strP
 
 instance StrEncoding DBEncryptionKey where
-  strEncode (DBEncryptionKey s) = B.pack s
-  strP = DBEncryptionKey . B.unpack <$> A.takeWhile (\c -> c /= ' ' && ord c >= 0x21 && ord c <= 0x7E)
+  strEncode (DBEncryptionKey s) = BA.convert s
+  strP = DBEncryptionKey . BA.convert <$> A.takeWhile (\c -> c /= ' ' && ord c >= 0x21 && ord c <= 0x7E)
 
 instance FromJSON DBEncryptionKey where
   parseJSON = strParseJSON "DBEncryptionKey"
@@ -923,9 +928,12 @@ data XFTPFileConfig = XFTPFileConfig
 defaultXFTPFileConfig :: XFTPFileConfig
 defaultXFTPFileConfig = XFTPFileConfig {minFileSize = 0}
 
-data NtfMsgInfo = NtfMsgInfo {msgTs :: UTCTime, msgFlags :: MsgFlags}
+data NtfMsgInfo = NtfMsgInfo {msgId :: Text, msgTs :: UTCTime}
   deriving (Show)
 
+ntfMsgInfo :: SMPMsgMeta -> NtfMsgInfo
+ntfMsgInfo SMPMsgMeta {msgId, msgTs} = NtfMsgInfo {msgId = decodeLatin1 $ strEncode msgId, msgTs = systemToUTCTime msgTs}
+
 crNtfToken :: (DeviceToken, NtfTknStatus, NotificationsMode) -> ChatResponse
 crNtfToken (token, status, ntfMode) = CRNtfToken {token, status, ntfMode}
 

src/Simplex/Chat/Core.hs

@@ -22,7 +22,7 @@ simplexChatCore cfg@ChatConfig {confirmMigrations, testView} opts@ChatOpts {core
       withGlobalLogging logCfg initRun
     _ -> initRun
   where
-    initRun = createChatDatabase dbFilePrefix dbKey confirmMigrations >>= either exit run
+    initRun = createChatDatabase dbFilePrefix dbKey False confirmMigrations >>= either exit run
     exit e = do
       putStrLn $ "Error opening database: " <> show e
       exitFailure

src/Simplex/Chat/Migrations/M20231207_chat_list_pagination.hs

@@ -26,9 +26,6 @@ CREATE INDEX idx_contacts_chat_ts ON contacts(user_id, chat_ts);
 CREATE INDEX idx_groups_chat_ts ON groups(user_id, chat_ts);
 CREATE INDEX idx_contact_requests_updated_at ON contact_requests(user_id, updated_at);
 CREATE INDEX idx_connections_updated_at ON connections(user_id, updated_at);
-
-CREATE INDEX idx_chat_items_contact_id_item_status ON chat_items(contact_id, item_status);
-CREATE INDEX idx_chat_items_group_id_item_status ON chat_items(group_id, item_status);
 |]
 
 down_m20231207_chat_list_pagination :: Query
@@ -38,7 +35,4 @@ DROP INDEX idx_contacts_chat_ts;
 DROP INDEX idx_groups_chat_ts;
 DROP INDEX idx_contact_requests_updated_at;
 DROP INDEX idx_connections_updated_at;
-
-DROP INDEX idx_chat_items_contact_id_item_status;
-DROP INDEX idx_chat_items_group_id_item_status;
 |]

src/Simplex/Chat/Migrations/chat_schema.sql

@@ -802,14 +802,6 @@ CREATE INDEX idx_contact_requests_updated_at ON contact_requests(
   updated_at
 );
 CREATE INDEX idx_connections_updated_at ON connections(user_id, updated_at);
-CREATE INDEX idx_chat_items_contact_id_item_status ON chat_items(
-  contact_id,
-  item_status
-);
-CREATE INDEX idx_chat_items_group_id_item_status ON chat_items(
-  group_id,
-  item_status
-);
 CREATE INDEX idx_msg_deliveries_message_id ON "msg_deliveries"(message_id);
 CREATE INDEX idx_msg_deliveries_agent_ack_cmd_id ON "msg_deliveries"(
   connection_id,

src/Simplex/Chat/Mobile.hs

@@ -15,6 +15,8 @@ import Control.Monad.Reader
 import qualified Data.Aeson as J
 import qualified Data.Aeson.TH as JQ
 import Data.Bifunctor (first)
+import Data.ByteArray (ScrubbedBytes)
+import qualified Data.ByteArray as BA
 import qualified Data.ByteString.Base64.URL as U
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
@@ -44,7 +46,7 @@ import Simplex.Chat.Store.Profiles
 import Simplex.Chat.Types
 import Simplex.Messaging.Agent.Client (agentClientStore)
 import Simplex.Messaging.Agent.Env.SQLite (createAgentStore)
-import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation (..), MigrationError, closeSQLiteStore)
+import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation (..), MigrationError, closeSQLiteStore, reopenSQLiteStore)
 import Simplex.Messaging.Client (defaultNetworkConfig)
 import qualified Simplex.Messaging.Crypto as C
 import Simplex.Messaging.Encoding.String
@@ -70,8 +72,12 @@ $(JQ.deriveToJSON defaultJSON ''APIResponse)
 
 foreign export ccall "chat_migrate_init" cChatMigrateInit :: CString -> CString -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
 
+foreign export ccall "chat_migrate_init_key" cChatMigrateInitKey :: CString -> CString -> CInt -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
+
 foreign export ccall "chat_close_store" cChatCloseStore :: StablePtr ChatController -> IO CString
 
+foreign export ccall "chat_reopen_store" cChatReopenStore :: StablePtr ChatController -> IO CString
+
 foreign export ccall "chat_send_cmd" cChatSendCmd :: StablePtr ChatController -> CString -> IO CJSONString
 
 foreign export ccall "chat_send_remote_cmd" cChatSendRemoteCmd :: StablePtr ChatController -> CInt -> CString -> IO CJSONString
@@ -102,7 +108,10 @@ foreign export ccall "chat_decrypt_file" cChatDecryptFile :: CString -> CString
 
 -- | check / migrate database and initialize chat controller on success
 cChatMigrateInit :: CString -> CString -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
-cChatMigrateInit fp key conf ctrl = do
+cChatMigrateInit fp key = cChatMigrateInitKey fp key 0
+
+cChatMigrateInitKey :: CString -> CString -> CInt -> CString -> Ptr (StablePtr ChatController) -> IO CJSONString
+cChatMigrateInitKey fp key keepKey conf ctrl = do
   -- ensure we are set to UTF-8; iOS does not have locale, and will default to
   -- US-ASCII all the time.
   setLocaleEncoding utf8
@@ -110,10 +119,10 @@ cChatMigrateInit fp key conf ctrl = do
   setForeignEncoding utf8
 
   dbPath <- peekCAString fp
-  dbKey <- peekCAString key
+  dbKey <- BA.convert <$> B.packCString key
   confirm <- peekCAString conf
   r <-
-    chatMigrateInit dbPath dbKey confirm >>= \case
+    chatMigrateInitKey dbPath dbKey (keepKey /= 0) confirm >>= \case
       Right cc -> (newStablePtr cc >>= poke ctrl) $> DBMOk
       Left e -> pure e
   newCStringFromLazyBS $ J.encode r
@@ -121,6 +130,11 @@ cChatMigrateInit fp key conf ctrl = do
 cChatCloseStore :: StablePtr ChatController -> IO CString
 cChatCloseStore cPtr = deRefStablePtr cPtr >>= chatCloseStore >>= newCAString
 
+cChatReopenStore :: StablePtr ChatController -> IO CString
+cChatReopenStore cPtr = do
+  c <- deRefStablePtr cPtr
+  newCAString =<< chatReopenStore c
+
 -- | send command to chat (same syntax as in terminal for now)
 cChatSendCmd :: StablePtr ChatController -> CString -> IO CJSONString
 cChatSendCmd cPtr cCmd = do
@@ -162,13 +176,13 @@ cChatPasswordHash cPwd cSalt = do
 cChatValidName :: CString -> IO CString
 cChatValidName cName = newCString . mkValidName =<< peekCString cName
 
-mobileChatOpts :: String -> String -> ChatOpts
-mobileChatOpts dbFilePrefix dbKey =
+mobileChatOpts :: String -> ChatOpts
+mobileChatOpts dbFilePrefix =
   ChatOpts
     { coreOptions =
         CoreChatOpts
           { dbFilePrefix,
-            dbKey,
+            dbKey = "", -- for API database is already opened, and the key in options is not used
             smpServers = [],
             xftpServers = [],
             networkConfig = defaultNetworkConfig,
@@ -205,8 +219,11 @@ defaultMobileConfig =
 getActiveUser_ :: SQLiteStore -> IO (Maybe User)
 getActiveUser_ st = find activeUser <$> withTransaction st getUsers
 
-chatMigrateInit :: String -> String -> String -> IO (Either DBMigrationResult ChatController)
-chatMigrateInit dbFilePrefix dbKey confirm = runExceptT $ do
+chatMigrateInit :: String -> ScrubbedBytes -> String -> IO (Either DBMigrationResult ChatController)
+chatMigrateInit dbFilePrefix dbKey = chatMigrateInitKey dbFilePrefix dbKey False
+
+chatMigrateInitKey :: String -> ScrubbedBytes -> Bool -> String -> IO (Either DBMigrationResult ChatController)
+chatMigrateInitKey dbFilePrefix dbKey keepKey confirm = runExceptT $ do
   confirmMigrations <- liftEitherWith (const DBMInvalidConfirmation) $ strDecode $ B.pack confirm
   chatStore <- migrate createChatStore (chatStoreFile dbFilePrefix) confirmMigrations
   agentStore <- migrate createAgentStore (agentStoreFile dbFilePrefix) confirmMigrations
@@ -214,10 +231,10 @@ chatMigrateInit dbFilePrefix dbKey confirm = runExceptT $ do
   where
     initialize st db = do
       user_ <- getActiveUser_ st
-      newChatController db user_ defaultMobileConfig (mobileChatOpts dbFilePrefix dbKey)
+      newChatController db user_ defaultMobileConfig (mobileChatOpts dbFilePrefix)
     migrate createStore dbFile confirmMigrations =
       ExceptT $
-        (first (DBMErrorMigration dbFile) <$> createStore dbFile dbKey confirmMigrations)
+        (first (DBMErrorMigration dbFile) <$> createStore dbFile dbKey keepKey confirmMigrations)
           `catch` (pure . checkDBError)
           `catchAll` (pure . dbError)
       where
@@ -231,6 +248,11 @@ chatCloseStore ChatController {chatStore, smpAgent} = handleErr $ do
   closeSQLiteStore chatStore
   closeSQLiteStore $ agentClientStore smpAgent
 
+chatReopenStore :: ChatController -> IO String
+chatReopenStore ChatController {chatStore, smpAgent} = handleErr $ do
+  reopenSQLiteStore chatStore
+  reopenSQLiteStore (agentClientStore smpAgent)
+
 handleErr :: IO () -> IO String
 handleErr a = (a $> "") `catch` (pure . show @SomeException)
 

src/Simplex/Chat/Options.hs

@@ -18,6 +18,7 @@ where
 
 import Control.Logger.Simple (LogLevel (..))
 import qualified Data.Attoparsec.ByteString.Char8 as A
+import Data.ByteArray (ScrubbedBytes)
 import qualified Data.ByteString.Char8 as B
 import Data.Text (Text)
 import Numeric.Natural (Natural)
@@ -48,7 +49,7 @@ data ChatOpts = ChatOpts
 
 data CoreChatOpts = CoreChatOpts
   { dbFilePrefix :: String,
-    dbKey :: String,
+    dbKey :: ScrubbedBytes,
     smpServers :: [SMPServerWithAuth],
     xftpServers :: [XFTPServerWithAuth],
     networkConfig :: NetworkConfig,

src/Simplex/Chat/Remote.hs

@@ -189,7 +189,7 @@ startRemoteHost rh_ rcAddrPrefs_ port_ = do
         RHSessionConnecting _inv rhs' -> Right ((), RHSessionPendingConfirmation sessionCode tls rhs')
         _ -> Left $ ChatErrorRemoteHost rhKey RHEBadState
       let rh_' = (\rh -> (rh :: RemoteHostInfo) {sessionState = Just RHSPendingConfirmation {sessionCode}}) <$> remoteHost_
-      toView $ CRRemoteHostSessionCode {remoteHost_ = rh_', sessionCode}
+      toView CRRemoteHostSessionCode {remoteHost_ = rh_', sessionCode}
       (RCHostSession {sessionKeys}, rhHello, pairing') <- timeoutThrow (ChatErrorRemoteHost rhKey RHETimeout) 60000000 $ takeRCStep vars'
       hostInfo@HostAppInfo {deviceName = hostDeviceName} <-
         liftError (ChatErrorRemoteHost rhKey) $ parseHostAppInfo rhHello
@@ -260,7 +260,7 @@ cancelRemoteHostSession handlerInfo_ rhKey = do
     atomically $
       TM.lookup rhKey sessions >>= \case
         Nothing -> pure Nothing
-        Just (sessSeq, _) | maybe False (/= sessSeq) (fst <$> handlerInfo_) -> pure Nothing -- ignore cancel from a ghost session handler
+        Just (sessSeq, _) | maybe False ((sessSeq /=) . fst) handlerInfo_ -> pure Nothing -- ignore cancel from a ghost session handler
         Just (_, rhs) -> do
           TM.delete rhKey sessions
           modifyTVar' crh $ \cur -> if (RHId <$> cur) == Just rhKey then Nothing else cur -- only wipe the closing RH
@@ -268,7 +268,7 @@ cancelRemoteHostSession handlerInfo_ rhKey = do
   forM_ deregistered $ \session -> do
     liftIO $ cancelRemoteHost handlingError session `catchAny` (logError . tshow)
     forM_ (snd <$> handlerInfo_) $ \rhStopReason ->
-      toView $ CRRemoteHostStopped {remoteHostId_, rhsState = rhsSessionState session, rhStopReason}
+      toView CRRemoteHostStopped {remoteHostId_, rhsState = rhsSessionState session, rhStopReason}
   where
     handlingError = isJust handlerInfo_
     remoteHostId_ = case rhKey of

src/Simplex/Chat/Store.hs

@@ -12,13 +12,14 @@ module Simplex.Chat.Store
   )
 where
 
+import Data.ByteArray (ScrubbedBytes)
 import Simplex.Chat.Store.Migrations
 import Simplex.Chat.Store.Profiles
 import Simplex.Chat.Store.Shared
 import Simplex.Messaging.Agent.Store.SQLite (MigrationConfirmation, MigrationError, SQLiteStore (..), createSQLiteStore, withTransaction)
 
-createChatStore :: FilePath -> String -> MigrationConfirmation -> IO (Either MigrationError SQLiteStore)
-createChatStore dbPath dbKey = createSQLiteStore dbPath dbKey migrations
+createChatStore :: FilePath -> ScrubbedBytes -> Bool -> MigrationConfirmation -> IO (Either MigrationError SQLiteStore)
+createChatStore dbPath key keepKey = createSQLiteStore dbPath key keepKey migrations
 
 chatStoreFile :: FilePath -> FilePath
 chatStoreFile = (<> "_chat.db")

src/Simplex/Chat/Store/Messages.hs

@@ -468,8 +468,8 @@ getChatPreviews db user withPCC pagination query = do
   where
     ts :: AChatPreviewData -> UTCTime
     ts (ACPD _ cpd) = case cpd of
-      (DirectChatPD t _ _) -> t
-      (GroupChatPD t _ _) -> t
+      (DirectChatPD t _ _ _) -> t
+      (GroupChatPD t _ _ _) -> t
       (ContactRequestPD t _) -> t
       (ContactConnectionPD t _) -> t
     sortTake = case pagination of
@@ -484,8 +484,8 @@ getChatPreviews db user withPCC pagination query = do
       SCTContactConnection -> let (ContactConnectionPD _ chat) = cpd in pure chat
 
 data ChatPreviewData (c :: ChatType) where
-  DirectChatPD :: UTCTime -> ContactId -> Maybe ChatStats -> ChatPreviewData 'CTDirect
-  GroupChatPD :: UTCTime -> GroupId -> Maybe ChatStats -> ChatPreviewData 'CTGroup
+  DirectChatPD :: UTCTime -> ContactId -> Maybe ChatItemId -> ChatStats -> ChatPreviewData 'CTDirect
+  GroupChatPD :: UTCTime -> GroupId -> Maybe ChatItemId -> ChatStats -> ChatPreviewData 'CTGroup
   ContactRequestPD :: UTCTime -> AChat -> ChatPreviewData 'CTContactRequest
   ContactConnectionPD :: UTCTime -> AChat -> ChatPreviewData 'CTContactConnection
 
@@ -497,283 +497,200 @@ paginationByTimeFilter = \case
   PTAfter ts count -> ("\nAND ts > :ts ORDER BY ts ASC LIMIT :count", [":ts" := ts, ":count" := count])
   PTBefore ts count -> ("\nAND ts < :ts ORDER BY ts DESC LIMIT :count", [":ts" := ts, ":count" := count])
 
-type MaybeChatStatsRow = (Maybe Int, Maybe ChatItemId, Maybe Bool)
+type ChatStatsRow = (Int, ChatItemId, Bool)
 
-toMaybeChatStats :: MaybeChatStatsRow -> Maybe ChatStats
-toMaybeChatStats (Just unreadCount, Just minUnreadItemId, Just unreadChat) = Just ChatStats {unreadCount, minUnreadItemId, unreadChat}
-toMaybeChatStats _ = Nothing
+toChatStats :: ChatStatsRow -> ChatStats
+toChatStats (unreadCount, minUnreadItemId, unreadChat) = ChatStats {unreadCount, minUnreadItemId, unreadChat}
 
 findDirectChatPreviews_ :: DB.Connection -> User -> PaginationByTime -> ChatListQuery -> IO [AChatPreviewData]
 findDirectChatPreviews_ db User {userId} pagination clq =
   map toPreview <$> getPreviews
   where
-    toPreview :: (ContactId, UTCTime) :. MaybeChatStatsRow -> AChatPreviewData
-    toPreview ((contactId, ts) :. statsRow_) =
-      ACPD SCTDirect $ DirectChatPD ts contactId (toMaybeChatStats statsRow_)
+    toPreview :: (ContactId, UTCTime, Maybe ChatItemId) :. ChatStatsRow -> AChatPreviewData
+    toPreview ((contactId, ts, lastItemId_) :. statsRow) =
+      ACPD SCTDirect $ DirectChatPD ts contactId lastItemId_ (toChatStats statsRow)
+    baseQuery =
+      [sql|
+        SELECT ct.contact_id, ct.chat_ts as ts, LastItems.chat_item_id, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), ct.unread_chat
+        FROM contacts ct
+        LEFT JOIN (
+          SELECT contact_id, chat_item_id, MAX(created_at)
+          FROM chat_items
+          GROUP BY contact_id
+        ) LastItems ON LastItems.contact_id = ct.contact_id
+        LEFT JOIN (
+          SELECT contact_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
+          FROM chat_items
+          WHERE item_status = :rcv_new
+          GROUP BY contact_id
+        ) ChatStats ON ChatStats.contact_id = ct.contact_id
+      |]
     (pagQuery, pagParams) = paginationByTimeFilter pagination
     getPreviews = case clq of
       CLQFilters {favorite = False, unread = False} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT ct.contact_id, ct.chat_ts as ts, NULL, NULL, NULL
-              FROM contacts ct
-              WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = True, unread = False} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT ct.contact_id, ct.chat_ts as ts, NULL, NULL, NULL
-              FROM contacts ct
-              WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
-                AND ct.favorite = 1
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
+                      AND ct.favorite = 1
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = False, unread = True} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT ct.contact_id, ct.chat_ts as ts, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), ct.unread_chat
-              FROM contacts ct
-              LEFT JOIN (
-                SELECT contact_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-                FROM chat_items
-                WHERE item_status = :rcv_new
-                GROUP BY contact_id
-              ) ChatStats ON ChatStats.contact_id = ct.contact_id
-              WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
-                AND (ct.unread_chat = 1 OR ChatStats.UnreadCount > 0)
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
+                      AND (ct.unread_chat = 1 OR ChatStats.UnreadCount > 0)
+                  |]
               <> pagQuery
           )
           ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = True, unread = True} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT ct.contact_id, ct.chat_ts as ts, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), ct.unread_chat
-              FROM contacts ct
-              LEFT JOIN (
-                SELECT contact_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-                FROM chat_items
-                WHERE item_status = :rcv_new
-                GROUP BY contact_id
-              ) ChatStats ON ChatStats.contact_id = ct.contact_id
-              WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
-                AND (ct.favorite = 1
-                  OR ct.unread_chat = 1 OR ChatStats.UnreadCount > 0)
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
+                      AND (ct.favorite = 1
+                        OR ct.unread_chat = 1 OR ChatStats.UnreadCount > 0)
+                  |]
               <> pagQuery
           )
           ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQSearch {search} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT ct.contact_id, ct.chat_ts as ts, NULL, NULL, NULL
-              FROM contacts ct
-              JOIN contact_profiles cp ON ct.contact_profile_id = cp.contact_profile_id
-              WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
-                AND (
-                  ct.local_display_name LIKE '%' || :search || '%'
-                  OR cp.display_name LIKE '%' || :search || '%'
-                  OR cp.full_name LIKE '%' || :search || '%'
-                  OR cp.local_alias LIKE '%' || :search || '%'
-                )
-            |]
+          ( baseQuery
+              <> [sql|
+                    JOIN contact_profiles cp ON ct.contact_profile_id = cp.contact_profile_id
+                    WHERE ct.user_id = :user_id AND ct.is_user = 0 AND ct.deleted = 0 AND ct.contact_used
+                      AND (
+                        ct.local_display_name LIKE '%' || :search || '%'
+                        OR cp.display_name LIKE '%' || :search || '%'
+                        OR cp.full_name LIKE '%' || :search || '%'
+                        OR cp.local_alias LIKE '%' || :search || '%'
+                      )
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId, ":search" := search] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew, ":search" := search] <> pagParams)
 
 getDirectChatPreview_ :: DB.Connection -> User -> ChatPreviewData 'CTDirect -> ExceptT StoreError IO AChat
-getDirectChatPreview_ db user (DirectChatPD _ contactId stats_) = do
+getDirectChatPreview_ db user (DirectChatPD _ contactId lastItemId_ stats) = do
   contact <- getContact db user contactId
-  lastItem <- getLastItem
-  stats <- maybe getChatStats pure stats_
+  lastItem <- case lastItemId_ of
+    Just lastItemId -> (: []) <$> getDirectChatItem db user contactId lastItemId
+    Nothing -> pure []
   pure $ AChat SCTDirect (Chat (DirectChat contact) lastItem stats)
-  where
-    getLastItem :: ExceptT StoreError IO [CChatItem 'CTDirect]
-    getLastItem =
-      liftIO getLastItemId >>= \case
-        Nothing -> pure []
-        Just lastItemId -> (: []) <$> getDirectChatItem db user contactId lastItemId
-    getLastItemId :: IO (Maybe ChatItemId)
-    getLastItemId =
-      maybeFirstRow fromOnly $
-        DB.query
-          db
-          [sql|
-            SELECT chat_item_id FROM (
-              SELECT contact_id, chat_item_id, MAX(created_at)
-              FROM chat_items
-              WHERE contact_id = ?
-              GROUP BY contact_id
-            )
-          |]
-          (Only contactId)
-    getChatStats :: ExceptT StoreError IO ChatStats
-    getChatStats = do
-      r_ <- liftIO getUnreadStats
-      let (unreadCount, minUnreadItemId) = maybe (0, 0) (\(_, unreadCnt, minId) -> (unreadCnt, minId)) r_
-      -- unread_chat could be read into contact to not search twice
-      unreadChat <-
-        ExceptT . firstRow fromOnly (SEInternalError $ "unread_chat not found for contact " <> show contactId) $
-          DB.query db "SELECT unread_chat FROM contacts WHERE contact_id = ?" (Only contactId)
-      pure ChatStats {unreadCount, minUnreadItemId, unreadChat}
-    getUnreadStats :: IO (Maybe (ContactId, Int, ChatItemId))
-    getUnreadStats =
-      maybeFirstRow id $
-        DB.query
-          db
-          [sql|
-            SELECT contact_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-            FROM chat_items
-            WHERE contact_id = ? AND item_status = ?
-            GROUP BY contact_id
-          |]
-          (contactId, CISRcvNew)
 
 findGroupChatPreviews_ :: DB.Connection -> User -> PaginationByTime -> ChatListQuery -> IO [AChatPreviewData]
 findGroupChatPreviews_ db User {userId} pagination clq =
   map toPreview <$> getPreviews
   where
-    toPreview :: (GroupId, UTCTime) :. MaybeChatStatsRow -> AChatPreviewData
-    toPreview ((groupId, ts) :. statsRow_) =
-      ACPD SCTGroup $ GroupChatPD ts groupId (toMaybeChatStats statsRow_)
+    toPreview :: (GroupId, UTCTime, Maybe ChatItemId) :. ChatStatsRow -> AChatPreviewData
+    toPreview ((groupId, ts, lastItemId_) :. statsRow) =
+      ACPD SCTGroup $ GroupChatPD ts groupId lastItemId_ (toChatStats statsRow)
+    baseQuery =
+      [sql|
+        SELECT g.group_id, g.chat_ts as ts, LastItems.chat_item_id, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), g.unread_chat
+        FROM groups g
+        LEFT JOIN (
+          SELECT group_id, chat_item_id, MAX(item_ts)
+          FROM chat_items
+          GROUP BY group_id
+        ) LastItems ON LastItems.group_id = g.group_id
+        LEFT JOIN (
+          SELECT group_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
+          FROM chat_items
+          WHERE item_status = :rcv_new
+          GROUP BY group_id
+        ) ChatStats ON ChatStats.group_id = g.group_id
+      |]
     (pagQuery, pagParams) = paginationByTimeFilter pagination
     getPreviews = case clq of
       CLQFilters {favorite = False, unread = False} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT g.group_id, g.chat_ts as ts, NULL, NULL, NULL
-              FROM groups g
-              WHERE g.user_id = :user_id
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE g.user_id = :user_id
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = True, unread = False} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT g.group_id, g.chat_ts as ts, NULL, NULL, NULL
-              FROM groups g
-              WHERE g.user_id = :user_id
-                AND g.favorite = 1
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE g.user_id = :user_id
+                      AND g.favorite = 1
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = False, unread = True} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT g.group_id, g.chat_ts as ts, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), g.unread_chat
-              FROM groups g
-              LEFT JOIN (
-                SELECT group_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-                FROM chat_items
-                WHERE item_status = :rcv_new
-                GROUP BY group_id
-              ) ChatStats ON ChatStats.group_id = g.group_id
-              WHERE g.user_id = :user_id
-                AND (g.unread_chat = 1 OR ChatStats.UnreadCount > 0)
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE g.user_id = :user_id
+                      AND (g.unread_chat = 1 OR ChatStats.UnreadCount > 0)
+                  |]
               <> pagQuery
           )
           ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQFilters {favorite = True, unread = True} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT g.group_id, g.chat_ts as ts, COALESCE(ChatStats.UnreadCount, 0), COALESCE(ChatStats.MinUnread, 0), g.unread_chat
-              FROM groups g
-              LEFT JOIN (
-                SELECT group_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-                FROM chat_items
-                WHERE item_status = :rcv_new
-                GROUP BY group_id
-              ) ChatStats ON ChatStats.group_id = g.group_id
-              WHERE g.user_id = :user_id
-                AND (g.favorite = 1
-                  OR g.unread_chat = 1 OR ChatStats.UnreadCount > 0)
-            |]
+          ( baseQuery
+              <> [sql|
+                    WHERE g.user_id = :user_id
+                      AND (g.favorite = 1
+                        OR g.unread_chat = 1 OR ChatStats.UnreadCount > 0)
+                  |]
               <> pagQuery
           )
           ([":user_id" := userId, ":rcv_new" := CISRcvNew] <> pagParams)
       CLQSearch {search} ->
         DB.queryNamed
           db
-          ( [sql|
-              SELECT g.group_id, g.chat_ts as ts, NULL, NULL, NULL
-              FROM groups g
-              JOIN group_profiles gp ON gp.group_profile_id = g.group_profile_id
-              WHERE g.user_id = :user_id
-                AND (
-                  g.local_display_name LIKE '%' || :search || '%'
-                  OR gp.display_name LIKE '%' || :search || '%'
-                  OR gp.full_name LIKE '%' || :search || '%'
-                  OR gp.description LIKE '%' || :search || '%'
-                )
-            |]
+          ( baseQuery
+              <> [sql|
+                    JOIN group_profiles gp ON gp.group_profile_id = g.group_profile_id
+                    WHERE g.user_id = :user_id
+                      AND (
+                        g.local_display_name LIKE '%' || :search || '%'
+                        OR gp.display_name LIKE '%' || :search || '%'
+                        OR gp.full_name LIKE '%' || :search || '%'
+                        OR gp.description LIKE '%' || :search || '%'
+                      )
+                  |]
               <> pagQuery
           )
-          ([":user_id" := userId, ":search" := search] <> pagParams)
+          ([":user_id" := userId, ":rcv_new" := CISRcvNew, ":search" := search] <> pagParams)
 
 getGroupChatPreview_ :: DB.Connection -> User -> ChatPreviewData 'CTGroup -> ExceptT StoreError IO AChat
-getGroupChatPreview_ db user (GroupChatPD _ groupId stats_) = do
+getGroupChatPreview_ db user (GroupChatPD _ groupId lastItemId_ stats) = do
   groupInfo <- getGroupInfo db user groupId
-  lastItem <- getLastItem
-  stats <- maybe getChatStats pure stats_
+  lastItem <- case lastItemId_ of
+    Just lastItemId -> (: []) <$> getGroupChatItem db user groupId lastItemId
+    Nothing -> pure []
   pure $ AChat SCTGroup (Chat (GroupChat groupInfo) lastItem stats)
-  where
-    getLastItem :: ExceptT StoreError IO [CChatItem 'CTGroup]
-    getLastItem =
-      liftIO getLastItemId >>= \case
-        Nothing -> pure []
-        Just lastItemId -> (: []) <$> getGroupChatItem db user groupId lastItemId
-    getLastItemId :: IO (Maybe ChatItemId)
-    getLastItemId =
-      maybeFirstRow fromOnly $
-        DB.query
-          db
-          [sql|
-            SELECT chat_item_id FROM (
-              SELECT group_id, chat_item_id, MAX(item_ts)
-              FROM chat_items
-              WHERE group_id = ?
-              GROUP BY group_id
-            )
-          |]
-          (Only groupId)
-    getChatStats :: ExceptT StoreError IO ChatStats
-    getChatStats = do
-      r_ <- liftIO getUnreadStats
-      let (unreadCount, minUnreadItemId) = maybe (0, 0) (\(_, unreadCnt, minId) -> (unreadCnt, minId)) r_
-      -- unread_chat could be read into group to not search twice
-      unreadChat <-
-        ExceptT . firstRow fromOnly (SEInternalError $ "unread_chat not found for group " <> show groupId) $
-          DB.query db "SELECT unread_chat FROM groups WHERE group_id = ?" (Only groupId)
-      pure ChatStats {unreadCount, minUnreadItemId, unreadChat}
-    getUnreadStats :: IO (Maybe (GroupId, Int, ChatItemId))
-    getUnreadStats =
-      maybeFirstRow id $
-        DB.query
-          db
-          [sql|
-            SELECT group_id, COUNT(1) AS UnreadCount, MIN(chat_item_id) AS MinUnread
-            FROM chat_items
-            WHERE group_id = ? AND item_status = ?
-            GROUP BY group_id
-          |]
-          (groupId, CISRcvNew)
 
 getContactRequestChatPreviews_ :: DB.Connection -> User -> PaginationByTime -> ChatListQuery -> IO [AChatPreviewData]
 getContactRequestChatPreviews_ db User {userId} pagination clq = case clq of

src/Simplex/Chat/View.hs

@@ -279,6 +279,7 @@ responseToView hu@(currentRH, user_) ChatConfig {logLevel, showReactions, showRe
   CRNtfTokenStatus status -> ["device token status: " <> plain (smpEncode status)]
   CRNtfToken _ status mode -> ["device token status: " <> plain (smpEncode status) <> ", notifications mode: " <> plain (strEncode mode)]
   CRNtfMessages {} -> []
+  CRNtfMessage {} -> []
   CRCurrentRemoteHost rhi_ ->
     [ maybe
         "Using local profile"