chore: move notes migration to main process

Author: haritabh-z01

apps/desktop/src/db/schema.ts

@@ -193,6 +193,9 @@ export interface AppSettingsData {
       followed: boolean; // Whether user followed recommendation
     };
   };
+  dataMigrations?: {
+    notesLexical?: number;
+  };
 }
 
 // Notes table

apps/desktop/src/main/core/app-manager.ts

@@ -12,6 +12,7 @@ import type { OnboardingService } from "../../services/onboarding-service";
 import type { RecordingManager } from "../managers/recording-manager";
 import type { RecordingState } from "../../types/recording";
 import type { SettingsService } from "../../services/settings-service";
+import { runDataMigrations } from "../migrations/data-migrations";
 
 export class AppManager {
   private windowManager!: WindowManager;
@@ -131,6 +132,7 @@ export class AppManager {
 
   private async initializeDatabase(): Promise<void> {
     await initializeDatabase();
+    await runDataMigrations();
     logger.db.info(
       "Database initialized and migrations completed successfully",
     );

apps/desktop/src/main/migrations/data-migrations.ts

@@ -0,0 +1,91 @@
+import * as Y from "yjs";
+import { logger } from "../logger";
+import { getAppSettings, updateAppSettings } from "../../db/app-settings";
+import {
+  getUniqueNoteIds,
+  getYjsUpdatesByNoteId,
+  replaceYjsUpdates,
+} from "../../db/notes";
+import {
+  isLexicalEditorStateJsonString,
+  serializePlainTextToLexicalEditorStateJson,
+} from "../../services/notes/lexical-editor-state";
+
+const NOTES_LEXICAL_MIGRATION_VERSION = 1;
+
+async function migrateNotesToLexicalEditorState(): Promise<{
+  notesChecked: number;
+  notesMigrated: number;
+}> {
+  const noteIds = await getUniqueNoteIds();
+  let notesMigrated = 0;
+
+  for (const noteId of noteIds) {
+    const updates = await getYjsUpdatesByNoteId(noteId);
+    if (updates.length === 0) continue;
+
+    const ydoc = new Y.Doc();
+    for (const update of updates) {
+      const updateArray = new Uint8Array(update.updateData as Buffer);
+      Y.applyUpdate(ydoc, updateArray);
+    }
+
+    const yText = ydoc.getText("content");
+    const storedContent = yText.toString();
+
+    if (!storedContent) continue;
+    if (isLexicalEditorStateJsonString(storedContent)) continue;
+
+    const migratedJson =
+      serializePlainTextToLexicalEditorStateJson(storedContent);
+
+    ydoc.transact(() => {
+      yText.delete(0, yText.length);
+      yText.insert(0, migratedJson);
+    }, "notes-lexical-migration");
+
+    const stateUpdate = Y.encodeStateAsUpdate(ydoc);
+    await replaceYjsUpdates(noteId, stateUpdate);
+    notesMigrated++;
+  }
+
+  return {
+    notesChecked: noteIds.length,
+    notesMigrated,
+  };
+}
+
+export async function runDataMigrations(): Promise<void> {
+  try {
+    const settings = await getAppSettings();
+    const currentVersion = settings.dataMigrations?.notesLexical ?? 0;
+
+    if (currentVersion >= NOTES_LEXICAL_MIGRATION_VERSION) {
+      return;
+    }
+
+    const startTime = Date.now();
+    logger.db.info("Running data migrations", {
+      notesLexicalFrom: currentVersion,
+      notesLexicalTo: NOTES_LEXICAL_MIGRATION_VERSION,
+    });
+
+    const { notesChecked, notesMigrated } =
+      await migrateNotesToLexicalEditorState();
+
+    await updateAppSettings({
+      dataMigrations: {
+        ...(settings.dataMigrations ?? {}),
+        notesLexical: NOTES_LEXICAL_MIGRATION_VERSION,
+      },
+    });
+
+    logger.db.info("Data migrations complete", {
+      notesChecked,
+      notesMigrated,
+      durationMs: Date.now() - startTime,
+    });
+  } catch (error) {
+    logger.db.error("Data migrations failed", error);
+  }
+}

apps/desktop/src/main/preload.ts

@@ -110,7 +110,10 @@ const api: ElectronAPI = {
     }),
   },
 
-  // External link handling
+  // External link handling.
+  // Prefer proxying through main (shell.openExternal) instead of `window.open()` from
+  // the renderer, because Chromium can block popups unless the call is made
+  // synchronously in direct response to a user gesture (click/keypress).
   openExternal: (url: string) => ipcRenderer.invoke("open-external", url),
 
   // Notes API - Yjs synchronization only

apps/desktop/src/renderer/main/components/create-note-button.tsx

@@ -47,7 +47,6 @@ export function CreateNoteButton() {
     });
     createNoteMutation.mutate({
       title: t("settings.notes.defaultTitleWithDate", { date: dateStr }),
-      initialContent: "",
     });
   }, [createNoteMutation, i18n.language, t]);
 

