Migrate local thread mutes (#4523)

* migrate thread mutes

* don't try and clear if not logged in yet

* migrate mutes one at a time

* write before mutating

* only migrate mutes of self posts

* use /** @deprecated */

* shouldLike -> shouldMute

src/state/cache/thread-mutes.tsx

···
-import React from 'react'
+import React, {useEffect} from 'react'
+
+import * as persisted from '#/state/persisted'
+import {useAgent, useSession} from '../session'
 
 type StateContext = Map<string, boolean>
 type SetStateContext = (uri: string, value: boolean) => void
···
     },
     [setState],
   )
+
+  useMigrateMutes(setThreadMute)
+
   return (
     <stateContext.Provider value={state}>
       <setStateContext.Provider value={setThreadMute}>
···
 export function useSetThreadMute() {
   return React.useContext(setStateContext)
 }
+
+function useMigrateMutes(setThreadMute: SetStateContext) {
+  const agent = useAgent()
+  const {currentAccount} = useSession()
+
+  useEffect(() => {
+    if (currentAccount) {
+      if (
+        !persisted
+          .get('mutedThreads')
+          .some(uri => uri.includes(currentAccount.did))
+      ) {
+        return
+      }
+
+      let cancelled = false
+
+      const migrate = async () => {
+        while (!cancelled) {
+          const threads = persisted.get('mutedThreads')
+
+          const root = threads.findLast(uri => uri.includes(currentAccount.did))
+
+          if (!root) break
+
+          persisted.write(
+            'mutedThreads',
+            threads.filter(uri => uri !== root),
+          )
+
+          setThreadMute(root, true)
+
+          await agent.api.app.bsky.graph
+            .muteThread({root})
+            // not a big deal if this fails, since the post might have been deleted
+            .catch(console.error)
+        }
+      }
+
+      migrate()
+
+      return () => {
+        cancelled = true
+      }
+    }
+  }, [agent, currentAccount, setThreadMute])
+}

src/state/persisted/schema.ts

···
       flickr: z.enum(externalEmbedOptions).optional(),
     })
     .optional(),
-  mutedThreads: z.array(z.string()), // should move to server
   invites: z.object({
     copiedInvites: z.array(z.string()),
   }),
···
   disableHaptics: z.boolean().optional(),
   disableAutoplay: z.boolean().optional(),
   kawaii: z.boolean().optional(),
+  /** @deprecated */
+  mutedThreads: z.array(z.string()),
 })
 export type Schema = z.infer<typeof schema>
 

src/state/queries/post.ts

···
 
   const queueToggle = useToggleMutationQueue<boolean>({
     initialState: isThreadMuted,
-    runMutation: async (_prev, shouldLike) => {
-      if (shouldLike) {
+    runMutation: async (_prev, shouldMute) => {
+      if (shouldMute) {
         await threadMuteMutation.mutateAsync({
           uri: rootUri,
         })