Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

feat(sql-file): add search filtering and name sorting to SQL file panel (#12795) (#12840)

lxk955f9957f1f8a3f
diff --git a/apps/desktop/src/components/layout/SqlFilePanel.vue b/apps/desktop/src/components/layout/SqlFilePanel.vue
index 7e903814ce..59d5242967 100644
--- a/apps/desktop/src/components/layout/SqlFilePanel.vue
+++ b/apps/desktop/src/components/layout/SqlFilePanel.vue
@@ -1,7 +1,7 @@
<script setup lang="ts">
-import { ref, computed, nextTick, onMounted } from "vue";
+import { ref, computed, nextTick, onMounted, watch } from "vue";
import { useI18n } from "vue-i18n";
-import { FolderOpen, FolderClosed, FileCode, FolderPlus, ChevronRight, ChevronDown, X, Trash2, RefreshCw, FolderSearch, Copy, Play, ChevronsUpDown, ChevronsDownUp, Settings, FilePlus, Pencil } from "@lucide/vue";
+import { FolderOpen, FolderClosed, FileCode, FolderPlus, ChevronRight, ChevronDown, X, Trash2, RefreshCw, FolderSearch, Copy, Play, ChevronsUpDown, ChevronsDownUp, Settings, FilePlus, Pencil, Search, ArrowDownAZ, ArrowUpAZ } from "@lucide/vue";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
@@ -22,6 +22,7 @@ import { externalSqlFileOpenErrorMessage, externalSqlEditorMaxBytes, formatSqlFi
import * as api from "@/lib/backend/api";
import type { SqlFileEntry } from "@/lib/backend/api";
import { getSqlFileFilter, getSqlFileFolderPaths, saveSqlFileFilter, saveSqlFileFolderPaths, notifySqlFileFoldersChanged } from "@/lib/sqlFile/sqlFileFolders";
+import { filterAndSortSqlFileEntries, getSqlFileSortOrder, saveSqlFileSortOrder, type SqlFileSortOrder } from "@/lib/sql/sqlFileTreeFilter";
import { orderedListRangeAnchorIndex, orderedListSelectionIntent, type OrderedListSelectionItem } from "@/lib/selection/orderedListSelection";
const emit = defineEmits<{
@@ -53,6 +54,26 @@ const filterSettingsOpen = ref(false);
const fileFilterDraft = ref(getSqlFileFilter());
const fileFilterRegexExample = "(?i)[.](sql|ddl|sh|py)$";
+const searchText = ref("");
+const searchQuery = computed(() => searchText.value.trim().toLowerCase());
+const sortOrder = ref<SqlFileSortOrder>(getSqlFileSortOrder ? getSqlFileSortOrder() : "asc");
+const userCollapsedDuringSearch = ref<Set<string>>(new Set());
+
+watch(searchQuery, () => {
+ userCollapsedDuringSearch.value.clear();
+});
+
+function toggleSortOrder() {
+ const next = sortOrder.value === "asc" ? "desc" : "asc";
+ sortOrder.value = next;
+ saveSqlFileSortOrder?.(next);
+}
+
+function setSortOrder(order: SqlFileSortOrder) {
+ sortOrder.value = order;
+ saveSqlFileSortOrder?.(order);
+}
+
// Right-click target. `kind` discriminates between a folder header, a tree
// directory entry, and a tree file entry. `folderPath` is the owning top-level
// folder (for refresh scoping); `entryPath` is the right-clicked node path.
@@ -103,6 +124,13 @@ const activeFileTarget = computed(() => {
async function locateActiveFile() {
const target = activeFileTarget.value;
if (!target) return;
+ if (searchText.value) {
+ const isVisibleNow = visibleItems.value.some((item) => item.type === "file" && normalizeExternalSqlPath(item.id) === target.path);
+ if (!isVisibleNow) {
+ searchText.value = "";
+ await nextTick();
+ }
+ }
target.folder.collapsed = false;
target.folder.expanded = new Set([...target.folder.expanded, ...target.ancestors]);
const itemIndex = visibleItems.value.findIndex((item) => item.type === "file" && normalizeExternalSqlPath(item.id) === target.path);
@@ -310,18 +338,90 @@ async function copyPath(path: string) {
}
}
+interface ProcessedFolder {
+ entries: SqlFileEntry[];
+ autoExpanded: Set<string>;
+ hasMatches: boolean;
+}
+
+const folderProcessedMap = computed<Map<string, ProcessedFolder>>(() => {
+ const map = new Map<string, ProcessedFolder>();
+ for (const folder of folders.value) {
+ const res = filterAndSortSqlFileEntries(folder.entries, searchQuery.value, sortOrder.value);
+ map.set(folder.path, {
+ entries: res.entries,
+ autoExpanded: res.autoExpanded,
+ hasMatches: res.matchCount > 0,
+ });
+ }
+ return map;
+});
+
+function getProcessedEntries(folderPath: string): SqlFileEntry[] {
+ return folderProcessedMap.value.get(folderPath)?.entries ?? [];
+}
+
+function isFolderContentVisible(folder: FolderState): boolean {
+ if (userCollapsedDuringSearch.value.has(folder.path)) {
+ return false;
+ }
+ if (searchQuery.value) {
+ const processed = folderProcessedMap.value.get(folder.path);
+ if (processed?.hasMatches) {
+ return true;
+ }
+ }
+ return !folder.collapsed;
+}
+
+function getEffectiveExpanded(folder: FolderState): Set<string> {
+ if (!searchQuery.value) {
+ return folder.expanded;
+ }
+ const processed = folderProcessedMap.value.get(folder.path);
+ const auto = processed?.autoExpanded ?? new Set<string>();
+ const combined = new Set<string>();
+ for (const p of folder.expanded) {
+ if (!userCollapsedDuringSearch.value.has(p)) combined.add(p);
+ }
+ for (const p of auto) {
+ if (!userCollapsedDuringSearch.value.has(p)) combined.add(p);
+ }
+ return combined;
+}
+
function toggleExpand(folder: FolderState, path: string) {
- const next = new Set(folder.expanded);
- if (next.has(path)) {
+ const effective = getEffectiveExpanded(folder);
+ const isExpanded = effective.has(path);
+ if (isExpanded) {
+ if (searchQuery.value) {
+ userCollapsedDuringSearch.value.add(path);
+ }
+ const next = new Set(folder.expanded);
next.delete(path);
+ folder.expanded = next;
} else {
+ if (searchQuery.value) {
+ userCollapsedDuringSearch.value.delete(path);
+ }
+ const next = new Set(folder.expanded);
next.add(path);
+ folder.expanded = next;
}
- folder.expanded = next;
}
function toggleFolderCollapse(folder: FolderState) {
- folder.collapsed = !folder.collapsed;
+ if (searchQuery.value) {
+ const currentlyVisible = isFolderContentVisible(folder);
+ if (currentlyVisible) {
+ userCollapsedDuringSearch.value.add(folder.path);
+ } else {
+ userCollapsedDuringSearch.value.delete(folder.path);
+ folder.collapsed = false;
+ }
+ } else {
+ folder.collapsed = !folder.collapsed;
+ }
}
// Expand/collapse every directory beneath the given top-level folder.
@@ -404,8 +504,8 @@ const visibleItems = computed<OrderedListSelectionItem[]>(() => {
const items: OrderedListSelectionItem[] = [];
for (const folder of folders.value) {
items.push({ type: "folderHeader", id: folder.path });
- if (folder.collapsed) continue;
- for (const { entry } of flatTree(folder.entries, folder.expanded)) {
+ if (!isFolderContentVisible(folder)) continue;
+ for (const { entry } of flatTree(getProcessedEntries(folder.path), getEffectiveExpanded(folder))) {
items.push({ type: entry.is_dir ? "dir" : "file", id: entry.path });
}
}
@@ -688,6 +788,15 @@ const contextMenuItems = computed<ContextMenuItem[]>(() => {
if (target.kind === "panel") {
const items: ContextMenuItem[] = [{ label: t("sqlFileTree.openFolder"), action: pickFolder, icon: FolderOpen }];
if (folders.value.length > 0) {
+ items.push({ label: "", separator: true });
+ items.push({
+ label: t("sqlLibrary.sortFiles"),
+ icon: ArrowDownAZ,
+ children: [
+ { label: t("sqlLibrary.sortNameAsc"), action: () => setSortOrder("asc"), icon: ArrowDownAZ },
+ { label: t("sqlLibrary.sortNameDesc"), action: () => setSortOrder("desc"), icon: ArrowUpAZ },
+ ],
+ });
items.push({ label: "", separator: true });
items.push({ label: t("sqlFileTree.refreshAll"), action: refreshAll, icon: RefreshCw });
}
@@ -707,6 +816,15 @@ const contextMenuItems = computed<ContextMenuItem[]>(() => {
{ label: t("sqlFileTree.expandAll"), action: () => folder && setAllExpanded(folder, true), icon: ChevronsUpDown, disabled: !folder },
{ label: t("sqlFileTree.collapseAll"), action: () => folder && setAllExpanded(folder, false), icon: ChevronsDownUp, disabled: !folder },
{ label: "", separator: true },
+ {
+ label: t("sqlLibrary.sortFiles"),
+ icon: ArrowDownAZ,
+ children: [
+ { label: t("sqlLibrary.sortNameAsc"), action: () => setSortOrder("asc"), icon: ArrowDownAZ },
+ { label: t("sqlLibrary.sortNameDesc"), action: () => setSortOrder("desc"), icon: ArrowUpAZ },
+ ],
+ },
+ { label: "", separator: true },
{ label: t("sqlFileTree.refreshFolder"), action: () => refreshFolder(target.folderPath), icon: RefreshCw },
{ label: "", separator: true },
{ label: t("sqlFileTree.removeFolder"), action: () => folderIdx !== -1 && removeFolder(folderIdx), icon: Trash2, variant: "destructive" },
@@ -724,6 +842,15 @@ const contextMenuItems = computed<ContextMenuItem[]>(() => {
{ label: t("sqlFileTree.expandAll"), action: () => expandSubtree(target), icon: ChevronsUpDown },
{ label: t("sqlFileTree.collapseAll"), action: () => collapseSubtree(target), icon: ChevronsDownUp },
{ label: "", separator: true },
+ {
+ label: t("sqlLibrary.sortFiles"),
+ icon: ArrowDownAZ,
+ children: [
+ { label: t("sqlLibrary.sortNameAsc"), action: () => setSortOrder("asc"), icon: ArrowDownAZ },
+ { label: t("sqlLibrary.sortNameDesc"), action: () => setSortOrder("desc"), icon: ArrowUpAZ },
+ ],
+ },
+ { label: "", separator: true },
{ label: t("sqlFileTree.renameFolder"), action: () => openRenameFolderDialog(target), icon: Pencil },
{ label: t("sqlFileTree.deleteFolder"), action: () => openDeleteFolderDialog(target), icon: Trash2, variant: "destructive" },
];
@@ -797,6 +924,12 @@ function clearContextTarget() {
<Settings class="h-3 w-3" />
</Button>
</LightTooltip>
+ <LightTooltip :text="sortOrder === 'asc' ? t('sqlLibrary.sortNameAsc') : t('sqlLibrary.sortNameDesc')" side="bottom" :delay="0" :close-delay="0" nowrap>
+ <Button data-sql-file-sort-btn variant="ghost" size="icon" class="h-5 w-5" @click="toggleSortOrder">
+ <ArrowDownAZ v-if="sortOrder === 'asc'" class="h-3 w-3" />
+ <ArrowUpAZ v-else class="h-3 w-3" />
+ </Button>
+ </LightTooltip>
<LightTooltip v-if="folders.length > 0" :text="t('sqlFileTree.refreshAll')" side="bottom" :delay="0" :close-delay="0" nowrap>
<Button variant="ghost" size="icon" class="h-5 w-5" @click="refreshAll">
<RefreshCw class="h-3 w-3" />
@@ -814,6 +947,16 @@ function clearContextTarget() {
</LightTooltip>
</div>
+ <div v-if="folders.length > 0" class="border-b shrink-0 px-2 py-1">
+ <div class="relative">
+ <Search class="absolute left-2 top-1/2 -translate-y-1/2 h-3 w-3 text-muted-foreground" />
+ <input data-sql-file-search v-model="searchText" autocapitalize="off" autocorrect="off" spellcheck="false" class="w-full h-6 pl-7 pr-6 text-[13px] rounded border border-border bg-background focus:outline-none focus:ring-1 focus:ring-ring" :placeholder="t('grid.search')" />
+ <button v-if="searchText" type="button" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="searchText = ''">
+ <X class="h-3 w-3" />
+ </button>
+ </div>
+ </div>
+
<CustomContextMenu :items="contextMenuItems" @close="clearContextTarget">
<template #default="{ onContextMenu }">
<div
@@ -849,7 +992,7 @@ function clearContextTarget() {
onContextMenu($event);
"
>
- <ChevronRight v-if="folder.collapsed" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+ <ChevronRight v-if="!isFolderContentVisible(folder)" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
<ChevronDown v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
<FolderOpen class="h-3.5 w-3.5 shrink-0 text-amber-500" />
<span class="truncate shrink-0" :title="folder.path">{{ folderName(folder.path) }}</span>
@@ -880,17 +1023,20 @@ function clearContextTarget() {
</Button>
</LightTooltip>
</div>
- <div v-show="!folder.collapsed">
+ <div v-show="isFolderContentVisible(folder)">
<div v-if="folder.loading" class="px-3 py-2 text-xs text-muted-foreground">
{{ t("sqlFileTree.loading") }}
</div>
<div v-else-if="folder.entries.length === 0" class="px-3 py-2 text-xs text-muted-foreground">
{{ t("sqlFileTree.noSqlFiles") }}
</div>
+ <div v-else-if="searchQuery && getProcessedEntries(folder.path).length === 0" data-sql-file-empty-search class="px-3 py-2 text-xs text-muted-foreground">
+ {{ t("grid.noSearchResults") }}
+ </div>
<div v-else>
<div
data-sql-file-row="true"
- v-for="{ entry, depth } in flatTree(folder.entries, folder.expanded)"
+ v-for="{ entry, depth } in flatTree(getProcessedEntries(folder.path), getEffectiveExpanded(folder))"
:key="entry.path"
:data-sql-file-path="entry.path"
:aria-current="activePath === entry.path ? 'true' : undefined"
@@ -909,9 +1055,9 @@ function clearContextTarget() {
"
>
<template v-if="entry.is_dir">
- <ChevronRight v-if="!folder.expanded.has(entry.path)" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+ <ChevronRight v-if="!getEffectiveExpanded(folder).has(entry.path)" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
<ChevronDown v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
- <FolderClosed v-if="!folder.expanded.has(entry.path)" class="h-4 w-4 shrink-0 text-amber-500" />
+ <FolderClosed v-if="!getEffectiveExpanded(folder).has(entry.path)" class="h-4 w-4 shrink-0 text-amber-500" />
<FolderOpen v-else class="h-4 w-4 shrink-0 text-amber-500" />
</template>
<template v-else>
diff --git a/apps/desktop/src/components/layout/__tests__/SqlFilePanel.searchAndSort.spec.ts b/apps/desktop/src/components/layout/__tests__/SqlFilePanel.searchAndSort.spec.ts
new file mode 100644
index 0000000000..2498a36852
--- /dev/null
+++ b/apps/desktop/src/components/layout/__tests__/SqlFilePanel.searchAndSort.spec.ts
@@ -0,0 +1,200 @@
+// @vitest-environment happy-dom
+
+import { createApp, nextTick, type App } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import i18n from "@/i18n";
+import { useQueryStore } from "@/stores/queryStore";
+
+const mocks = vi.hoisted(() => ({
+ savedSortOrder: "asc",
+ saveSqlFileSortOrder: vi.fn((order: string) => {
+ mocks.savedSortOrder = order;
+ }),
+}));
+
+vi.mock("@/lib/sqlFile/sqlFileFolders", () => ({
+ getSqlFileFilter: () => "*.sql",
+ getSqlFileFolderPaths: () => ["/sql"],
+ saveSqlFileFilter: vi.fn(),
+ saveSqlFileFolderPaths: vi.fn(),
+ notifySqlFileFoldersChanged: vi.fn(),
+}));
+
+vi.mock("@/lib/sql/sqlFileTreeFilter", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("@/lib/sql/sqlFileTreeFilter")>();
+ return {
+ ...actual,
+ getSqlFileSortOrder: () => mocks.savedSortOrder,
+ saveSqlFileSortOrder: mocks.saveSqlFileSortOrder,
+ };
+});
+
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+
+const testEntries = [
+ {
+ name: "queries",
+ path: "/sql/queries",
+ is_dir: true,
+ children: [
+ { name: "01_find_user.sql", path: "/sql/queries/01_find_user.sql", is_dir: false, children: [] },
+ { name: "02_orders.sql", path: "/sql/queries/02_orders.sql", is_dir: false, children: [] },
+ ],
+ },
+ {
+ name: "migrations",
+ path: "/sql/migrations",
+ is_dir: true,
+ children: [{ name: "01_init.sql", path: "/sql/migrations/01_init.sql", is_dir: false, children: [] }],
+ },
+ { name: "zebra.sql", path: "/sql/zebra.sql", is_dir: false, children: [] },
+ { name: "alpha.sql", path: "/sql/alpha.sql", is_dir: false, children: [] },
+];
+
+vi.mock("@/lib/backend/api", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/lib/backend/api")>()),
+ listSqlFilesInFolder: vi.fn(async () => JSON.parse(JSON.stringify(testEntries))),
+}));
+
+import SqlFilePanel from "../SqlFilePanel.vue";
+
+const mounted: Array<{ app: App; host: HTMLElement }> = [];
+
+async function mountPanel(activeFilePath?: string) {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ const queryStore = useQueryStore();
+ if (activeFilePath) {
+ queryStore.openExternalSqlFile("", "", activeFilePath, "SELECT 1");
+ }
+ const host = document.createElement("div");
+ document.body.appendChild(host);
+ const app = createApp(SqlFilePanel);
+ app.use(pinia);
+ app.use(i18n);
+ app.mount(host);
+ mounted.push({ app, host });
+ await vi.waitFor(() => expect(host.textContent).toContain("alpha.sql"));
+ return { host, queryStore };
+}
+
+beforeEach(() => {
+ mocks.savedSortOrder = "asc";
+ mocks.saveSqlFileSortOrder.mockClear();
+});
+
+afterEach(() => {
+ for (const { app, host } of mounted.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+ vi.restoreAllMocks();
+});
+
+describe("SqlFilePanel search and sort", () => {
+ it("renders search input and sort button, sorts entries in ascending order initially", async () => {
+ const { host } = await mountPanel();
+
+ const searchInput = host.querySelector<HTMLInputElement>("input[data-sql-file-search]");
+ expect(searchInput).not.toBeNull();
+
+ const sortBtn = host.querySelector<HTMLButtonElement>("button[data-sql-file-sort-btn]");
+ expect(sortBtn).not.toBeNull();
+
+ // Check row order: directories (migrations, queries) then files (alpha.sql, zebra.sql)
+ const rows = Array.from(host.querySelectorAll<HTMLElement>("[data-sql-file-path]"));
+ const renderedNames = rows.map((r) => r.querySelector(".truncate")?.textContent?.trim());
+ expect(renderedNames).toEqual(["migrations", "queries", "alpha.sql", "zebra.sql"]);
+ });
+
+ it("toggles sort order between asc and desc, updating rendered order and persisting", async () => {
+ const { host } = await mountPanel();
+ const sortBtn = host.querySelector<HTMLButtonElement>("button[data-sql-file-sort-btn]")!;
+
+ // Toggle to descending
+ sortBtn.click();
+ await nextTick();
+
+ expect(mocks.saveSqlFileSortOrder).toHaveBeenCalledWith("desc");
+
+ // Order should now be: queries, migrations, zebra.sql, alpha.sql
+ let rows = Array.from(host.querySelectorAll<HTMLElement>("[data-sql-file-path]"));
+ let renderedNames = rows.map((r) => r.querySelector(".truncate")?.textContent?.trim());
+ expect(renderedNames).toEqual(["queries", "migrations", "zebra.sql", "alpha.sql"]);
+
+ // Toggle back to ascending
+ sortBtn.click();
+ await nextTick();
+
+ expect(mocks.saveSqlFileSortOrder).toHaveBeenCalledWith("asc");
+ rows = Array.from(host.querySelectorAll<HTMLElement>("[data-sql-file-path]"));
+ renderedNames = rows.map((r) => r.querySelector(".truncate")?.textContent?.trim());
+ expect(renderedNames).toEqual(["migrations", "queries", "alpha.sql", "zebra.sql"]);
+ });
+
+ it("filters file tree by search query, auto-expands matching directories, and restores on clear", async () => {
+ const { host } = await mountPanel();
+ const searchInput = host.querySelector<HTMLInputElement>("input[data-sql-file-search]")!;
+
+ // Type "user" into search input
+ searchInput.value = "user";
+ searchInput.dispatchEvent(new Event("input"));
+ await nextTick();
+
+ // Should auto-expand queries and display 01_find_user.sql
+ const rows = Array.from(host.querySelectorAll<HTMLElement>("[data-sql-file-path]"));
+ const renderedNames = rows.map((r) => r.querySelector(".truncate")?.textContent?.trim());
+ expect(renderedNames).toEqual(["queries", "01_find_user.sql"]);
+
+ // Clear search using clear button
+ const clearBtn = host.querySelector<HTMLButtonElement>("button.absolute.right-1\\.5")!;
+ expect(clearBtn).not.toBeNull();
+ clearBtn.click();
+ await nextTick();
+
+ // Reverted to full tree
+ const restoredRows = Array.from(host.querySelectorAll<HTMLElement>("[data-sql-file-path]"));
+ const restoredNames = restoredRows.map((r) => r.querySelector(".truncate")?.textContent?.trim());
+ expect(restoredNames).toEqual(["migrations", "queries", "alpha.sql", "zebra.sql"]);
+ });
+
+ it("shows empty search result message when no items match", async () => {
+ const { host } = await mountPanel();
+ const searchInput = host.querySelector<HTMLInputElement>("input[data-sql-file-search]")!;
+
+ searchInput.value = "nonexistent_query";
+ searchInput.dispatchEvent(new Event("input"));
+ await nextTick();
+
+ const emptyMsg = host.querySelector<HTMLElement>("[data-sql-file-empty-search]");
+ expect(emptyMsg).not.toBeNull();
+ expect(emptyMsg!.textContent?.trim()).toBe(i18n.global.t("grid.noSearchResults"));
+ });
+
+ it("clears search input when locating an active file that is currently filtered out", async () => {
+ const { host } = await mountPanel("/sql/zebra.sql");
+ const searchInput = host.querySelector<HTMLInputElement>("input[data-sql-file-search]")!;
+ const locateBtn = host.querySelector<HTMLButtonElement>(`button[aria-label="${i18n.global.t("sqlFileTree.locateActiveFile")}"]`)!;
+
+ // Search for "user" so zebra.sql is hidden
+ searchInput.value = "user";
+ searchInput.dispatchEvent(new Event("input"));
+ await nextTick();
+
+ expect(host.textContent).not.toContain("zebra.sql");
+ expect(searchInput.value).toBe("user");
+
+ // Click locate button
+ locateBtn.click();
+ await nextTick();
+ await nextTick();
+
+ // Search should have been cleared and zebra.sql highlighted
+ expect(searchInput.value).toBe("");
+ expect(host.textContent).toContain("zebra.sql");
+ const zebraRow = host.querySelector<HTMLElement>('[data-sql-file-path="/sql/zebra.sql"]');
+ expect(zebraRow).not.toBeNull();
+ expect(zebraRow!.classList.contains("bg-accent")).toBe(true);
+ });
+});
diff --git a/apps/desktop/src/lib/sql/__tests__/sqlFileTreeFilter.spec.ts b/apps/desktop/src/lib/sql/__tests__/sqlFileTreeFilter.spec.ts
new file mode 100644
index 0000000000..fb5d64f13e
--- /dev/null
+++ b/apps/desktop/src/lib/sql/__tests__/sqlFileTreeFilter.spec.ts
@@ -0,0 +1,134 @@
+import { describe, expect, it } from "vitest";
+import type { SqlFileEntry } from "@/lib/backend/api";
+import { compareSqlFileEntries, filterAndSortSqlFileEntries, recursivelySortSqlFileEntries } from "../sqlFileTreeFilter";
+
+describe("sqlFileTreeFilter", () => {
+ const sampleEntries: SqlFileEntry[] = [
+ {
+ name: "queries",
+ path: "/sql/queries",
+ is_dir: true,
+ children: [
+ { name: "select_user.sql", path: "/sql/queries/select_user.sql", is_dir: false, children: [] },
+ { name: "get_orders.sql", path: "/sql/queries/get_orders.sql", is_dir: false, children: [] },
+ { name: "file10.sql", path: "/sql/queries/file10.sql", is_dir: false, children: [] },
+ { name: "file2.sql", path: "/sql/queries/file2.sql", is_dir: false, children: [] },
+ ],
+ },
+ {
+ name: "migrations",
+ path: "/sql/migrations",
+ is_dir: true,
+ children: [
+ {
+ name: "2024",
+ path: "/sql/migrations/2024",
+ is_dir: true,
+ children: [{ name: "01_init.sql", path: "/sql/migrations/2024/01_init.sql", is_dir: false, children: [] }],
+ },
+ {
+ name: "2025",
+ path: "/sql/migrations/2025",
+ is_dir: true,
+ children: [{ name: "02_add_user_roles.sql", path: "/sql/migrations/2025/02_add_user_roles.sql", is_dir: false, children: [] }],
+ },
+ ],
+ },
+ { name: "root_zebra.sql", path: "/sql/root_zebra.sql", is_dir: false, children: [] },
+ { name: "root_alpha.sql", path: "/sql/root_alpha.sql", is_dir: false, children: [] },
+ ];
+
+ describe("compareSqlFileEntries", () => {
+ it("always sorts directories before files in both asc and desc orders", () => {
+ const dir: SqlFileEntry = { name: "z_dir", path: "/z_dir", is_dir: true, children: [] };
+ const file: SqlFileEntry = { name: "a_file.sql", path: "/a_file.sql", is_dir: false, children: [] };
+
+ expect(compareSqlFileEntries(dir, file, "asc")).toBeLessThan(0);
+ expect(compareSqlFileEntries(file, dir, "asc")).toBeGreaterThan(0);
+ expect(compareSqlFileEntries(dir, file, "desc")).toBeLessThan(0);
+ expect(compareSqlFileEntries(file, dir, "desc")).toBeGreaterThan(0);
+ });
+
+ it("performs natural numeric comparison in ascending order", () => {
+ const f1: SqlFileEntry = { name: "file2.sql", path: "/file2.sql", is_dir: false, children: [] };
+ const f2: SqlFileEntry = { name: "file10.sql", path: "/file10.sql", is_dir: false, children: [] };
+
+ expect(compareSqlFileEntries(f1, f2, "asc")).toBeLessThan(0);
+ expect(compareSqlFileEntries(f2, f1, "asc")).toBeGreaterThan(0);
+ });
+
+ it("inverts comparison in descending order", () => {
+ const f1: SqlFileEntry = { name: "file2.sql", path: "/file2.sql", is_dir: false, children: [] };
+ const f2: SqlFileEntry = { name: "file10.sql", path: "/file10.sql", is_dir: false, children: [] };
+
+ expect(compareSqlFileEntries(f1, f2, "desc")).toBeGreaterThan(0);
+ expect(compareSqlFileEntries(f2, f1, "desc")).toBeLessThan(0);
+ });
+ });
+
+ describe("recursivelySortSqlFileEntries", () => {
+ it("sorts folders and files recursively in ascending order", () => {
+ const sorted = recursivelySortSqlFileEntries(sampleEntries, "asc");
+
+ expect(sorted.map((e) => e.name)).toEqual(["migrations", "queries", "root_alpha.sql", "root_zebra.sql"]);
+
+ const queries = sorted.find((e) => e.name === "queries")!;
+ expect(queries.children.map((c) => c.name)).toEqual(["file2.sql", "file10.sql", "get_orders.sql", "select_user.sql"]);
+
+ const migrations = sorted.find((e) => e.name === "migrations")!;
+ expect(migrations.children.map((c) => c.name)).toEqual(["2024", "2025"]);
+ });
+
+ it("sorts folders and files recursively in descending order", () => {
+ const sorted = recursivelySortSqlFileEntries(sampleEntries, "desc");
+
+ expect(sorted.map((e) => e.name)).toEqual(["queries", "migrations", "root_zebra.sql", "root_alpha.sql"]);
+
+ const queries = sorted.find((e) => e.name === "queries")!;
+ expect(queries.children.map((c) => c.name)).toEqual(["select_user.sql", "get_orders.sql", "file10.sql", "file2.sql"]);
+
+ const migrations = sorted.find((e) => e.name === "migrations")!;
+ expect(migrations.children.map((c) => c.name)).toEqual(["2025", "2024"]);
+ });
+ });
+
+ describe("filterAndSortSqlFileEntries", () => {
+ it("returns all items recursively sorted when query is empty or whitespace", () => {
+ const result = filterAndSortSqlFileEntries(sampleEntries, " ", "asc");
+ expect(result.entries.map((e) => e.name)).toEqual(["migrations", "queries", "root_alpha.sql", "root_zebra.sql"]);
+ expect(result.autoExpanded.size).toBe(0);
+ expect(result.matchCount).toBe(12);
+ });
+
+ it("filters files by name case-insensitively and auto-expands ancestor directories", () => {
+ const result = filterAndSortSqlFileEntries(sampleEntries, "USER", "asc");
+
+ expect(result.entries.map((e) => e.name)).toEqual(["migrations", "queries"]);
+
+ const migrations = result.entries.find((e) => e.name === "migrations")!;
+ expect(migrations.children.map((c) => c.name)).toEqual(["2025"]);
+ expect(migrations.children[0].children.map((c) => c.name)).toEqual(["02_add_user_roles.sql"]);
+
+ const queries = result.entries.find((e) => e.name === "queries")!;
+ expect(queries.children.map((c) => c.name)).toEqual(["select_user.sql"]);
+
+ expect(Array.from(result.autoExpanded).sort()).toEqual(["/sql/migrations", "/sql/migrations/2025", "/sql/queries"]);
+ });
+
+ it("keeps all children of a directory when the directory name itself matches", () => {
+ const result = filterAndSortSqlFileEntries(sampleEntries, "queries", "desc");
+
+ expect(result.entries.map((e) => e.name)).toEqual(["queries"]);
+ const queries = result.entries[0];
+ expect(queries.children.map((c) => c.name)).toEqual(["select_user.sql", "get_orders.sql", "file10.sql", "file2.sql"]);
+ expect(result.autoExpanded.has("/sql/queries")).toBe(true);
+ });
+
+ it("returns empty entries when no item matches", () => {
+ const result = filterAndSortSqlFileEntries(sampleEntries, "non_existent_keyword", "asc");
+ expect(result.entries).toEqual([]);
+ expect(result.autoExpanded.size).toBe(0);
+ expect(result.matchCount).toBe(0);
+ });
+ });
+});
diff --git a/apps/desktop/src/lib/sql/sqlFileTreeFilter.ts b/apps/desktop/src/lib/sql/sqlFileTreeFilter.ts
new file mode 100644
index 0000000000..fb96d4c0ca
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlFileTreeFilter.ts
@@ -0,0 +1,149 @@
+import type { SqlFileEntry } from "@/lib/backend/api";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+const SORT_ORDER_STORAGE_KEY = "dbx-sql-file-sort-order";
+export type SqlFileSortOrder = "asc" | "desc";
+export const DEFAULT_SQL_FILE_SORT_ORDER: SqlFileSortOrder = "asc";
+
+/** Read the sort order ("asc" or "desc") for external SQL files. */
+export function getSqlFileSortOrder(): SqlFileSortOrder {
+ const order = safeLocalStorageGet(SORT_ORDER_STORAGE_KEY)?.trim();
+ return order === "desc" ? "desc" : DEFAULT_SQL_FILE_SORT_ORDER;
+}
+
+/** Persist the sort order for external SQL files. */
+export function saveSqlFileSortOrder(order: SqlFileSortOrder): void {
+ safeLocalStorageSet(SORT_ORDER_STORAGE_KEY, order === "desc" ? "desc" : "asc");
+}
+
+export interface SqlFileFilterResult {
+ entries: SqlFileEntry[];
+ autoExpanded: Set<string>;
+ matchCount: number;
+}
+
+/**
+ * Compare two SqlFileEntry nodes for ordering.
+ * Folders/directories always appear before files.
+ * Within the same kind, names are compared naturally (e.g. file2 < file10).
+ */
+export function compareSqlFileEntries(a: SqlFileEntry, b: SqlFileEntry, order: SqlFileSortOrder = "asc"): number {
+ if (a.is_dir !== b.is_dir) {
+ return a.is_dir ? -1 : 1;
+ }
+ let cmp = a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+ if (cmp === 0) {
+ cmp = a.name.localeCompare(b.name);
+ }
+ return order === "desc" ? -cmp : cmp;
+}
+
+/**
+ * Recursively sorts SQL file entries by name (folders first) in ascending or descending order.
+ * Returns a new array and new entry objects for modified directories (immutable).
+ */
+export function recursivelySortSqlFileEntries(entries: SqlFileEntry[], order: SqlFileSortOrder = "asc"): SqlFileEntry[] {
+ const sorted = [...entries].sort((a, b) => compareSqlFileEntries(a, b, order));
+ return sorted.map((entry) => {
+ if (entry.is_dir && entry.children && entry.children.length > 0) {
+ return {
+ ...entry,
+ children: recursivelySortSqlFileEntries(entry.children, order),
+ };
+ }
+ return entry;
+ });
+}
+
+function collectMatchingDescendantDirPaths(items: SqlFileEntry[], q: string, autoExpanded: Set<string>) {
+ for (const item of items) {
+ if (item.is_dir) {
+ if (item.name.toLowerCase().includes(q)) {
+ autoExpanded.add(item.path);
+ }
+ if (item.children) {
+ collectMatchingDescendantDirPaths(item.children, q, autoExpanded);
+ }
+ }
+ }
+}
+
+/**
+ * Filters and sorts SQL file entries based on a search query and sort order.
+ * - If the query is empty, all entries are preserved and recursively sorted.
+ * - If a directory's name matches the query, all of its contents are preserved (and recursively sorted),
+ * and its path is added to `autoExpanded`.
+ * - If a directory's name does not match, but some descendants do, the directory is kept with only the matching descendants,
+ * and its path is added to `autoExpanded`.
+ * - If a file matches the query, it is kept.
+ */
+export function filterAndSortSqlFileEntries(entries: SqlFileEntry[], query: string, order: SqlFileSortOrder = "asc"): SqlFileFilterResult {
+ const trimmed = query.trim();
+ if (!trimmed) {
+ const sorted = recursivelySortSqlFileEntries(entries, order);
+ let count = 0;
+ const countNodes = (items: SqlFileEntry[]) => {
+ for (const item of items) {
+ count++;
+ if (item.is_dir && item.children) countNodes(item.children);
+ }
+ };
+ countNodes(sorted);
+ return {
+ entries: sorted,
+ autoExpanded: new Set<string>(),
+ matchCount: count,
+ };
+ }
+
+ const q = trimmed.toLowerCase();
+ const autoExpanded = new Set<string>();
+ let matchCount = 0;
+
+ function filterEntries(items: SqlFileEntry[]): SqlFileEntry[] {
+ const result: SqlFileEntry[] = [];
+
+ for (const item of items) {
+ if (!item.is_dir) {
+ if (item.name.toLowerCase().includes(q)) {
+ matchCount++;
+ result.push(item);
+ }
+ } else {
+ const dirMatches = item.name.toLowerCase().includes(q);
+ if (dirMatches) {
+ matchCount++;
+ autoExpanded.add(item.path);
+ if (item.children && item.children.length > 0) {
+ collectMatchingDescendantDirPaths(item.children, q, autoExpanded);
+ result.push({
+ ...item,
+ children: recursivelySortSqlFileEntries(item.children, order),
+ });
+ } else {
+ result.push(item);
+ }
+ } else {
+ const filteredChildren = filterEntries(item.children || []);
+ if (filteredChildren.length > 0) {
+ autoExpanded.add(item.path);
+ result.push({
+ ...item,
+ children: filteredChildren,
+ });
+ }
+ }
+ }
+ }
+
+ result.sort((a, b) => compareSqlFileEntries(a, b, order));
+ return result;
+ }
+
+ const filtered = filterEntries(entries);
+ return {
+ entries: filtered,
+ autoExpanded,
+ matchCount,
+ };
+}
diff --git a/apps/desktop/src/lib/sqlFile/sqlFileFolders.ts b/apps/desktop/src/lib/sqlFile/sqlFileFolders.ts
index c30ed02fca..dc2d529d1e 100644
--- a/apps/desktop/src/lib/sqlFile/sqlFileFolders.ts
+++ b/apps/desktop/src/lib/sqlFile/sqlFileFolders.ts
@@ -1,6 +1,8 @@
import { ref } from "vue";
import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+export { getSqlFileSortOrder, saveSqlFileSortOrder, DEFAULT_SQL_FILE_SORT_ORDER, type SqlFileSortOrder } from "@/lib/sql/sqlFileTreeFilter";
+
const STORAGE_KEY = "dbx-sql-file-folders";
const FILTER_STORAGE_KEY = "dbx-sql-file-filter";
export const DEFAULT_SQL_FILE_FILTER = "(?i)\\.(sql|ddl)$";