fix: refresh code and notes after vault sync

Author: antonreshetov

src/renderer/components/notes/NotesEditorPane.vue

@@ -13,6 +13,7 @@ import {
   Pencil,
   Presentation,
 } from 'lucide-vue-next'
+import { shouldSyncSelectedNoteContent } from './editorSync'
 import { getTextStats } from './textStats'
 
 const {
@@ -88,8 +89,12 @@ const name = computed({
 const editorContent = ref('')
 
 watch(
-  () => selectedNote.value?.id,
-  () => {
+  selectedNote,
+  (nextNote, previousNote) => {
+    if (!shouldSyncSelectedNoteContent(previousNote, nextNote)) {
+      return
+    }
+
     editorContent.value = selectedNote.value?.content ?? ''
   },
   { immediate: true },

src/renderer/components/notes/__tests__/editorSync.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+import { shouldSyncSelectedNoteContent } from '../editorSync'
+
+describe('shouldSyncSelectedNoteContent', () => {
+  it('returns true when selected note content changes for the same note', () => {
+    expect(
+      shouldSyncSelectedNoteContent(
+        { id: 1, content: 'before' },
+        { id: 1, content: 'after' },
+      ),
+    ).toBe(true)
+  })
+
+  it('returns true when selected note changes', () => {
+    expect(
+      shouldSyncSelectedNoteContent(
+        { id: 1, content: 'same' },
+        { id: 2, content: 'same' },
+      ),
+    ).toBe(true)
+  })
+
+  it('returns false when note id and content are unchanged', () => {
+    expect(
+      shouldSyncSelectedNoteContent(
+        { id: 1, content: 'same' },
+        { id: 1, content: 'same' },
+      ),
+    ).toBe(false)
+  })
+})

src/renderer/components/notes/editorSync.ts

@@ -0,0 +1,14 @@
+interface SyncableSelectedNote {
+  id: number
+  content: string
+}
+
+export function shouldSyncSelectedNoteContent(
+  previousNote: SyncableSelectedNote | null | undefined,
+  nextNote: SyncableSelectedNote | null | undefined,
+): boolean {
+  return (
+    previousNote?.id !== nextNote?.id
+    || previousNote?.content !== nextNote?.content
+  )
+}

src/renderer/ipc/listeners/__tests__/system.test.ts

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { ref } from 'vue'
+
+async function setup(activeSpace: 'code' | 'notes' | 'tools' | null) {
+  vi.resetModules()
+  vi.useFakeTimers()
+
+  const ipcHandlers = new Map<string, (...args: any[]) => void>()
+  const state = {
+    snippetId: undefined,
+  }
+  const isCodeSpaceInitialized = ref(true)
+  const isNotesSpaceInitialized = ref(true)
+  const displayedSnippets = ref<{ id: number }[]>([])
+  const getFolders = vi.fn(async () => undefined)
+  const getSnippets = vi.fn(async () => undefined)
+  const reloadMathFromDisk = vi.fn(async () => undefined)
+  const getNoteFolders = vi.fn(async () => undefined)
+  const getNotes = vi.fn(async () => undefined)
+  const getNoteTags = vi.fn(async () => undefined)
+
+  vi.doMock('@/composables', () => ({
+    useApp: () => ({
+      state,
+      highlightedFolderIds: ref(new Set<number>()),
+      highlightedSnippetIds: ref(new Set<number>()),
+      focusedSnippetId: ref<number | undefined>(),
+      focusedFolderId: ref<number | undefined>(),
+      isCodeSpaceInitialized,
+    }),
+    useFolders: () => ({
+      selectFolder: vi.fn(),
+      getFolders,
+    }),
+    useMathNotebook: () => ({
+      reloadFromDisk: reloadMathFromDisk,
+    }),
+    useNoteFolders: () => ({
+      getNoteFolders,
+    }),
+    useNotes: () => ({
+      getNotes,
+      hasBusyNoteContentUpdates: vi.fn(() => false),
+    }),
+    useNotesApp: () => ({
+      isNotesSpaceInitialized,
+    }),
+    useNoteTags: () => ({
+      getNoteTags,
+    }),
+    useSnippets: () => ({
+      selectSnippet: vi.fn(),
+      getSnippets,
+      selectFirstSnippet: vi.fn(),
+      displayedSnippets,
+    }),
+    useSnippetUpdate: () => ({
+      hasBusyContentUpdates: vi.fn(() => false),
+    }),
+    useSonner: () => ({
+      sonner: vi.fn(),
+    }),
+    useStorageMutation: () => ({
+      shouldSkipStorageSyncRefresh: vi.fn(() => false),
+    }),
+  }))
+
+  vi.doMock('@/electron', () => ({
+    i18n: {
+      t: vi.fn((key: string) => key),
+    },
+    ipc: {
+      on: vi.fn((channel: string, handler: (...args: any[]) => void) => {
+        ipcHandlers.set(channel, handler)
+      }),
+      invoke: vi.fn(),
+    },
+  }))
+
+  vi.doMock('@/spaceDefinitions', () => ({
+    getActiveSpaceId: vi.fn(() => activeSpace),
+  }))
+
+  const { registerSystemListeners } = await import('../system')
+
+  registerSystemListeners()
+
+  return {
+    getFolders,
+    getNoteFolders,
+    getNotes,
+    getNoteTags,
+    getSnippets,
+    ipcHandlers,
+    isCodeSpaceInitialized,
+    isNotesSpaceInitialized,
+  }
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+})
+
+afterEach(() => {
+  vi.useRealTimers()
+})
+
+describe('registerSystemListeners', () => {
+  it('invalidates code and notes initialization after storage sync', async () => {
+    const context = await setup('tools')
+
+    context.ipcHandlers.get('system:storage-synced')?.(undefined)
+    await vi.advanceTimersByTimeAsync(300)
+
+    expect(context.isCodeSpaceInitialized.value).toBe(false)
+    expect(context.isNotesSpaceInitialized.value).toBe(false)
+    expect(context.getFolders).not.toHaveBeenCalled()
+    expect(context.getSnippets).not.toHaveBeenCalled()
+    expect(context.getNoteFolders).not.toHaveBeenCalled()
+    expect(context.getNotes).not.toHaveBeenCalled()
+    expect(context.getNoteTags).not.toHaveBeenCalled()
+  })
+})

src/renderer/ipc/listeners/system.ts

@@ -4,6 +4,7 @@ import {
   useMathNotebook,
   useNoteFolders,
   useNotes,
+  useNotesApp,
   useNoteTags,
   useSnippets,
   useSnippetUpdate,
@@ -16,6 +17,7 @@ import { repository } from '../../../../package.json'
 
 const {
   state,
+  isCodeSpaceInitialized,
   highlightedFolderIds,
   highlightedSnippetIds,
   focusedSnippetId,
@@ -27,6 +29,7 @@ const { selectSnippet, getSnippets, selectFirstSnippet, displayedSnippets }
 const { hasBusyContentUpdates } = useSnippetUpdate()
 const { shouldSkipStorageSyncRefresh } = useStorageMutation()
 const { reloadFromDisk: reloadMathFromDisk } = useMathNotebook()
+const { isNotesSpaceInitialized } = useNotesApp()
 const { getNoteFolders } = useNoteFolders()
 const { getNotes, hasBusyNoteContentUpdates } = useNotes()
 const { getNoteTags } = useNoteTags()
@@ -54,6 +57,8 @@ async function refreshCodeSpace() {
 
 async function refreshAfterStorageSync() {
   const activeSpace = getActiveSpaceId()
+  isCodeSpaceInitialized.value = false
+  isNotesSpaceInitialized.value = false
 
   switch (activeSpace) {
     case 'math':