fix(saved-sql): avoid full directory rewrites

Closes #4300

apps/desktop/src/lib/backend/api.ts

@@ -124,6 +124,7 @@ export async function reinstallJre(jreKey?: string, operationId?: string) {
 export const uninstallJre = forward("uninstallJre");
 export const listenAgentInstallProgress = forward("listenAgentInstallProgress");
 export const loadSavedSqlLibrary = forward("loadSavedSqlLibrary");
+export const loadSavedSqlFilesForSync = forward("loadSavedSqlFilesForSync");
 export const loadSavedSqlFile = forward("loadSavedSqlFile");
 export const saveSavedSqlFolder = forward("saveSavedSqlFolder");
 export const deleteSavedSqlFolder = forward("deleteSavedSqlFolder");

apps/desktop/src/lib/backend/http.ts

@@ -651,6 +651,10 @@ export async function loadSavedSqlLibrary(): Promise<SavedSqlLibrary> {
   return get("/api/saved-sql");
 }
 
+export async function loadSavedSqlFilesForSync(): Promise<SavedSqlFile[]> {
+  throw new Error("SQL directory sync is only available in the desktop app.");
+}
+
 export async function loadSavedSqlFile(id: string): Promise<SavedSqlFile | null> {
   return get(`/api/saved-sql/${encodeURIComponent(id)}`);
 }

apps/desktop/src/lib/backend/tauri.ts

@@ -1942,6 +1942,10 @@ export async function loadSavedSqlLibrary(): Promise<SavedSqlLibrary> {
   return invoke("load_saved_sql_library");
 }
 
+export async function loadSavedSqlFilesForSync(): Promise<SavedSqlFile[]> {
+  return invoke("load_saved_sql_files_for_sync");
+}
+
 export async function loadSavedSqlFile(id: string): Promise<SavedSqlFile | null> {
   return invoke("load_saved_sql_file", { id });
 }

apps/desktop/src/stores/__tests__/savedSqlStore.sync.spec.ts

@@ -0,0 +1,123 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "@/lib/backend/api";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+
+const mocks = vi.hoisted(() => ({
+  syncDir: { value: "/workspace/dbx-sql-sync" as string | null },
+}));
+
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => true }));
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    desktopSettings: { saved_sql_sync_dir: mocks.syncDir.value },
+  }),
+}));
+vi.mock("@/lib/backend/api", () => ({
+  loadSavedSqlLibrary: vi.fn(),
+  loadSavedSqlFilesForSync: vi.fn(),
+  loadSavedSqlFile: vi.fn(),
+  saveSavedSqlFile: vi.fn(),
+  syncSavedSqlDirectory: vi.fn(),
+}));
+
+function library(sqlLoaded: boolean) {
+  return {
+    folders: [
+      {
+        id: "folder-1",
+        connectionId: "connection-1",
+        name: "Reports",
+        orderIndex: 0,
+        createdAt: "2026-08-14T00:00:00.000Z",
+        updatedAt: "2026-08-14T00:00:00.000Z",
+      },
+    ],
+    files: [
+      {
+        id: "file-1",
+        connectionId: "connection-1",
+        folderId: "folder-1",
+        name: "daily.sql",
+        database: "",
+        sql: sqlLoaded ? "SELECT 1;" : "",
+        sqlLoaded,
+        orderIndex: 0,
+        openCount: 0,
+        createdAt: "2026-08-14T00:00:00.000Z",
+        updatedAt: "2026-08-14T00:00:00.000Z",
+      },
+      {
+        id: "file-2",
+        connectionId: "connection-1",
+        folderId: "folder-1",
+        name: "weekly.sql",
+        database: "",
+        sql: sqlLoaded ? "SELECT 7;" : "",
+        sqlLoaded,
+        orderIndex: 1,
+        openCount: 0,
+        createdAt: "2026-08-14T00:00:00.000Z",
+        updatedAt: "2026-08-14T00:00:00.000Z",
+      },
+    ],
+  };
+}
+
+describe("savedSqlStore directory sync", () => {
+  beforeEach(() => {
+    const storage = new Map<string, string>();
+    vi.stubGlobal("localStorage", {
+      getItem: (key: string) => storage.get(key) ?? null,
+      setItem: (key: string, value: string) => storage.set(key, value),
+      removeItem: (key: string) => storage.delete(key),
+      clear: () => storage.clear(),
+    });
+    setActivePinia(createPinia());
+    vi.clearAllMocks();
+    mocks.syncDir.value = "/workspace/dbx-sql-sync";
+    vi.mocked(api.loadSavedSqlLibrary).mockResolvedValue(library(false));
+    vi.mocked(api.loadSavedSqlFilesForSync).mockResolvedValue(library(true).files);
+    vi.mocked(api.saveSavedSqlFile).mockImplementation(async (file) => file);
+    vi.mocked(api.syncSavedSqlDirectory).mockResolvedValue(undefined);
+  });
+
+  it("hydrates an unloaded library with one batch request and reuses it", async () => {
+    const store = useSavedSqlStore();
+    await store.initFromStorage();
+
+    await store.syncToLocalDirectory();
+    await store.syncToLocalDirectory();
+
+    expect(api.loadSavedSqlFilesForSync).toHaveBeenCalledTimes(1);
+    expect(api.loadSavedSqlFile).not.toHaveBeenCalled();
+    expect(api.syncSavedSqlDirectory).toHaveBeenCalledTimes(2);
+    expect(api.syncSavedSqlDirectory).toHaveBeenLastCalledWith({
+      targetDir: "/workspace/dbx-sql-sync",
+      entries: [
+        { folderName: "Reports", fileName: "daily.sql", sql: "SELECT 1;" },
+        { folderName: "Reports", fileName: "weekly.sql", sql: "SELECT 7;" },
+      ],
+    });
+  });
+
+  it("does not add a sync read or request when directory sync is disabled", async () => {
+    mocks.syncDir.value = null;
+    const store = useSavedSqlStore();
+    await store.initFromStorage();
+
+    await store.saveFile({
+      id: "file-1",
+      connectionId: "connection-1",
+      folderId: "folder-1",
+      name: "daily.sql",
+      database: "",
+      sql: "SELECT 2;",
+    });
+
+    expect(api.saveSavedSqlFile).toHaveBeenCalledTimes(1);
+    expect(api.loadSavedSqlFilesForSync).not.toHaveBeenCalled();
+    expect(api.loadSavedSqlFile).not.toHaveBeenCalled();
+    expect(api.syncSavedSqlDirectory).not.toHaveBeenCalled();
+  });
+});

