Fix delete message

- Create transaction for delete message
- Fix updates in server

Author: dena-sohrabi

apple/InlineIOS/Chat/ComposeView.swift

@@ -580,7 +580,6 @@ class ComposeView: UIView, NSTextLayoutManagerDelegate,
         } catch {
           Log.shared.error("Failed to save photo", error: error)
         }
-        print("Attachment items", self.attachmentItems)
 
         for (index, (_, attachment)) in self.attachmentItems.enumerated() {
           _ = index == 0
@@ -595,7 +594,6 @@ class ComposeView: UIView, NSTextLayoutManagerDelegate,
               )
             )
           )
-          print("Sent attachment", attachment)
         }
 
         DispatchQueue.main.async { [weak self] in

apple/InlineIOS/Chat/UIMessageView.swift

@@ -1,5 +1,6 @@
 import Auth
 import ContextMenuAuxiliaryPreview
+import GRDB
 import InlineKit
 import Logger
 import Nuke
@@ -683,10 +684,14 @@ extension UIMessageView: UIContextMenuInteractionDelegate, ContextMenuManagerDel
         attributes: .destructive
       ) { _ in
         Task {
-          try? await DataManager.shared.deleteMessage(
-            messageId: self.message.messageId,
-            chatId: self.message.chatId,
-            peerId: self.message.peerId
+          let _ = Transactions.shared.mutate(
+            transaction: .deleteMessage(
+              .init(
+                messageIds: [self.message.messageId],
+                peerId: self.message.peerId,
+                chatId: self.message.chatId
+              )
+            )
           )
         }
       }

apple/InlineKit/Sources/InlineKit/RealtimeHelpers/RealtimeUpdates.swift

@@ -140,7 +140,7 @@ extension InlineProtocol.UpdateComposeAction {
       default:
         nil
     }
-    
+
     print("action: \(action)")
 
     if let action {
@@ -161,10 +161,11 @@ extension InlineProtocol.UpdateDeleteMessages {
 
     let prevChatLastMsgId = chat.lastMsgId
 
-    try Message
-      .filter(ids: messageIds)
-      .filter(Column("chatId") == chat.id)
-      .deleteAll(db)
+    for messageId in messageIds {
+      try Message
+        .filter(Column("messageId") == messageId && Column("chatId") == chat.id)
+        .deleteAll(db)
+    }
 
     // Update last message
     for messageId in messageIds {

apple/InlineKit/Sources/InlineKit/Transactions/Methods/DeleteMessage.swift

@@ -0,0 +1,146 @@
+import Auth
+import Foundation
+import GRDB
+import InlineProtocol
+import Logger
+import MultipartFormDataKit
+import RealtimeAPI
+
+public struct TransactionDeleteMessage: Transaction {
+  // Properties
+  var messageIds: [Int64]
+  var peerId: Peer
+  var chatId: Int64
+
+  // Config
+  public var id = UUID().uuidString
+  var config = TransactionConfig.default
+  var date = Date()
+
+  public init(messageIds: [Int64], peerId: Peer, chatId: Int64) {
+    self.messageIds = messageIds
+    self.peerId = peerId
+    self.chatId = chatId
+  }
+
+  // Methods
+  func optimistic() {
+    Log.shared.debug("Optimistic delete message \(messageIds) \(peerId) \(chatId)")
+    do {
+      try AppDatabase.shared.dbWriter.write { db in
+        let chat = try Chat.fetchOne(db, id: chatId)
+
+        let prevChatLastMsgId = chat?.lastMsgId
+
+        for messageId in messageIds {
+          try Message.filter(Column("messageId") == messageId && Column("chatId") == chatId).deleteAll(db)
+        }
+
+        // Update last message
+        for messageId in messageIds {
+          guard prevChatLastMsgId == messageId else { continue }
+
+          let previousMessage = try Message
+            .filter(Column("chatId") == chat?.id)
+            .order(Column("date").desc)
+            .limit(1, offset: 1)
+            .fetchOne(db)
+
+          var updatedChat = chat
+          updatedChat?.lastMsgId = previousMessage?.messageId
+          try updatedChat?.save(db)
+        }
+      }
+    } catch {
+      Log.shared.error("Failed to delete message \(error)")
+    }
+
+    DispatchQueue.main.async {
+      MessagesPublisher.shared.messagesDeleted(messageIds: messageIds, peer: peerId)
+    }
+  }
+
+  func execute() async throws -> [InlineProtocol.Update] {
+    let result = try await Realtime.shared.invoke(
+      .deleteMessages,
+      input: .deleteMessages(DeleteMessagesInput.with {
+        $0.peerID = peerId.toInputPeer()
+        $0.messageIds = messageIds
+      })
+    )
+
+    guard case let .deleteMessages(response) = result else {
+      throw DeleteMessageError.failed
+    }
+
+    return response.updates
+  }
+
+  func shouldRetryOnFail(error: Error) -> Bool {
+    if let error = error as? RealtimeAPIError {
+      switch error {
+        case let .rpcError(_, _, code):
+          switch code {
+            case 400, 401:
+              return false
+
+            default:
+              return true
+          }
+        default:
+          return true
+      }
+    }
+
+    return true
+  }
+
+  func didSucceed(result: [InlineProtocol.Update]) async {
+    await Realtime.shared.updates.applyBatch(updates: result)
+  }
+
+  func didFail(error: Error?) async {
+    Log.shared.error("Failed to delete message", error: error)
+
+    try? await AppDatabase.shared.dbWriter.write { db in
+      var chat = try Chat.fetchOne(db, id: chatId)
+    }
+
+    DispatchQueue.main.async {
+      MessagesPublisher.shared.messagesDeleted(messageIds: messageIds, peer: peerId)
+    }
+  }
+
+  func rollback() async {
+    let _ = try? await AppDatabase.shared.dbWriter.write { db in
+      var chat = try Chat.fetchOne(db, id: chatId)
+
+      let prevChatLastMsgId = chat?.lastMsgId
+
+      for messageId in messageIds {
+        try Message.filter(Column("messageId") == messageId && Column("chatId") == chatId).deleteAll(db)
+      }
+
+      // Update last message
+      for messageId in messageIds {
+        guard prevChatLastMsgId == messageId else { continue }
+
+        let previousMessage = try Message
+          .filter(Column("chatId") == chat?.id)
+          .order(Column("date").desc)
+          .limit(1, offset: 1)
+          .fetchOne(db)
+
+        var updatedChat = chat
+        updatedChat?.lastMsgId = previousMessage?.messageId
+        try updatedChat?.save(db)
+
+        break
+      }
+    }
+  }
+
+  enum DeleteMessageError: Error {
+    case failed
+  }
+}

apple/InlineKit/Sources/InlineKit/Transactions/Methods/SendMessage.swift

@@ -183,7 +183,7 @@ public struct TransactionSendMessage: Transaction {
   func shouldRetryOnFail(error: Error) -> Bool {
     if let error = error as? RealtimeAPIError {
       switch error {
-        case let .rpcError(_, _, code):
+        case let .rpcError(ec, msg, code):
           switch code {
             case 400, 401:
               return false

apple/InlineKit/Sources/InlineKit/Transactions/Transactions.swift

@@ -84,7 +84,7 @@ public class Transactions: @unchecked Sendable {
       await actor.cancel(transactionId: transactionId)
     }
   }
-  
+
   public func clearAll() {
     Task {
       await actor.clearAll()
@@ -96,6 +96,7 @@ public class Transactions: @unchecked Sendable {
 public enum TransactionType: Codable {
   case sendMessage(TransactionSendMessage)
   case mockMessage(MockMessageTransaction)
+  case deleteMessage(TransactionDeleteMessage)
 
   var id: String {
     transaction.id
@@ -111,6 +112,8 @@ public enum TransactionType: Codable {
         t
       case let .mockMessage(t):
         t
+      case let .deleteMessage(t):
+        t
     }
   }
 
@@ -140,6 +143,9 @@ public enum TransactionType: Codable {
       case let .mockMessage(transaction):
         try container.encode("mockMessage", forKey: .type)
         try container.encode(transaction, forKey: .transaction)
+      case let .deleteMessage(transaction):
+        try container.encode("deleteMessage", forKey: .type)
+        try container.encode(transaction, forKey: .transaction)
     }
   }
 
@@ -154,6 +160,9 @@ public enum TransactionType: Codable {
       case "mockMessage":
         let transaction = try container.decode(MockMessageTransaction.self, forKey: .transaction)
         self = .mockMessage(transaction)
+      case "deleteMessage":
+        let transaction = try container.decode(TransactionDeleteMessage.self, forKey: .transaction)
+        self = .deleteMessage(transaction)
       default:
         throw DecodingError.dataCorruptedError(
           forKey: .type,
@@ -189,7 +198,7 @@ protocol Transaction: Codable, Sendable, Identifiable {
   func optimistic()
   /// Optionally apply additional changes in cache after success. For example mark an status as completed.
   func didSucceed(result: R) async
-  
+
   func shouldRetryOnFail(error: Error) -> Bool
 
   /// If execute fails, apply appropriate logic. By default it calls `rollback()` method

server/src/db/models/messages.ts

@@ -200,6 +200,8 @@ async function deleteMessages(messageIds: bigint[], chatId: number) {
     )
     .returning()
 
+  console.log("deleted", deleted)
+
   if (deleted.length === 0) {
     log.trace("messages not found", { messageIds, chatId })
     throw ModelError.MessageInvalid

server/src/functions/messages.deleteMessage.ts

@@ -18,12 +18,17 @@ export const deleteMessage = async (input: Input, context: FunctionContext): Pro
   const chatId = await ChatModel.getChatIdFromInputPeer(input.peer, context)
   await MessageModel.deleteMessages(input.messageIds, chatId)
 
+  const encodingForInputPeer: InputPeer =
+    input.peer.type.oneofKind === "user" && BigInt(context.currentUserId) === input.peer.type.user.userId
+      ? input.peer
+      : { type: { oneofKind: "user", user: { userId: BigInt(context.currentUserId) } } }
+
   const update: Update = {
     update: {
       oneofKind: "deleteMessages",
       deleteMessages: {
         messageIds: input.messageIds.map((id) => BigInt(id)),
-        peerId: Encoders.peerFromInputPeer({ inputPeer: input.peer, currentUserId: context.currentUserId }),
+        peerId: Encoders.peerFromInputPeer({ inputPeer: encodingForInputPeer, currentUserId: context.currentUserId }),
       },
     },
   }