Refactor frontend message handling to consolidate auto-save document loading

Author: Keavon

desktop/src/app.rs

@@ -314,39 +314,25 @@ impl App {
 					responses.push(message);
 				}
 			}
-			DesktopFrontendMessage::PersistenceLoadCurrentDocument => {
-				if let Some((id, document)) = self.persistent_data.current_document() {
-					let message = DesktopWrapperMessage::LoadDocument {
-						id,
-						document,
-						to_front: false,
-						select_after_open: true,
-					};
-					responses.push(message);
-				}
-			}
-			DesktopFrontendMessage::PersistenceLoadRemainingDocuments => {
-				for (id, document) in self.persistent_data.documents_before_current().into_iter().rev() {
-					let message = DesktopWrapperMessage::LoadDocument {
-						id,
-						document,
-						to_front: true,
-						select_after_open: false,
-					};
-					responses.push(message);
-				}
-				for (id, document) in self.persistent_data.documents_after_current() {
-					let message = DesktopWrapperMessage::LoadDocument {
+			DesktopFrontendMessage::PersistenceLoadDocuments => {
+				let current_id = self.persistent_data.current_document_id();
+				let mut seen_current = false;
+
+				for (id, document) in self.persistent_data.all_documents() {
+					let is_current = current_id == Some(id);
+					let to_front = !seen_current && !is_current;
+					seen_current |= is_current;
+
+					responses.push(DesktopWrapperMessage::LoadDocument {
 						id,
 						document,
-						to_front: false,
+						to_front,
 						select_after_open: false,
-					};
-					responses.push(message);
+					});
 				}
-				if let Some(id) = self.persistent_data.current_document_id() {
-					let message = DesktopWrapperMessage::SelectDocument { id };
-					responses.push(message);
+
+				if let Some(id) = current_id {
+					responses.push(DesktopWrapperMessage::SelectDocument { id });
 				}
 			}
 			DesktopFrontendMessage::OpenLaunchDocuments => {

desktop/src/cef/dirs.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use crate::dirs::{app_data_dir, ensure_dir_exists};
 
-static CEF_DIR_NAME: &str = "browser";
+static CEF_DIR_NAME: &str = "cef";
 
 pub(crate) fn delete_instance_dirs() {
 	let cef_dir = app_data_dir().join(CEF_DIR_NAME);

desktop/src/persist.rs

@@ -55,32 +55,8 @@ impl PersistentData {
 		}
 	}
 
-	pub(crate) fn current_document(&self) -> Option<(DocumentId, Document)> {
-		let current_id = self.current_document_id()?;
-		Some((current_id, self.read_document(&current_id)?))
-	}
-
-	pub(crate) fn documents_before_current(&self) -> Vec<(DocumentId, Document)> {
-		let Some(current_id) = self.current_document_id() else {
-			return Vec::new();
-		};
-		self.documents
-			.iter()
-			.take_while(|doc| doc.id != current_id)
-			.filter_map(|doc| Some((doc.id, self.read_document(&doc.id)?)))
-			.collect()
-	}
-
-	pub(crate) fn documents_after_current(&self) -> Vec<(DocumentId, Document)> {
-		let Some(current_id) = self.current_document_id() else {
-			return Vec::new();
-		};
-		self.documents
-			.iter()
-			.skip_while(|doc| doc.id != current_id)
-			.skip(1)
-			.filter_map(|doc| Some((doc.id, self.read_document(&doc.id)?)))
-			.collect()
+	pub(crate) fn all_documents(&self) -> Vec<(DocumentId, Document)> {
+		self.documents.iter().filter_map(|doc| Some((doc.id, self.read_document(&doc.id)?))).collect()
 	}
 
 	pub(crate) fn set_current_document(&mut self, id: DocumentId) {
@@ -154,6 +130,32 @@ impl PersistentData {
 			}
 		};
 		*self = loaded;
+
+		self.garbage_collect_document_files();
+	}
+
+	// Remove orphaned document content files that have no corresponding entry in the persisted state
+	fn garbage_collect_document_files(&self) {
+		let valid_paths: std::collections::HashSet<_> = self.documents.iter().map(|doc| Self::document_content_path(&doc.id)).collect();
+
+		let directory = crate::dirs::app_autosave_documents_dir();
+		let entries = match std::fs::read_dir(&directory) {
+			Ok(entries) => entries,
+			Err(e) if e.kind() == std::io::ErrorKind::NotFound => return,
+			Err(e) => {
+				tracing::error!("Failed to read autosave documents directory: {e}");
+				return;
+			}
+		};
+
+		for entry in entries.flatten() {
+			let path = entry.path();
+			if path.is_file() && !valid_paths.contains(&path) {
+				if let Err(e) = std::fs::remove_file(&path) {
+					tracing::error!("Failed to remove orphaned document file {path:?}: {e}");
+				}
+			}
+		}
 	}
 
 	fn state_file_path() -> std::path::PathBuf {

desktop/wrapper/src/intercept_frontend_message.rs

@@ -95,11 +95,8 @@ pub(super) fn intercept_frontend_message(dispatcher: &mut DesktopWrapperMessageD
 			// Forward this to update the UI
 			return Some(FrontendMessage::UpdateOpenDocumentsList { open_documents });
 		}
-		FrontendMessage::TriggerLoadFirstAutoSaveDocument => {
-			dispatcher.respond(DesktopFrontendMessage::PersistenceLoadCurrentDocument);
-		}
-		FrontendMessage::TriggerLoadRestAutoSaveDocuments => {
-			dispatcher.respond(DesktopFrontendMessage::PersistenceLoadRemainingDocuments);
+		FrontendMessage::TriggerLoadAutoSaveDocuments => {
+			dispatcher.respond(DesktopFrontendMessage::PersistenceLoadDocuments);
 		}
 		FrontendMessage::TriggerOpenLaunchDocuments => {
 			dispatcher.respond(DesktopFrontendMessage::OpenLaunchDocuments);

desktop/wrapper/src/messages.rs

@@ -50,8 +50,7 @@ pub enum DesktopFrontendMessage {
 	PersistenceUpdateCurrentDocument {
 		id: DocumentId,
 	},
-	PersistenceLoadCurrentDocument,
-	PersistenceLoadRemainingDocuments,
+	PersistenceLoadDocuments,
 	PersistenceUpdateDocumentsList {
 		ids: Vec<DocumentId>,
 	},

editor/src/messages/frontend/frontend_message.rs

@@ -123,8 +123,7 @@ pub enum FrontendMessage {
 		document: String,
 		details: DocumentDetails,
 	},
-	TriggerLoadFirstAutoSaveDocument,
-	TriggerLoadRestAutoSaveDocuments,
+	TriggerLoadAutoSaveDocuments,
 	TriggerOpenLaunchDocuments,
 	TriggerLoadPreferences,
 	TriggerLoadWorkspaceLayout,

editor/src/messages/portfolio/portfolio_message_handler.rs

@@ -109,20 +109,20 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 				// Before loading any documents, initially prepare the welcome screen buttons layout
 				responses.add(PortfolioMessage::RequestWelcomeScreenButtonsLayout);
 
-				// Tell frontend to load the current document
-				responses.add(FrontendMessage::TriggerLoadFirstAutoSaveDocument);
+				// Tell frontend to load persistent auto-saved documents (placed early so IndexedDB reads overlap with subsequent UI setup)
+				responses.add(FrontendMessage::TriggerLoadAutoSaveDocuments);
+
+				// Tell frontend to load documents passed in as launch arguments
+				responses.add(FrontendMessage::TriggerOpenLaunchDocuments);
 
 				// Display the menu bar at the top of the window
 				responses.add(MenuBarMessage::SendLayout);
 
 				// Send the initial workspace panel layout to the frontend
 				responses.add(PortfolioMessage::UpdateWorkspacePanelLayout);
 
-				// Send the information for tooltips and categories for each node/input.
-				responses.add(FrontendMessage::SendUIMetadata {
-					node_descriptions: document_node_definitions::collect_node_descriptions(),
-					node_types: document_node_definitions::collect_node_types(),
-				});
+				// Request status bar info layout
+				responses.add(PortfolioMessage::RequestStatusBarInfoLayout);
 
 				// Send shortcuts for widgets created in the frontend which need shortcut tooltips
 				responses.add(FrontendMessage::SendShortcutFullscreen {
@@ -136,14 +136,11 @@ impl MessageHandler<PortfolioMessage, PortfolioMessageContext<'_>> for Portfolio
 					shortcut: action_shortcut_manual!(Key::Shift, Key::MouseLeft),
 				});
 
-				// Request status bar info layout
-				responses.add(PortfolioMessage::RequestStatusBarInfoLayout);
-
-				// Tell frontend to finish loading persistent documents
-				responses.add(FrontendMessage::TriggerLoadRestAutoSaveDocuments);
-
-				// Tell frontend to load documented passed in as launch arguments
-				responses.add(FrontendMessage::TriggerOpenLaunchDocuments);
+				// Send the information for tooltips and categories for each node/input.
+				responses.add(FrontendMessage::SendUIMetadata {
+					node_descriptions: document_node_definitions::collect_node_descriptions(),
+					node_types: document_node_definitions::collect_node_types(),
+				});
 			}
 			PortfolioMessage::DocumentPassMessage { document_id, message } => {
 				if let Some(document) = self.documents.get_mut(&document_id) {

frontend/src/managers/persistence.ts

@@ -7,8 +7,7 @@ import {
 	loadWorkspaceLayout,
 	storeDocument,
 	removeDocument,
-	loadFirstDocument,
-	loadRestDocuments,
+	loadDocuments,
 	saveActiveDocument,
 } from "/src/utility-functions/persistence";
 import type { EditorWrapper } from "/wrapper/pkg/graphite_wasm_wrapper";
@@ -48,12 +47,8 @@ export function createPersistenceManager(subscriptions: SubscriptionsRouter, edi
 		await removeDocument(String(data.documentId), portfolio);
 	});
 
-	subscriptions.subscribeFrontendMessage("TriggerLoadFirstAutoSaveDocument", async () => {
-		await loadFirstDocument(editor);
-	});
-
-	subscriptions.subscribeFrontendMessage("TriggerLoadRestAutoSaveDocuments", async () => {
-		await loadRestDocuments(editor);
+	subscriptions.subscribeFrontendMessage("TriggerLoadAutoSaveDocuments", async () => {
+		await loadDocuments(editor);
 	});
 
 	subscriptions.subscribeFrontendMessage("TriggerOpenLaunchDocuments", async () => {
@@ -75,8 +70,7 @@ export function destroyPersistenceManager() {
 	subscriptions.unsubscribeFrontendMessage("TriggerLoadWorkspaceLayout");
 	subscriptions.unsubscribeFrontendMessage("TriggerPersistenceWriteDocument");
 	subscriptions.unsubscribeFrontendMessage("TriggerPersistenceRemoveDocument");
-	subscriptions.unsubscribeFrontendMessage("TriggerLoadFirstAutoSaveDocument");
-	subscriptions.unsubscribeFrontendMessage("TriggerLoadRestAutoSaveDocuments");
+	subscriptions.unsubscribeFrontendMessage("TriggerLoadAutoSaveDocuments");
 	subscriptions.unsubscribeFrontendMessage("TriggerOpenLaunchDocuments");
 	subscriptions.unsubscribeFrontendMessage("TriggerSaveActiveDocument");
 }

frontend/src/utility-functions/persistence.ts

@@ -119,62 +119,30 @@ export async function removeDocument(id: string, portfolio: PortfolioStore) {
 	});
 }
 
-export async function loadFirstDocument(editor: EditorWrapper) {
+export async function loadDocuments(editor: EditorWrapper) {
 	await migrateToNewFormat();
 	await garbageCollectDocuments();
 
 	const state = await databaseGet<PersistedState>("state");
 	const documentContents = await databaseGet<Record<string, string>>("documents");
 	if (!state || !documentContents || state.documents.length === 0) return;
 
-	// Find and open the current document (or fall back to the last document in the list)
+	// Find the current document (or fall back to the last document in the list)
 	const currentId = state.current_document;
 	const currentEntry = currentId !== undefined ? state.documents.find((doc) => doc.id === currentId) : undefined;
-	const entryToOpen = currentEntry || state.documents[state.documents.length - 1];
-
-	const content = documentContents[String(entryToOpen.id)];
-	if (content === undefined) return;
-
-	editor.openAutoSavedDocument(entryToOpen.id, entryToOpen.name, entryToOpen.is_saved, content, false);
-	editor.selectDocument(entryToOpen.id);
-}
-
-export async function loadRestDocuments(editor: EditorWrapper) {
-	const state = await databaseGet<PersistedState>("state");
-	const documentContents = await databaseGet<Record<string, string>>("documents");
-	if (!state || !documentContents || state.documents.length === 0) return;
-
-	const currentId = state.current_document;
-	const currentIndex = currentId !== undefined ? state.documents.findIndex((doc) => doc.id === currentId) : -1;
+	const current = currentEntry || state.documents[state.documents.length - 1];
+	const currentIndex = state.documents.indexOf(current);
 
 	// Open documents in order around the current document, placing earlier ones before it and later ones after
-	if (currentIndex !== -1 && currentId !== undefined) {
-		for (let i = currentIndex - 1; i >= 0; i--) {
-			const entry = state.documents[i];
-			const content = documentContents[String(entry.id)];
-			if (content !== undefined) editor.openAutoSavedDocument(entry.id, entry.name, entry.is_saved, content, true);
-		}
-
-		for (let i = currentIndex + 1; i < state.documents.length; i++) {
-			const entry = state.documents[i];
-			const content = documentContents[String(entry.id)];
-			if (content !== undefined) editor.openAutoSavedDocument(entry.id, entry.name, entry.is_saved, content, false);
-		}
+	state.documents.forEach((entry, index) => {
+		const content = documentContents[String(entry.id)];
+		if (content === undefined) return;
 
-		editor.selectDocument(currentId);
-	}
-	// No valid current document: open all remaining documents and select the last one
-	else {
-		const length = state.documents.length;
-
-		for (let i = length - 2; i >= 0; i--) {
-			const entry = state.documents[i];
-			const content = documentContents[String(entry.id)];
-			if (content !== undefined) editor.openAutoSavedDocument(entry.id, entry.name, entry.is_saved, content, true);
-		}
+		const toFront = index < currentIndex;
+		editor.openAutoSavedDocument(entry.id, entry.name, entry.is_saved, content, toFront);
+	});
 
-		if (length > 0) editor.selectDocument(state.documents[length - 1].id);
-	}
+	editor.selectDocument(current.id);
 }
 
 export async function saveActiveDocument(documentId: bigint) {
@@ -244,7 +212,7 @@ async function wipeOldFormat() {
 }
 
 // TODO: Eventually remove this document upgrade code
-export async function migrateToNewFormat() {
+async function migrateToNewFormat() {
 	// Detect the old format by checking for the existence of the "documents_tab_order" key
 	const oldTabOrder = await databaseGet<string[]>("documents_tab_order");
 	if (oldTabOrder === undefined) return;