Fix delete message

Author: dena-sohrabi

server/src/functions/messages.deleteMessage.ts

@@ -4,6 +4,11 @@ import { MessageModel } from "@in/server/db/models/messages"
 import type { FunctionContext } from "@in/server/functions/_types"
 import { Updates } from "@in/server/modules/updates/updates"
 import { Encoders } from "@in/server/realtime/encoders/encoders"
+import type { UpdateGroup } from "../modules/updates"
+import { getUpdateGroupFromInputPeer } from "../modules/updates"
+import { RealtimeUpdates } from "../realtime/message"
+import { connectionManager } from "../ws/connections"
+import { Log } from "../utils/log"
 
 type Input = {
   messageIds: bigint[]
@@ -18,22 +23,95 @@ 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: encodingForInputPeer, currentUserId: context.currentUserId }),
-      },
-    },
-  }
+  const { selfUpdates, updateGroup } = await pushUpdates({
+    inputPeer: input.peer,
+    messageIds: input.messageIds,
+    currentUserId: context.currentUserId,
+  })
+
+  return { updates: selfUpdates }
+}
+
+// ------------------------------------------------------------
+// Updates
+// ------------------------------------------------------------
+
+/** Push updates for delete messages */
+const pushUpdates = async ({
+  inputPeer,
+  messageIds,
+  currentUserId,
+}: {
+  inputPeer: InputPeer
+  messageIds: bigint[]
+  currentUserId: number
+}): Promise<{ selfUpdates: Update[]; updateGroup: UpdateGroup }> => {
+  const updateGroup = await getUpdateGroupFromInputPeer(inputPeer, { currentUserId })
 
-  Updates.shared.pushUpdate([update], { peerId: input.peer, currentUserId: context.currentUserId })
+  let selfUpdates: Update[] = []
+
+  if (updateGroup.type === "users") {
+    updateGroup.userIds.forEach((userId) => {
+      const encodingForUserId = userId
+      const encodingForInputPeer: InputPeer =
+        userId === currentUserId ? inputPeer : { type: { oneofKind: "user", user: { userId: BigInt(currentUserId) } } }
+
+      let newMessageUpdate: Update = {
+        update: {
+          oneofKind: "deleteMessages",
+          deleteMessages: {
+            messageIds: messageIds.map((id) => BigInt(id)),
+            peerId: Encoders.peerFromInputPeer({ inputPeer: encodingForInputPeer, currentUserId }),
+          },
+        },
+      }
+
+      if (userId === currentUserId) {
+        // current user gets the message id update and new message update
+        RealtimeUpdates.pushToUser(userId, [
+          // order matters here
+          newMessageUpdate,
+        ])
+        selfUpdates = [
+          // order matters here
+          newMessageUpdate,
+        ]
+      } else {
+        // other users get the message only
+        RealtimeUpdates.pushToUser(userId, [newMessageUpdate])
+      }
+    })
+  } else if (updateGroup.type === "space") {
+    const userIds = connectionManager.getSpaceUserIds(updateGroup.spaceId)
+    Log.shared.debug(`Sending message to space ${updateGroup.spaceId}`, { userIds })
+    userIds.forEach((userId) => {
+      // New updates
+      let newMessageUpdate: Update = {
+        update: {
+          oneofKind: "deleteMessages",
+          deleteMessages: {
+            messageIds: messageIds.map((id) => BigInt(id)),
+            peerId: Encoders.peerFromInputPeer({ inputPeer, currentUserId }),
+          },
+        },
+      }
+
+      if (userId === currentUserId) {
+        // current user gets the message id update and new message update
+        RealtimeUpdates.pushToUser(userId, [
+          // order matters here
+          newMessageUpdate,
+        ])
+        selfUpdates = [
+          // order matters here
+          newMessageUpdate,
+        ]
+      } else {
+        // other users get the message only
+        RealtimeUpdates.pushToUser(userId, [newMessageUpdate])
+      }
+    })
+  }
 
-  return { updates: [update] }
+  return { selfUpdates, updateGroup }
 }