fix: Delete / Archive / Block conversations and users

components/debug-menu.tsx

@@ -21,26 +21,33 @@ import {
 } from "@/features/notifications/notifications.service"
 import { getXmtpConversationIdFromXmtpTopic } from "@/features/xmtp/xmtp-conversations/xmtp-conversation"
 import { getXmtpConversations } from "@/features/xmtp/xmtp-conversations/xmtp-conversations-list"
-import { syncAllXmtpConversations } from "@/features/xmtp/xmtp-conversations/xmtp-conversations-sync"
+import {
+  syncAllXmtpConversations,
+  syncOneXmtpConversation,
+} from "@/features/xmtp/xmtp-conversations/xmtp-conversations-sync"
+import { getXmtpDisappearingMessageSettings } from "@/features/xmtp/xmtp-disappearing-messages/xmtp-disappearing-messages"
 import {
   clearXmtpLogFiles,
   clearXmtpLogs,
   getXmtpLogFile,
   startXmtpFileLogging,
   stopXmtpFileLogging,
 } from "@/features/xmtp/xmtp-logs"
-import type { IXmtpInboxId } from "@/features/xmtp/xmtp.types"
+import { getXmtpConversationMessages } from "@/features/xmtp/xmtp-messages/xmtp-messages"
+import type { IXmtpDecodedMessage, IXmtpInboxId } from "@/features/xmtp/xmtp.types"
 import { translate } from "@/i18n"
-import { navigate } from "@/navigation/navigation.utils"
+import { getCurrentRouteParams, navigate } from "@/navigation/navigation.utils"
 import { useAppStore } from "@/stores/app.store"
 import { captureError } from "@/utils/capture-error"
+import { convertNanosecondsToMilliseconds } from "@/utils/date"
 import { GenericError } from "@/utils/error"
 import { getEnv, isProd } from "@/utils/getEnv"
 import { Haptics } from "@/utils/haptics"
 import { clearImageCache } from "@/utils/image"
 import { clearLogFile, LOG_FILE_PATH } from "@/utils/logger/logger"
 import { clearReacyQueryQueriesAndCache } from "@/utils/react-query/react-query.utils"
 import { shareContent } from "@/utils/share"
