Do not confirm DOE or edit until it is processed

ts/messageModifiers/Deletes.ts

@@ -1,109 +1,98 @@
 // Copyright 2020 Signal Messenger, LLC
 // SPDX-License-Identifier: AGPL-3.0-only
 
-/* eslint-disable max-classes-per-file */
-
-import { Collection, Model } from 'backbone';
-import type { MessageModel } from '../models/messages';
+import type { MessageAttributesType } from '../model-types.d';
 import { getContactId } from '../messages/helpers';
 import * as log from '../logging/log';
 import * as Errors from '../types/errors';
 import { deleteForEveryone } from '../util/deleteForEveryone';
 import { drop } from '../util/drop';
+import { filter, size } from '../util/iterables';
 import { getMessageSentTimestampSet } from '../util/getMessageSentTimestampSet';
 
 export type DeleteAttributesType = {
+  envelopeId: string;
   targetSentTimestamp: number;
   serverTimestamp: number;
   fromId: string;
+  removeFromMessageReceiverCache: () => unknown;
 };
 
-export class DeleteModel extends Model<DeleteAttributesType> {}
+const deletes = new Map<string, DeleteAttributesType>();
 
-let singleton: Deletes | undefined;
+export function forMessage(
+  messageAttributes: MessageAttributesType
+): Array<DeleteAttributesType> {
+  const sentTimestamps = getMessageSentTimestampSet(messageAttributes);
+  const matchingDeletes = filter(deletes, ([_envelopeId, item]) => {
+    return (
+      item.fromId === getContactId(messageAttributes) &&
+      sentTimestamps.has(item.targetSentTimestamp)
+    );
+  });
 
-export class Deletes extends Collection<DeleteModel> {
-  static getSingleton(): Deletes {
-    if (!singleton) {
-      singleton = new Deletes();
-    }
-
-    return singleton;
-  }
-
-  forMessage(message: MessageModel): Array<DeleteModel> {
-    const sentTimestamps = getMessageSentTimestampSet(message.attributes);
-    const matchingDeletes = this.filter(item => {
-      return (
-        item.get('fromId') === getContactId(message.attributes) &&
-        sentTimestamps.has(item.get('targetSentTimestamp'))
-      );
+  if (size(matchingDeletes) > 0) {
+    log.info('Found early DOE for message');
+    const result = Array.from(matchingDeletes);
+    result.forEach(([envelopeId, del]) => {
+      del.removeFromMessageReceiverCache();
+      deletes.delete(envelopeId);
     });
-
-    if (matchingDeletes.length > 0) {
-      log.info('Found early DOE for message');
-      this.remove(matchingDeletes);
-      return matchingDeletes;
-    }
-
-    return [];
+    return result.map(([_envelopeId, item]) => item);
   }
 
-  async onDelete(del: DeleteModel): Promise<void> {
-    try {
-      // The conversation the deleted message was in; we have to find it in the database
-      //   to to figure that out.
-      const targetConversation =
-        await window.ConversationController.getConversationForTargetMessage(
-          del.get('fromId'),
-          del.get('targetSentTimestamp')
-        );
+  return [];
+}
 
-      if (!targetConversation) {
-        log.info(
-          'No target conversation for DOE',
-          del.get('fromId'),
-          del.get('targetSentTimestamp')
-        );
+export async function onDelete(del: DeleteAttributesType): Promise<void> {
+  deletes.set(del.envelopeId, del);
 
-        return;
-      }
+  const logId = `Deletes.onDelete(timestamp=${del.targetSentTimestamp})`;
 
-      // Do not await, since this can deadlock the queue
-      drop(
-        targetConversation.queueJob('Deletes.onDelete', async () => {
-          log.info('Handling DOE for', del.get('targetSentTimestamp'));
-
-          const messages = await window.Signal.Data.getMessagesBySentAt(
-            del.get('targetSentTimestamp')
-          );
-
-          const targetMessage = messages.find(
-            m => del.get('fromId') === getContactId(m) && !m.deletedForEveryone
-          );
-
-          if (!targetMessage) {
-            log.info(
-              'No message for DOE',
-              del.get('fromId'),
-              del.get('targetSentTimestamp')
-            );
-
-            return;
-          }
-
-          const message = window.MessageController.register(
-            targetMessage.id,
-            targetMessage
-          );
-
-          await deleteForEveryone(message, del);
-
-          this.remove(del);
-        })
+  try {
+    // The conversation the deleted message was in; we have to find it in the database
+    //   to to figure that out.
+    const targetConversation =
+      await window.ConversationController.getConversationForTargetMessage(
+        del.fromId,
+        del.targetSentTimestamp
       );
-    } catch (error) {
-      log.error('Deletes.onDelete error:', Errors.toLogFormat(error));
+
+    if (!targetConversation) {
+      log.info(`${logId}: No message for DOE`);
+      return;
     }
+
+    // Do not await, since this can deadlock the queue
+    drop(
+      targetConversation.queueJob('Deletes.onDelete', async () => {
+        log.info(`${logId}: Handling DOE`);
+
+        const messages = await window.Signal.Data.getMessagesBySentAt(
+          del.targetSentTimestamp
+        );
+
+        const targetMessage = messages.find(
+          m => del.fromId === getContactId(m) && !m.deletedForEveryone
+        );
+
+        if (!targetMessage) {
+          log.info(`${logId}: No message for DOE 2`);
+          return;
+        }
+
+        const message = window.MessageController.register(
+          targetMessage.id,
+          targetMessage
+        );
+
+        await deleteForEveryone(message, del);
+
+        deletes.delete(del.envelopeId);
+        del.removeFromMessageReceiverCache();
+      })
+    );
+  } catch (error) {
+    log.error(`${logId}: error`, Errors.toLogFormat(error));
   }
 }