apps/desktop/src/renderer/main/components/editor/yjs-sync-plugin.tsx

@@ -1,10 +1,7 @@
 import { useEffect, useRef, useMemo, useCallback } from "react";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
-import { $createParagraphNode, $createTextNode, $getRoot } from "lexical";
 import type * as Y from "yjs";
-import { toast } from "sonner";
 import { debounce } from "@/renderer/main/utils/debounce";
-import { useTranslation } from "react-i18next";
 
 interface YjsSyncPluginProps {
   yText: Y.Text;
@@ -15,11 +12,9 @@ export function YjsSyncPlugin({
   yText,
   onSyncStatusChange,
 }: YjsSyncPluginProps): null {
-  const { t } = useTranslation();
   const [editor] = useLexicalComposerContext();
   const isUpdatingFromYjsRef = useRef(false);
   const isUpdatingFromLexicalRef = useRef(false);
-  const isMigratingRef = useRef(false);
   const hasPendingRef = useRef(false);
   const pendingJsonRef = useRef<string | null>(null);
   const onSyncStatusChangeRef = useRef(onSyncStatusChange);
@@ -31,7 +26,7 @@ export function YjsSyncPlugin({
 
   const writeJsonToYjs = useCallback(
     (jsonString: string) => {
-      if (isUpdatingFromYjsRef.current || isMigratingRef.current) {
+      if (isUpdatingFromYjsRef.current) {
         onSyncStatusChangeRef.current?.(false);
         return;
       }
@@ -73,63 +68,20 @@ export function YjsSyncPlugin({
       }
     };
 
-    const migrateLegacyText = (legacyText: string) => {
-      isMigratingRef.current = true;
-      isUpdatingFromYjsRef.current = true;
-
-      editor.update(() => {
-        const root = $getRoot();
-        root.clear();
-
-        const lines = legacyText.split(/\r?\n/);
-        lines.forEach((line) => {
-          const paragraph = $createParagraphNode();
-          if (line.length > 0) {
-            paragraph.append($createTextNode(line));
-          }
-          root.append(paragraph);
-        });
-      });
-
-      isUpdatingFromYjsRef.current = false;
-
-      const migratedJson = JSON.stringify(editor.getEditorState().toJSON());
-      const yDoc = yText.doc;
-
-      if (yDoc) {
-        isUpdatingFromLexicalRef.current = true;
-        yDoc.transact(() => {
-          const oldLength = yText.length;
-          yText.delete(0, oldLength);
-          yText.insert(0, migratedJson);
-        }, "migration");
-        isUpdatingFromLexicalRef.current = false;
-      }
-
-      toast.success(t("settings.notes.toast.upgradedToRichNotes"));
-
-      isMigratingRef.current = false;
-    };
-
     // Set initial content from Yjs (stored as JSON)
     const storedContent = yText.toString();
     if (storedContent) {
       try {
         setEditorStateFromJson(storedContent);
       } catch (error) {
-        // If parsing fails (e.g., old plain text content), migrate to Lexical JSON
-        console.warn(
-          "Failed to parse stored content as JSON, may be legacy format:",
-          error,
-        );
-        migrateLegacyText(storedContent);
+        console.warn("Failed to parse stored content as editor state:", error);
       }
     }
     onSyncStatusChangeRef.current?.(false);
 
     // Observer for Yjs changes -> Lexical
     const yjsObserver = () => {
-      if (isUpdatingFromLexicalRef.current || isMigratingRef.current) return;
+      if (isUpdatingFromLexicalRef.current) return;
 
       const newContent = yText.toString();
 
@@ -153,7 +105,6 @@ export function YjsSyncPlugin({
         // Skip if triggered by Yjs sync or no actual changes
         if (
           isUpdatingFromYjsRef.current ||
-          isMigratingRef.current ||
           (dirtyElements.size === 0 && dirtyLeaves.size === 0)
         ) {
           return;

apps/desktop/src/services/notes-service.ts

@@ -17,7 +17,6 @@ import { logger } from "../main/logger";
 
 export interface NoteCreateOptions {
   title: string;
-  initialContent?: string;
   icon?: string | null;
 }
 
@@ -83,17 +82,6 @@ class NotesService {
       icon: options.icon,
     });
 
-    // Initialize yjs document with initial content if provided
-    if (options.initialContent) {
-      const ydoc = new Y.Doc();
-      const text = ydoc.getText("content");
-      text.insert(0, options.initialContent);
-
-      // Save initial content as a YJS update
-      const initialUpdate = Y.encodeStateAsUpdate(ydoc);
-      await saveYjsUpdateToDB(note.id, initialUpdate);
-    }
-
     return note;
   }
 

apps/desktop/src/services/notes/lexical-editor-state.ts

@@ -0,0 +1,93 @@
+type SerializedTextNode = {
+  type: "text";
+  version: 1;
+  text: string;
+  detail: 0;
+  format: 0;
+  mode: "normal";
+  style: "";
+};
+
+type SerializedParagraphNode = {
+  type: "paragraph";
+  version: 1;
+  children: SerializedTextNode[];
+  direction: null;
+  format: "";
+  indent: 0;
+};
+
+type SerializedRootNode = {
+  type: "root";
+  version: 1;
+  children: SerializedParagraphNode[];
+  direction: null;
+  format: "";
+  indent: 0;
+};
+
+type SerializedEditorState = {
+  root: SerializedRootNode;
+};
+
+export function isLexicalEditorStateJsonString(value: string): boolean {
+  if (!value) return false;
+
+  try {
+    const parsed = JSON.parse(value) as Partial<SerializedEditorState> | null;
+    const root =
+      parsed && typeof parsed === "object"
+        ? (parsed as Partial<SerializedEditorState>).root
+        : undefined;
+
+    return !!(
+      root &&
+      typeof root === "object" &&
+      root.type === "root" &&
+      Array.isArray(root.children)
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function serializePlainTextToLexicalEditorStateJson(
+  plainText: string,
+): string {
+  const lines = plainText.split(/\r?\n/);
+
+  const paragraphs: SerializedParagraphNode[] = lines.map((line) => ({
+    type: "paragraph",
+    version: 1,
+    direction: null,
+    format: "",
+    indent: 0,
+    children:
+      line.length > 0
+        ? [
+            {
+              type: "text",
+              version: 1,
+              text: line,
+              detail: 0,
+              format: 0,
+              mode: "normal",
+              style: "",
+            },
+          ]
+        : [],
+  }));
+
+  const state: SerializedEditorState = {
+    root: {
+      type: "root",
+      version: 1,
+      direction: null,
+      format: "",
+      indent: 0,
+      children: paragraphs,
+    },
+  };
+
+  return JSON.stringify(state);
+}

apps/desktop/src/trpc/routers/notes.ts

@@ -20,7 +20,6 @@ const GetNotesSchema = z.object({
 
 const CreateNoteSchema = z.object({
   title: z.string().min(1),
-  initialContent: z.string().optional(),
   icon: z.string().nullish(),
 });
 
@@ -62,7 +61,6 @@ export const notesRouter = createRouter({
   createNote: procedure.input(CreateNoteSchema).mutation(async ({ input }) => {
     const note = await notesService.createNote({
       title: input.title,
-      initialContent: input.initialContent || "",
       icon: input.icon,
     });
 
@@ -71,7 +69,7 @@ export const notesRouter = createRouter({
       ServiceManager.getInstance().getService("telemetryService");
     telemetryService.trackNoteCreated({
       note_id: note.id,
-      has_initial_content: !!input.initialContent,
+      has_initial_content: false,
       has_icon: !!input.icon,
     });