+import { getHumanReadableTimeFromMs } from "@/utils/time.utils"
 import { showActionSheet } from "./action-sheet"
 
 export const DebugMenuWrapper = memo(function DebugWrapper(props: { children: React.ReactNode }) {
@@ -459,6 +466,109 @@ function useShowDebugMenu() {
     const clientInboxId = currentSenderInboxId as IXmtpInboxId
 
     const xmtpMethods = {
+      "Get last 10 XMTP messages": async () => {
+        try {
+          useAppStore.getState().actions.setFullScreenLoaderOptions({
+            isVisible: true,
+            texts: ["Loading messages..."],
+          })
+
+          const params = getCurrentRouteParams<"Conversation">()
+          const conversationId = params?.xmtpConversationId
+
+          if (!conversationId) {
+            Alert.alert("Error", "Select this debug option in a conversation")
+            return
+          }
+
+          await syncOneXmtpConversation({
+            clientInboxId,
+            conversationId,
+            caller: "debugMenu",
+          })
+
+          const messages = await getXmtpConversationMessages({
+            clientInboxId,
+            xmtpConversationId: conversationId,
+            limit: 10,
+          })
+
+          const messageContents = messages
+            .map((msg: IXmtpDecodedMessage) => JSON.stringify(msg.nativeContent))
+            .join("\n\n")
+          Alert.alert("Last few Messages", messageContents)
+        } catch (error) {
+          captureError(
+            new GenericError({
+              error,
+              additionalMessage: "Error getting messages",
+            }),
+          )
+          Alert.alert("Error", "Failed to get messages")
+        } finally {
+          useAppStore.getState().actions.setFullScreenLoaderOptions({
+            isVisible: false,
+          })
+        }
+      },
+      "Get disappearing message settings": async () => {
+        try {
+          useAppStore.getState().actions.setFullScreenLoaderOptions({
+            isVisible: true,
+            texts: ["Loading disappearing message settings..."],
+          })
+
+          const params = getCurrentRouteParams<"Conversation">()
+
+          const conversationId = params?.xmtpConversationId
+
+          if (!conversationId) {
+            Alert.alert("Error", "Select this debug option in a conversation")
+            return
+          }
+
+          await syncOneXmtpConversation({
+            clientInboxId,
+            conversationId,
+            caller: "debugMenu",
+          })
+
+          const settings = await getXmtpDisappearingMessageSettings({
+            clientInboxId,
+            conversationId,
+          })
+
+          if (!settings) {
+            Alert.alert("Error", "No disappearing message settings found for this conversation")
+            return
+          }
+
+          const formattedSettings = {
+            disappearStartingAt: new Date(
+              convertNanosecondsToMilliseconds(settings.disappearStartingAtNs),
+            ).toLocaleString(),
+            retentionDuration: getHumanReadableTimeFromMs(
+              convertNanosecondsToMilliseconds(settings.retentionDurationInNs),
+            ),
+          }
+          Alert.alert(
+            "Disappearing Message Settings",
+            `Messages will start disappearing at:\n${formattedSettings.disappearStartingAt}\n\nMessages will be retained for:\n${formattedSettings.retentionDuration}`,
+          )
+        } catch (error) {
+          captureError(
+            new GenericError({
+              error,
+              additionalMessage: "Error getting disappearing message settings",
+            }),
+          )
+          Alert.alert("Error", "Failed to get disappearing message settings")
+        } finally {
+          useAppStore.getState().actions.setFullScreenLoaderOptions({
+            isVisible: false,
+          })
+        }
+      },
       "List Allowed XMTP Conversations": async () => {
         try {
           useAppStore.getState().actions.setFullScreenLoaderOptions({

components/prompt-async.ts

@@ -0,0 +1,51 @@
+import { Alert, AlertOptions } from "react-native"
+
+/**
+ * Creates an Alert with a text input that returns a Promise which resolves with
+ * the input value when submitted, or undefined if canceled.
+ */
+
+export function promptAsync(args: {
+  title: string
+  message?: string
+  type?: "plain-text" | "secure-text"
+  defaultValue?: string
+  submitText?: string
+  cancelText?: string
+  keyboardType?: string
+  options?: AlertOptions
+}) {
+  const {
+    title,
+    message,
+    type = "plain-text",
+    defaultValue = "",
+    submitText = "OK",
+    cancelText = "Cancel",
+    keyboardType,
+    options,
+  } = args
+
+  return new Promise<{ value: string | undefined }>((resolve) => {
+    Alert.prompt(
+      title,
+      message,
+      [
+        {
+          text: cancelText,
+          style: "cancel",
+          onPress: () => resolve({ value: undefined }),
+        },
+        {
+          text: submitText,
+          style: "default",
+          onPress: (value?: string) => resolve({ value }),
+        },
+      ],
+      type,
+      defaultValue,
+      keyboardType,
+      options,
+    )
+  })
+}

features/blocked-conversations/blocked-conversations.screen.tsx → features/archived-conversations/archived-conversations.screen.tsx

@@ -2,13 +2,13 @@ import { translate } from "@i18n/index"
 import React from "react"
 import { Screen } from "@/components/screen/screen"
 import { EmptyState } from "@/design-system/empty-state"
-import { useBlockedConversationsForCurrentAccount } from "@/features/blocked-conversations/use-blocked-conversations-for-current-account"
+import { useBlockedConversationsForCurrentAccount } from "@/features/archived-conversations/use-archived-conversations-for-current-sender"
 import { ConversationList } from "@/features/conversation/conversation-list/conversation-list.component"
 import { useHeader } from "@/navigation/use-header"
 import { useRouter } from "@/navigation/use-navigation"
 import { $globalStyles } from "@/theme/styles"
 
-export function BlockedConversationsScreen() {
+export function ArchivedConversationsScreen() {
   const { data: blockedConversationsIds = [] } = useBlockedConversationsForCurrentAccount()
 
   const router = useRouter()

features/archived-conversations/denied-conversations.query.ts

@@ -0,0 +1,146 @@
+import { IXmtpConversationId, IXmtpInboxId } from "@features/xmtp/xmtp.types"
+import { queryOptions, skipToken } from "@tanstack/react-query"
+import { setConversationQueryData } from "@/features/conversation/queries/conversation.query"
+import { convertXmtpConversationToConvosConversation } from "@/features/conversation/utils/convert-xmtp-conversation-to-convos-conversation"
+import { getXmtpConversations } from "@/features/xmtp/xmtp-conversations/xmtp-conversations-list"
+import { syncAllXmtpConversations } from "@/features/xmtp/xmtp-conversations/xmtp-conversations-sync"
+import { reactQueryClient } from "@/utils/react-query/react-query.client"
+
+export type IDeniedConversationsQueryData = Awaited<
+  ReturnType<typeof getDeniedConversationsQueryFn>
+>
+
+async function getDeniedConversationsQueryFn(args: { inboxId: IXmtpInboxId }) {
+  const { inboxId } = args
+
+  if (!inboxId) {
+    throw new Error("InboxId is required")
+  }
+
+  await syncAllXmtpConversations({
+    clientInboxId: inboxId,
+    caller: "getDeniedConversationsQueryFn",
+    consentStates: ["denied"],
+  })
+
+  const deniedConsentXmtpConversations = await getXmtpConversations({
+    clientInboxId: inboxId,
+    consentStates: ["denied"],
+    caller: "getDeniedConversationsQueryFn",
+  })
+
+  const convosConversations = await Promise.all(
+    deniedConsentXmtpConversations.map(convertXmtpConversationToConvosConversation),
+  )
+
+  for (const conversation of convosConversations) {
+    setConversationQueryData({
+      clientInboxId: inboxId,
+      xmtpConversationId: conversation.xmtpId,
+      conversation,
+    })
+  }
+
+  return convosConversations.map((c) => c.xmtpId)
+}
+
+export const getDeniedConsentConversationsQueryData = (args: { inboxId: IXmtpInboxId }) => {
+  return reactQueryClient.getQueryData(getDeniedConsentConversationsQueryOptions(args).queryKey)
+}
+
+export function addConversationToDeniedConsentConversationsQuery(args: {
+  clientInboxId: IXmtpInboxId
+  conversationId: IXmtpConversationId
+}) {
+  const { clientInboxId, conversationId } = args
+
+  return reactQueryClient.setQueryData(
+    getDeniedConsentConversationsQueryOptions({
+      inboxId: clientInboxId,
+      caller: "addConversationToDeniedConsentConversationsQuery",
+    }).queryKey,
+    (previousConversationIds) => {
+      if (!previousConversationIds) {
+        return [conversationId]
+      }
+
+      const conversationExists = previousConversationIds.includes(conversationId)
+
+      if (conversationExists) {
+        return previousConversationIds
+      }
+
+      return [conversationId, ...previousConversationIds]
+    },
+  )
+}
+
+export function removeConversationFromDeniedConsentConversationsQuery(args: {
+  clientInboxId: IXmtpInboxId
+  conversationId: IXmtpConversationId
+}) {
+  const { clientInboxId, conversationId } = args
+
+  return reactQueryClient.setQueryData(
+    getDeniedConsentConversationsQueryOptions({
+      inboxId: clientInboxId,
+      caller: "removeConversationFromDeniedConsentConversationsQuery",
+    }).queryKey,
+    (previousConversationIds) => {
+      if (!previousConversationIds) {
+        return []
+      }
+
+      return previousConversationIds.filter((id) => id !== conversationId)
+    },
+  )
+}
+
+export function getDeniedConsentConversationsQueryOptions(args: {
+  inboxId: IXmtpInboxId
+  caller?: string
+}) {
+  const { inboxId, caller } = args
+
+  const enabled = !!inboxId
+
+  return queryOptions({
+    enabled,
+    meta: {
+      caller,
+    },
+    queryKey: ["denied-consent-conversations", inboxId],
+    queryFn: enabled
+      ? async () =>
+          getDeniedConversationsQueryFn({
+            inboxId,
+          })
+      : skipToken,
+  })
+}
+
+export function invalidateDeniedConsentConversationsQuery(args: {
+  inboxId: IXmtpInboxId
+  caller: string
+}) {
+  const { inboxId, caller } = args
+  return reactQueryClient.invalidateQueries({
+    queryKey: getDeniedConsentConversationsQueryOptions({
+      inboxId,
+      caller,
+    }).queryKey,
+  })
+}
+
+export function refetchDeniedConsentConversationsQuery(args: {
+  inboxId: IXmtpInboxId
+  caller: string
+}) {
+  const { inboxId, caller } = args
+  return reactQueryClient.refetchQueries({
+    queryKey: getDeniedConsentConversationsQueryOptions({
+      inboxId,
+      caller,
+    }).queryKey,
+  })
+}