apps/desktop/src/stores/savedSqlStore.ts

@@ -577,6 +577,17 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
   }
 
   async function syncEntries() {
+    if (files.value.some((file) => file.sqlLoaded === false)) {
+      const loadedFiles = await api.loadSavedSqlFilesForSync();
+      const loadedById = new Map(loadedFiles.map((file) => [file.id, file]));
+      files.value = files.value.map((file) => {
+        if (file.sqlLoaded !== false) return file;
+        const loaded = loadedById.get(file.id);
+        return loaded ? { ...file, sql: loaded.sql, sqlLoaded: true } : file;
+      });
+      bumpVersion();
+    }
+
     const folderById = new Map(folders.value.map((folder) => [folder.id, folder]));
     const folderPath = (folderId?: string): string | undefined => {
       if (!folderId) return undefined;
@@ -590,14 +601,14 @@ export const useSavedSqlStore = defineStore("savedSql", () => {
       }
       return parts.join("/");
     };
-    const loadedFiles = await Promise.all(sortFilesByOrder(files.value).map((file) => ensureFileContent(file.id)));
-    return loadedFiles
-      .filter((file): file is SavedSqlFile => Boolean(file))
-      .map((file) => ({
-        folderName: folderPath(file.folderId),
-        fileName: file.name,
-        sql: file.sql,
-      }));
+    const unloadedFile = files.value.find((file) => file.sqlLoaded === false);
+    if (unloadedFile) throw new Error(`Saved SQL file '${unloadedFile.id}' could not be loaded for directory sync.`);
+
+    return sortFilesByOrder(files.value).map((file) => ({
+      folderName: folderPath(file.folderId),
+      fileName: file.name,
+      sql: file.sql,
+    }));
   }
 
   async function syncToLocalDirectory() {