Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: migrate SQL Editor components to React (#20092)
ecmadao4dca8cead322
diff --git a/docs/superpowers/specs/2026-04-22-sql-editor-react-migration-stage-11-design.md b/docs/superpowers/specs/2026-04-22-sql-editor-react-migration-stage-11-design.mdnew file mode 100644index 0000000000..750c37cbe9--- /dev/null+++ b/docs/superpowers/specs/2026-04-22-sql-editor-react-migration-stage-11-design.md@@ -0,0 +1,447 @@+# SQL Editor React Migration — Stage 11 Design++**Date:** 2026-04-22+**Author:** [email protected]+**Status:** Draft++## 1. Goal & non-goals++**Goal:** Unblock future React migration of the entire WorksheetPane + tree-based surfaces by delivering two pieces of reusable infrastructure and one real consumer:++1. **Hoist the `useSheetContextByView` Vue `provide/inject` context into a Pinia store** (`useSQLEditorSheetStore`) so React components can read the same state the Vue components read.+2. **Build a shadcn-style `Tree` primitive** in `components/ui/tree.tsx` wrapping `react-arborist` (already a project dep, proven in `AsideTree.tsx`).+3. **Port `FolderForm.vue` → React** using the new store + primitive. Swap the single caller (`SaveSheetModal.vue`) to `ReactPageMount`.++**Non-goals (Stage 11):**+- Migrating `SaveSheetModal.vue` itself (deferred — its other internals are unchanged; next attempt at SaveSheetModal will reuse the React `FolderForm` built here).+- Migrating the other 6 `useSheetContextByView` consumers (`SheetTree.vue`, `WorksheetPane.vue`, `TabItem/Prefix.vue`, `TreeNodeSuffix.vue`) — they continue to work via the new Pinia store and migrate in future stages.+- Migrating the other 7 `NTree` consumers — the `Tree` primitive is built with only FolderForm's needs in scope. Additional features (drag-drop, virtualization beyond react-arborist defaults, multi-select) are deferred to future stages when specific consumers need them.+- Advanced `react-arborist` features not used by FolderForm (drag-drop reordering, multi-select, row nesting customization).++## 2. Architecture overview++```+Phase 1 — Sheet context → Pinia+ frontend/src/store/modules/sqlEditor/worksheetSheet.ts (new)+ frontend/src/views/sql-editor/Sheet/context.ts (refactor)+ frontend/src/views/sql-editor/Sheet/folder.ts (refactor)+ frontend/src/views/sql-editor/Sheet/ProvideSheetContext.vue (delete or shrink)+ 7 Vue files update imports (modify)++Phase 2 — Tree primitive+ frontend/src/react/components/ui/tree.tsx (new)++Phase 3 — React FolderForm+ frontend/src/react/components/sql-editor/FolderForm.tsx (new)+ frontend/src/react/components/sql-editor/TreeNodePrefix.tsx (new)++Phase 4 — Caller swap+ frontend/src/views/sql-editor/EditorCommon/SaveSheetModal.vue (modify)+ frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vue (delete)+ frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/TreeNodePrefix.vue (delete)+```++Each phase is commitable independently.++## 3. Phase 1 — Sheet context → Pinia++### 3.1 Current shape (for reference)++`useSheetContextByView(view)` returns per-view state via Vue `inject`:++```+SheetContext = {+ viewContexts: {+ my: ViewContext,+ shared: ViewContext,+ draft: ViewContext,+ }+}++ViewContext = {+ folderContext: FolderContext, // rootPath, folders, ensureFolderPath, mergeFolders, localCache+ folderTree, // ComputedRef<WorksheetFolderNode>+ isInitialized,+ isLoading,+ events, // Emittery+ expandedKeys,+ selectedKeys,+ editingNode,+ filter, filterChanged,+ isWorksheetCreator,+ getFoldersForWorksheet,+ batchUpdateWorksheetFolders,+}+```++Dependencies on upstream stores: `useSQLEditorStore` (for `project`), `useSQLEditorTabStore`, `useWorkSheetStore`, `useCurrentUserV1`.++### 3.2 New Pinia store shape++**File:** `frontend/src/store/modules/sqlEditor/worksheetSheet.ts`++```ts+export const useSQLEditorSheetStore = defineStore("sqlEditorSheet", () => {+ // Internal per-view state lazily built on first access.+ const contexts = reactive(new Map<SheetViewMode, ViewContext>());++ const ensureContext = (view: SheetViewMode): ViewContext => {+ if (!contexts.has(view)) {+ contexts.set(view, buildViewContext(view));+ }+ return contexts.get(view)!;+ };++ const getContextByView = (view: SheetViewMode) => ensureContext(view);++ return { getContextByView };+});+```++Each `ViewContext` is the same shape as before. `buildViewContext(view)` performs the composable setup that currently happens inside `useSheetTreeByView` + `useFolderByView`. Calling `getContextByView("my")` twice returns the same instance.++**Why a Pinia store wrapping a Map instead of 3 stores:** view-mode is dynamic; the callers request by string. A single store with `getContextByView(view)` is simpler than 3 parallel stores and matches the current `viewContexts[view]` access pattern.++**Event bus:** each view's `events` Emittery moves inside `buildViewContext`; consumers continue to subscribe/emit as before. React consumers can subscribe via `useEmitteryEventListener` from Stage 8 infra.++### 3.3 Migration steps++1. Create `worksheetSheet.ts` — copy the body of `useSheetTreeByView` + `useFolderByView` into `buildViewContext`, returning the same fields.+2. Rewrite `frontend/src/views/sql-editor/Sheet/context.ts`:+ - `useSheetContextByView(view)` delegates to `useSQLEditorSheetStore().getContextByView(view)`. Keep the function for source-compat; mark `useSheetContext()` and the `KEY` InjectionKey as deprecated (or delete if no remaining users).+3. `Sheet/folder.ts` → fold logic into `buildViewContext` or keep as a helper that `buildViewContext` calls (whichever keeps the diff smaller).+4. `Sheet/ProvideSheetContext.vue` — if it only `provide()`s the context, delete it and remove its mount point. If it does other setup (watchers, route hooks), keep the shell but drop the provide.+5. Update 7 Vue consumers — in most cases the call site `useSheetContextByView(view)` stays identical; only the implementation moved. Run a grep to confirm.++### 3.4 Backward-compat verification++After Phase 1 ships, every Vue caller must render identically. Verification:+- `pnpm --dir frontend fix && type-check && test` clean+- Manual: open SQL editor, switch tabs, save a worksheet into a folder, verify the tree renders + updates + filters + drags correctly. Same behavior expected.++## 4. Phase 2 — Tree primitive++### 4.1 File++`frontend/src/react/components/ui/tree.tsx`++### 4.2 Props (render-prop API — matches `AsideTree.tsx` pattern)++```tsx+interface TreeNode<T> {+ readonly id: string; // stable key+ readonly children?: readonly TreeNode<T>[];+ readonly data: T; // caller's payload+}++interface TreeProps<T> {+ readonly data: readonly TreeNode<T>[];+ readonly renderNode: (args: {+ node: NodeApi<TreeNode<T>>; // react-arborist node API+ style: CSSProperties;+ }) => ReactNode;++ readonly selectedIds?: readonly string[];+ readonly expandedIds?: readonly string[];+ readonly onSelect?: (ids: readonly string[]) => void;+ readonly onToggle?: (id: string) => void;++ readonly searchTerm?: string; // highlighting + filtering via searchMatch+ readonly searchMatch?: (node: TreeNode<T>, term: string) => boolean;++ readonly height?: number; // defaults to 300px+ readonly rowHeight?: number; // defaults to 28px+ readonly indent?: number; // defaults to 16px++ readonly className?: string;+}+```++### 4.3 Implementation notes++- Wraps `Tree` from `react-arborist` inside a styled container. Default height 300, row 28, indent 16.+- Selection is controlled: `selectedIds` drives `<Tree selection={ids[0]}>` for single-select. `onSelect` fires on row click.+- Expansion is controlled via `openByDefault={false}` + programmatic `tree.open(id)` / `tree.close(id)` through a ref. The component manages the bridge so callers just pass `expandedIds`.+- Search: `searchTerm` passed to react-arborist; falls back to node's `id` + `data.label` if `searchMatch` not provided. FolderForm will provide its own matcher.+- Styling: `LAYER_SURFACE_CLASS` is NOT used (tree is a normal in-flow element, not an overlay). Tailwind-only, uses `text-control`, `bg-accent/10` for selected row, `hover:bg-accent/5` for hover row. Focus ring via `focus-visible:ring-accent`.+- No drag-drop, no multi-select (YAGNI for Stage 11).++### 4.4 Test coverage++`tree.test.tsx`:+- Renders nodes with the render function+- Clicking a row fires `onSelect` with the row id+- `selectedIds` prop reflects selection visually+- `expandedIds` controls open/close+- `searchTerm` filters visible nodes++## 5. Phase 3 — React FolderForm + TreeNodePrefix++### 5.1 Files++- `frontend/src/react/components/sql-editor/FolderForm.tsx` (~150 lines)+- `frontend/src/react/components/sql-editor/TreeNodePrefix.tsx` (~40 lines)++### 5.2 FolderForm.tsx++**Props:**+```tsx+type Props = {+ readonly folder: string;+ readonly onFolderChange: (folder: string) => void;+};+```++**Shape:**+- `Popover` (the shadcn primitive built in Stage 6) with manual trigger mode+- Trigger = an `<Input>` showing `formattedFolderPath` (slash-joined, rootPath stripped)+- Content = `<Tree>` fed by the Pinia store's `getContextByView("my")`+- `onFocus` on input → open popover+- Clicking outside → close popover (use `useOnClickOutside` — either import an existing hook or write a 15-line `useOnClickOutside` hook inline)+- Typing in input → updates folderPath directly (adds trailing slash handling matching Vue logic lines 107–120)+- Selecting a tree node → sets folderPath + closes popover++**State:**+- `folderPath` (local, synced to/from `props.folder`)+- `expandedIds` — `Set<string>`+- `showPopover` — boolean+- `searchTerm` — `folderPath` value (for tree filter)++**Store access:** `useSQLEditorSheetStore().getContextByView("my")` at top level, then `useVueState` for `folderTree`, `folderContext.rootPath`.++**Vue `defineExpose` contract removal:** Vue FolderForm exposes `folders: computed(...)`. The Vue caller SaveSheetModal reads `folderFormRef.value?.folders` via template ref. This won't work across the React boundary. Solution:+- Vue `SaveSheetModal.vue` already has access to `useSheetContextByView("my").getFoldersForWorksheet`. After Phase 1 (Pinia), it can compute `folders` itself from the current `folder` state. Drop the `folderFormRef.value.folders` read; derive from the Pinia store using the current `folder` value.+- This is a Phase 4 adjustment, not a Phase 3 one.++### 5.3 TreeNodePrefix.tsx++Direct port of `TreeNodePrefix.vue` — icon selection logic based on node state. No store access. Pure props:++```tsx+type Props = {+ readonly node: WorksheetFolderNode;+ readonly expandedIds: ReadonlySet<string>;+ readonly rootPath: string;+ readonly view: SheetViewMode;+};+```++Uses `lucide-react` (already in use) for `FileCode`, `FolderCode`, `FolderMinus`, `FolderOpen`, `FolderPen`, `FolderSync`.++### 5.4 Register page mount++`frontend/src/react/mount.ts` glob already covers `./components/sql-editor/*.tsx`. Verify no change needed.++### 5.5 Tests++- `FolderForm.test.tsx` — 4 tests: renders input with formatted path, clicking input opens popover, selecting a tree node updates folder + closes popover, typing in input updates folderPath with slash normalization+- `TreeNodePrefix.test.tsx` — 3 tests: renders file icon for worksheet node, folder-open for expanded folder, root-variant icons for each view mode++## 6. Phase 4 — SaveSheetModal caller swap++### 6.1 SaveSheetModal.vue change++Find the `<FolderForm>` tag and replace:++```vue+<FolderForm :folder="folder" @update:folder="onFolderChange" />+```++With:++```vue+<ReactPageMount+ page="FolderForm"+ :folder="folder"+ :onFolderChange="onFolderChange"+/>+```++Remember: explicit camelCase `:onFolderChange`, not `:on-folder-change`.++Drop the Vue `FolderForm` import. Add `ReactPageMount` import.++**Folders computation:** Vue currently does `folderFormRef.value?.folders`. Replace with an inline computed that calls `sheetStore.getContextByView("my").getFoldersForWorksheet(folder)` directly. This reads from the Pinia store Phase 1 produced.++### 6.2 Vue file deletions++After the swap is wired and verified:+- `frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vue` — delete+- `frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/TreeNodePrefix.vue` — delete++Verify via `rg "FolderForm\.vue|TreeNodePrefix\.vue"` that no remaining imports exist.++## 7. Testing & verification++### 7.1 Per-phase checks++After each phase: `pnpm --dir frontend fix && check && type-check && test --run` must be green.++### 7.2 Manual UX (after Phase 4)++1. Open SQL editor → unsaved worksheet with content → cmd+S+2. Save modal opens → click folder input → popover with tree appears+3. Tree shows existing folders under "my" root with correct prefix icons+4. Click a folder → path updates in input, popover closes+5. Type "foo/bar" in input → path updates, tree filters accordingly+6. Submit save → worksheet saved into the picked folder path+7. Open save modal again on a different tab → fresh state, no cross-tab leak++### 7.3 Regression checks++After Phase 1 (before Phase 2-4):+- WorksheetPane (Vue) renders identically — folders expand/collapse, filter works, drag-sort works+- TabItem/Prefix shows correct folder badge+- Rename/move/delete folders still work++## 8. Checklist++### Phase 1+- [ ] `useSQLEditorSheetStore` Pinia store created in `store/modules/sqlEditor/worksheetSheet.ts`+- [ ] `Sheet/context.ts` refactored to delegate to Pinia store+- [ ] `Sheet/folder.ts` logic moved/referenced from the store+- [ ] `Sheet/ProvideSheetContext.vue` — deleted if only provides context; else shrunk+- [ ] All 7 Vue consumers import paths work without modification (grep confirms)+- [ ] `fix && type-check && test --run` green+- [ ] Manual verification of WorksheetPane + SaveSheetModal behavior unchanged++### Phase 2+- [ ] `components/ui/tree.tsx` created with render-prop API+- [ ] `tree.test.tsx` with 5 scenarios+- [ ] `fix && type-check && test --run` green++### Phase 3+- [ ] `FolderForm.tsx` + `TreeNodePrefix.tsx` created+- [ ] Tests for both+- [ ] Uses Pinia store from Phase 1, Tree primitive from Phase 2+- [ ] `fix && type-check && test --run` green++### Phase 4+- [ ] `SaveSheetModal.vue` swapped to `ReactPageMount`+- [ ] `folders` derivation moved from template ref to inline store read+- [ ] `FolderForm.vue` + `TreeNodePrefix.vue` deleted+- [ ] `rg FolderForm.vue|TreeNodePrefix.vue` returns no results+- [ ] Manual UX §7.2 verified++## 7. Phase 5 — Retire `SaveSheetModal.vue`++Added after Phase 4 to close the loop opened in Stage 8 (SaveSheetModal React attempt was reverted because FolderForm wasn't ready). All blockers are now resolved by Phases 1-4.++### 7.1 Prereq audit (already satisfied)++- `save-sheet` event flows through `sqlEditorEvents` singleton (Stage 8) — React subscribes via `useSQLEditorEvent`+- `maybeUpdateWorksheet`, `createWorksheet`, `abortAutoSave` live in `useSQLEditorWorksheetStore` Pinia (Stage 8)+- `useSheetContextByView` is Pinia (Phase 1 of this stage)+- React `FolderForm` exists and accepts `{ folder, onFolderChange }` (Phase 3 of this stage)+- shadcn `Dialog`, `Input`, `Button` primitives exist++No new infrastructure needed. Direct shell port.++### 7.2 Files++**New:**+- `frontend/src/react/components/sql-editor/SaveSheetModal.tsx` (~150 lines)+- `frontend/src/react/components/sql-editor/SaveSheetModal.test.tsx` (~200 lines, 5 tests)++**Modify:**+- `frontend/src/views/sql-editor/EditorPanel/StandardPanel/StandardPanel.vue` — swap `<SaveSheetModal />` → `<ReactPageMount page="SaveSheetModal" />`. No props.+- `frontend/src/views/sql-editor/EditorCommon/index.ts` — drop the `SaveSheetModal` barrel export.++**Delete:**+- `frontend/src/views/sql-editor/EditorCommon/SaveSheetModal.vue`++### 7.3 Component shape++```tsx+export function SaveSheetModal() {+ const { t } = useTranslation();+ const worksheetStore = useWorkSheetStore();+ const editorWorksheetStore = useSQLEditorWorksheetStore();+ const sheetContext = useSheetContextByView("my");++ const [open, setOpen] = useState(false);+ const [title, setTitle] = useState("");+ const [folder, setFolder] = useState("");+ const [rawTab, setRawTab] = useState<SQLEditorTab | undefined>(undefined);++ useSQLEditorEvent("save-sheet", ({ tab, editTitle }) => { ... });++ const doSaveSheet = async (tab?: SQLEditorTab) => { ... };++ return (+ <Dialog open={open} onOpenChange={(next) => !next && setOpen(false)}>+ <DialogContent className="max-w-lg">+ <DialogTitle>{t("sql-editor.save-sheet")}</DialogTitle>+ {/* title input + FolderForm (React, direct import) + Close/Save buttons */}+ </DialogContent>+ </Dialog>+ );+}+```++### 7.4 Full-parity behaviors (audit checklist)++1. Event listener sets `title`, `folder` (empty initially), `rawTab` synchronously on every `save-sheet`+2. `needShowModal(tab) = !tab.worksheet`+3. If `needShowModal` OR `editTitle`:+ - `worksheetStore.getWorksheetByName(tab.worksheet)` → if found, `folder = sheetContext.getPwdForWorksheet(worksheet)`+ - Show modal+4. Else: call `doSaveSheet(tab)` immediately, no modal+5. `doSaveSheet`:+ - Guard on missing `rawTab` and empty `title`+ - `abortAutoSave()` first+ - `folders = sheetContext.getFoldersForWorksheet(folder)`+ - `extractWorksheetID(worksheet ?? "") !== String(UNKNOWN_ID)` → `maybeUpdateWorksheet`, else `createWorksheet`+ - Close modal+6. Save button disabled when `title === ""`++### 7.5 Dialog vs Sheet++**Dialog** — focused 2-field save action, matches Vue `BBModal`'s centered-card shape. Not a multi-section resource edit, so Sheet would be overkill per `frontend/AGENTS.md`.++Width: `max-w-lg` (32rem) — mirrors Vue's `w-lg max-w-[calc(100vw-8rem)]`.++### 7.6 Tests++1. Modal opens on `save-sheet` for an unsaved tab, title prefilled+2. Modal does NOT open for a saved tab without `editTitle`; `maybeUpdateWorksheet` called instead+3. Modal opens for a saved tab when `editTitle: true`+4. Save button disabled when title empty+5. Clicking Save on an unsaved tab calls `createWorksheet` with the right args++Mock `FolderForm` so the test doesn't re-test the tree (already covered in Phase 3 tests).++### 7.7 Phase 5 checklist++- [ ] `SaveSheetModal.tsx` created+- [ ] `SaveSheetModal.test.tsx` created with 5 tests+- [ ] `StandardPanel.vue` swapped to `ReactPageMount`+- [ ] `EditorCommon/index.ts` dropped the `SaveSheetModal` export+- [ ] `SaveSheetModal.vue` deleted+- [ ] `rg "SaveSheetModal\.vue"` returns zero results+- [ ] `pnpm fix && type-check && test --run && check` all green++## 8. Manual UX (after all phases)++**Phase 1-4 flows:**++1. Open SQL editor → unsaved tab → cmd+S → save modal opens (now React)+2. Click folder input → tree popover, width matches input+3. Pick folder → path updates, popover closes+4. Type `foo/bar` → path normalizes, tree filters+5. Worksheet pane → select multiple → "Move to folder" modal (React FolderForm embedded)++**Phase 5 flows (new):**++6. Modal save flow end-to-end: title + folder → Save → worksheet created or updated in the correct folder+7. Right-click saved tab → Rename → modal opens with title + current folder prefilled+8. Saved tab without editTitle → cmd+S → no modal, save proceeds silently++## 9. Out of scope (deferred)++- Migrating `SheetTree.vue`, `WorksheetPane.vue` (shell), `TabItem/Prefix.vue`, `TreeNodeSuffix.vue` — they benefit from the Pinia hoist but remain Vue+- Other NTree consumers — the primitive is ready for them when their stages come+- Drag-drop / multi-select on the Tree primitive — add when a consumer needs it+- AI plugin context hoist (separate future stage)+- EditorAction shell migration (deferred)+- Dead-code cleanup of `Sheet/folder.ts` (Phase 1 left it unimported; separate cleanup)diff --git a/frontend/src/components/SensitiveData/components/ClassificationTree.vue b/frontend/src/components/SensitiveData/components/ClassificationTree.vuedeleted file mode 100644index 27c3bcf0de..0000000000--- a/frontend/src/components/SensitiveData/components/ClassificationTree.vue+++ /dev/null@@ -1,167 +0,0 @@-<template>- <div class="divide-block-border space-y-4 h-full">- <SearchBox- v-model:value="state.searchText"- style="max-width: 100%"- :placeholder="$t('schema-template.classification.search')"- />-- <NTree- ref="treeRef"- block-line- style="height: 100%; user-select: none"- :data="treeData"- :multiple="false"- :selectable="true"- :pattern="state.searchText"- :show-irrelevant-nodes="false"- :default-expand-all="true"- :expand-on-click="true"- :render-suffix="renderSuffix"- :render-label="renderLabel"- :node-props="nodeProps"- :virtual-scroll="false"- :theme-overrides="{ nodeHeight: '21px' }"- />- </div>-</template>--<script lang="ts" setup>-import type { TreeOption } from "naive-ui";-import { NTree } from "naive-ui";-import { computed, h, reactive } from "vue";-import { SearchBox } from "@/components/v2";-import type { DataClassificationSetting_DataClassificationConfig } from "@/types/proto-es/v1/setting_service_pb";-import { getHighlightHTMLByKeyWords } from "@/utils";-import ClassificationLevelBadge from "./ClassificationLevelBadge.vue";--const props = defineProps<{- classificationConfig: DataClassificationSetting_DataClassificationConfig;-}>();--const emit = defineEmits<{- (event: "apply", classificationId: string): void;-}>();--interface LocalState {- searchText: string;-}--interface TreeNode extends TreeOption {- key: string;- label: string;- level?: number;- children?: TreeNode[];-}--interface ClassificationMap {- [key: string]: {- id: string;- label: string;- level?: number;- children: ClassificationMap;- };-}--const state = reactive<LocalState>({- searchText: "",-});--const nodeProps = ({ option }: { option: TreeOption }) => {- return {- onClick() {- if (!option.isLeaf || !option.key) {- return;- }- emit("apply", option.key as string);- },- };-};--const sortClassification = (- item1: { id: string },- item2: { id: string }-): number => {- const id1s = item1.id.split("-");- const id2s = item2.id.split("-");-- if (id1s.length !== id2s.length) {- return id1s.length - id2s.length;- }-- for (let i = 0; i < id1s.length; i++) {- if (id1s[i] === id2s[i]) {- continue;- }- if (Number.isNaN(id1s[i]) || Number.isNaN(id1s[i])) {- return id1s[i].localeCompare(id2s[i]);- }- return Number(id1s[i]) - Number(id2s[i]);- }-- // shouldn't has duplicate id- return 0;-};--const treeData = computed((): TreeNode[] => {- const classifications = Object.values(- props.classificationConfig.classification- ).sort(sortClassification);-- const classificationMap: ClassificationMap = {};- for (const classification of classifications) {- const ids = classification.id.split("-");- let tmp = classificationMap;- for (let i = 0; i < ids.length - 1; i++) {- tmp = tmp[ids.slice(0, i + 1).join("-")].children;- if (!tmp) {- break;- }- }- if (tmp) {- tmp[classification.id] = {- id: classification.id,- label: classification.title,- level: classification.level,- children: {},- };- }- }- return getTreeNodeList(classificationMap);-});--const getTreeNodeList = (classificationMap: ClassificationMap): TreeNode[] => {- return Object.values(classificationMap)- .sort(sortClassification)- .map((item) => {- const children = getTreeNodeList(item.children);- return {- key: item.id,- label: `${item.id} ${item.label}`,- level: item.level,- isLeaf: children.length === 0,- children,- };- });-};--const renderSuffix = ({ option }: { option: TreeOption }) => {- const node = option as TreeNode;- if (node.level == null) {- return null;- }-- return h(ClassificationLevelBadge, {- showText: false,- classification: node.key,- classificationConfig: props.classificationConfig,- });-};--const renderLabel = ({ option }: { option: TreeOption }) => {- const node = option as TreeNode;- return h("span", {- innerHTML: getHighlightHTMLByKeyWords(node.label, state.searchText),- });-};-</script>diff --git a/frontend/src/components/SensitiveData/components/SelectClassificationDrawer.vue b/frontend/src/components/SensitiveData/components/SelectClassificationDrawer.vueindex 76fd265a12..9fa9ca1bbb 100644--- a/frontend/src/components/SensitiveData/components/SelectClassificationDrawer.vue+++ b/frontend/src/components/SensitiveData/components/SelectClassificationDrawer.vue@@ -2,9 +2,10 @@<Drawer :show="show" @close="$emit('dismiss')"><DrawerContent :title="$t('schema-template.classification.select')"><div class="w-[25rem] h-full">- <ClassificationTree- :classification-config="classificationConfig"- @apply="onApply"+ <ReactPageMount+ page="ClassificationTree"+ :config="classificationConfig"+ :onApply="onApply"/></div>@@ -24,8 +25,8 @@<script lang="ts" setup>import { NButton } from "naive-ui";import { Drawer, DrawerContent } from "@/components/v2";+import ReactPageMount from "@/react/ReactPageMount.vue";import type { DataClassificationSetting_DataClassificationConfig } from "@/types/proto-es/v1/setting_service_pb";-import ClassificationTree from "./ClassificationTree.vue";defineProps<{show: boolean;diff --git a/frontend/src/react/components/ClassificationTree.tsx b/frontend/src/react/components/ClassificationTree.tsxnew file mode 100644index 0000000000..84f31982b7--- /dev/null+++ b/frontend/src/react/components/ClassificationTree.tsx@@ -0,0 +1,234 @@+import { ChevronRight } from "lucide-react";+import { type JSX, useCallback, useMemo, useState } from "react";+import { useTranslation } from "react-i18next";+import { SearchInput } from "@/react/components/ui/search-input";+import type { TreeDataNode } from "@/react/components/ui/tree";+import { Tree } from "@/react/components/ui/tree";+import type { DataClassificationSetting_DataClassificationConfig } from "@/types/proto-es/v1/setting_service_pb";++interface TreeNode {+ key: string;+ label: string;+ level?: number;+ children: TreeNode[];+}++interface ClassificationMap {+ [key: string]: {+ id: string;+ label: string;+ level?: number;+ children: ClassificationMap;+ };+}++function sortClassification(a: { id: string }, b: { id: string }): number {+ const id1s = a.id.split("-");+ const id2s = b.id.split("-");+ if (id1s.length !== id2s.length) return id1s.length - id2s.length;+ for (let i = 0; i < id1s.length; i++) {+ if (id1s[i] === id2s[i]) continue;+ if (Number.isNaN(Number(id1s[i])) || Number.isNaN(Number(id2s[i]))) {+ return id1s[i].localeCompare(id2s[i]);+ }+ return Number(id1s[i]) - Number(id2s[i]);+ }+ return 0;+}++function buildTreeData(+ config: DataClassificationSetting_DataClassificationConfig+): TreeNode[] {+ const classifications = Object.values(config.classification).sort(+ sortClassification+ );+ const map: ClassificationMap = {};+ for (const c of classifications) {+ const ids = c.id.split("-");+ let tmp = map;+ for (let i = 0; i < ids.length - 1; i++) {+ const parentKey = ids.slice(0, i + 1).join("-");+ if (!tmp[parentKey]) break;+ tmp = tmp[parentKey].children;+ }+ tmp[c.id] = {+ id: c.id,+ label: c.title,+ level: c.level,+ children: {},+ };+ }++ function toNodes(m: ClassificationMap): TreeNode[] {+ return Object.values(m)+ .sort(sortClassification)+ .map((item) => ({+ key: item.id,+ label: `${item.id} ${item.label}`,+ level: item.level,+ children: toNodes(item.children),+ }));+ }+ return toNodes(map);+}++const bgColorList = [+ "bg-green-200",+ "bg-yellow-200",+ "bg-orange-300",+ "bg-amber-500",+ "bg-red-500",+];++function LevelBadge({+ level,+ config,+}: {+ level: number;+ config: DataClassificationSetting_DataClassificationConfig;+}) {+ const levelObj = config.levels.find((l) => l.level === level);+ if (!levelObj) return null;+ const color = bgColorList[level - 1] ?? "bg-control-bg-hover";+ return (+ <span className={`ml-1 px-1 py-0.5 rounded-xs text-xs ${color}`}>+ {levelObj.title}+ </span>+ );+}++function highlightText(text: string, keyword: string) {+ if (!keyword) return text;+ const lower = text.toLowerCase();+ const kw = keyword.toLowerCase();+ const parts: (string | JSX.Element)[] = [];+ let cursor = 0;+ let idx = lower.indexOf(kw, cursor);+ while (idx !== -1) {+ if (idx > cursor) parts.push(text.slice(cursor, idx));+ parts.push(+ <b key={idx} className="text-accent">+ {text.slice(idx, idx + keyword.length)}+ </b>+ );+ cursor = idx + keyword.length;+ idx = lower.indexOf(kw, cursor);+ }+ if (cursor < text.length) parts.push(text.slice(cursor));+ return <>{parts}</>;+}++function toTreeData(node: TreeNode): TreeDataNode<TreeNode> {+ return {+ id: node.key,+ data: node,+ children: node.children.map(toTreeData),+ };+}++function collectAllIds(nodes: TreeDataNode<TreeNode>[]): string[] {+ const ids: string[] = [];+ for (const n of nodes) {+ ids.push(n.id);+ if (n.children)+ ids.push(...collectAllIds(n.children as TreeDataNode<TreeNode>[]));+ }+ return ids;+}++function collectMatchingIds(nodes: TreeNode[], keyword: string): Set<string> {+ const ids = new Set<string>();+ function walk(node: TreeNode): boolean {+ const selfMatches = node.label+ .toLowerCase()+ .includes(keyword.toLowerCase());+ const childMatches = node.children.some((c) => walk(c));+ if (selfMatches || childMatches) {+ ids.add(node.key);+ return true;+ }+ return false;+ }+ for (const n of nodes) walk(n);+ return ids;+}++export function ClassificationTree({+ config,+ onApply,+}: {+ readonly config: DataClassificationSetting_DataClassificationConfig;+ readonly onApply?: (classificationId: string) => void;+}) {+ const { t } = useTranslation();+ const [searchText, setSearchText] = useState("");+ const treeData = useMemo(+ () => buildTreeData(config).map(toTreeData),+ [config]+ );+ const expandedIds = useMemo(() => collectAllIds(treeData), [treeData]);+ const matchingIds = useMemo(() => {+ if (!searchText) return null;+ return collectMatchingIds(+ treeData.map((n) => n.data),+ searchText+ );+ }, [treeData, searchText]);++ const searchMatch = useCallback(+ (node: TreeDataNode<TreeNode>) => {+ if (!matchingIds) return true;+ return matchingIds.has(node.data.key);+ },+ [matchingIds]+ );++ return (+ <div className="flex flex-col gap-4">+ <div>+ <SearchInput+ value={searchText}+ onChange={(e) => setSearchText(e.target.value)}+ placeholder={t("schema-template.classification.search")}+ />+ </div>+ <Tree<TreeNode>+ data={treeData}+ expandedIds={expandedIds}+ searchTerm={searchText || undefined}+ searchMatch={searchMatch}+ height={400}+ rowHeight={32}+ renderNode={({ node, style }) => {+ const treeNode = node.data.data;+ const hasChildren = (node.data.children?.length ?? 0) > 0;+ return (+ <div+ style={style}+ className="flex items-center gap-1 py-1 px-1 rounded-xs hover:bg-control-bg cursor-pointer select-none text-sm"+ onClick={() => {+ if (!hasChildren && onApply) {+ onApply(treeNode.key);+ } else {+ node.toggle();+ }+ }}+ >+ {hasChildren ? (+ <ChevronRight+ className={`size-4 shrink-0 transition-transform ${node.isOpen ? "rotate-90" : ""}`}+ />+ ) : (+ <span className="size-4 shrink-0" />+ )}+ <span>{highlightText(treeNode.label, searchText)}</span>+ {treeNode.level != null && treeNode.level !== 0 && (+ <LevelBadge level={treeNode.level} config={config} />+ )}+ </div>+ );+ }}+ />+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/FolderForm.test.tsx b/frontend/src/react/components/sql-editor/FolderForm.test.tsxnew file mode 100644index 0000000000..5e3ce654ba--- /dev/null+++ b/frontend/src/react/components/sql-editor/FolderForm.test.tsx@@ -0,0 +1,332 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";+import type { WorksheetFolderNode } from "@/views/sql-editor/Sheet";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++// Stub ResizeObserver — not provided by jsdom+globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++// ---- mocks ------------------------------------------------------------------++const mocks = vi.hoisted(() => ({+ useTranslation: vi.fn(() => ({ t: (key: string) => key })),+ useVueState: vi.fn<(getter: () => unknown) => unknown>(),+ useSQLEditorWorksheetStore: vi.fn(),+ useClickOutside: vi.fn(),+ onSelectCallback: vi.fn(),+}));++vi.mock("react-i18next", () => ({+ useTranslation: mocks.useTranslation,+}));++vi.mock("@/react/hooks/useVueState", () => ({+ useVueState: mocks.useVueState,+}));++vi.mock("@/store", () => ({+ useSQLEditorWorksheetStore: mocks.useSQLEditorWorksheetStore,+}));++vi.mock("@/react/hooks/useClickOutside", () => ({+ useClickOutside: mocks.useClickOutside,+}));++type TreeDataNodeLike = {+ id: string;+ data: WorksheetFolderNode;+ children?: TreeDataNodeLike[];+};++// Mock Tree to render a simple test double+vi.mock("@/react/components/ui/tree", () => ({+ Tree: ({+ data,+ renderNode,+ }: {+ data: TreeDataNodeLike[];+ renderNode: (args: {+ node: {+ id: string;+ data: TreeDataNodeLike;+ isSelected: boolean;+ };+ style: React.CSSProperties;+ }) => React.ReactNode;+ onSelect?: (ids: string[]) => void;+ }) => (+ <div data-testid="tree">+ {data.map((item) =>+ renderNode({+ node: {+ id: item.id,+ data: item,+ isSelected: false,+ },+ style: {},+ })+ )}+ </div>+ ),+}));++// Mock Popover — render children inline, track open state+// Module-scoped open state mirror so PopoverContent mock can gate its children+// the same way Base UI's real Portal only renders when `open=true`.+let mockPopoverOpen = false;++vi.mock("@/react/components/ui/popover", () => ({+ Popover: ({+ children,+ open,+ }: {+ children: React.ReactNode;+ open?: boolean;+ }) => {+ mockPopoverOpen = !!open;+ return (+ <div data-testid="popover-root" data-open={String(open ?? false)}>+ {children}+ </div>+ );+ },+ PopoverTrigger: ({+ children,+ render,+ }: {+ children?: React.ReactNode;+ render?: React.ReactElement;+ }) => <div data-testid="popover-trigger">{render ?? children}</div>,+ PopoverContent: ({+ children,+ style,+ }: {+ children: React.ReactNode;+ style?: React.CSSProperties;+ }) =>+ mockPopoverOpen ? (+ <div data-testid="popover-content" style={style}>+ {children}+ </div>+ ) : null,+}));++vi.mock("@/react/components/ui/input", () => ({+ Input: ({+ value,+ placeholder,+ onFocus,+ onChange,+ }: {+ value?: string;+ placeholder?: string;+ onFocus?: () => void;+ onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;+ }) => (+ <input+ data-testid="folder-input"+ value={value ?? ""}+ placeholder={placeholder}+ onFocus={onFocus}+ onChange={onChange}+ readOnly={!onChange}+ />+ ),+}));++vi.mock("./TreeNodePrefix", () => ({+ TreeNodePrefix: () => <span data-testid="tree-node-prefix" />,+}));++// ---- helpers ----------------------------------------------------------------++const makeFolderNode = (+ key: string,+ children: WorksheetFolderNode[] = []+): WorksheetFolderNode => ({+ key,+ label: key.split("/").slice(-1)[0],+ editable: true,+ children,+ empty: children.length === 0,+});++const setupDefaultMocks = () => {+ mocks.useTranslation.mockReturnValue({ t: (key: string) => key });+ mocks.useClickOutside.mockImplementation(() => undefined);+ mocks.useVueState.mockImplementation((getter: () => unknown) => getter());++ const rootNode = makeFolderNode("/my", [+ makeFolderNode("/my/foo"),+ makeFolderNode("/my/bar"),+ ]);++ const viewContext = {+ folderTree: { value: rootNode },+ folderContext: {+ rootPath: { value: "/my" },+ },+ };++ mocks.useSQLEditorWorksheetStore.mockReturnValue({+ getContextByView: vi.fn(() => viewContext),+ });+};++const renderIntoContainer = (element: ReactElement) => {+ const container = document.createElement("div");+ const root = createRoot(container);+ document.body.appendChild(container);+ return {+ container,+ render: () => {+ act(() => {+ root.render(element);+ });+ },+ update: (next: ReactElement) => {+ act(() => {+ root.render(next);+ });+ },+ unmount: () => {+ act(() => {+ root.unmount();+ });+ container.remove();+ },+ };+};++let FolderForm: typeof import("./FolderForm").FolderForm;++beforeEach(async () => {+ vi.clearAllMocks();+ setupDefaultMocks();+ ({ FolderForm } = await import("./FolderForm"));+});++afterEach(() => {+ document.body.innerHTML = "";+});++// ---- tests ------------------------------------------------------------------++describe("FolderForm", () => {+ test("renders input with formatted path (rootPath stripped, slashes converted to ' / ')", () => {+ const { container, render, unmount } = renderIntoContainer(+ <FolderForm folder="/my/foo/bar" onFolderChange={vi.fn()} />+ );+ render();++ const input = container.querySelector(+ "[data-testid='folder-input']"+ ) as HTMLInputElement;+ expect(input).not.toBeNull();+ // "/my/foo/bar" → strip "/my" → "/foo/bar" → strip leading "/" → "foo/bar" → join as " / " → "foo / bar"+ expect(input.value).toBe("foo / bar");++ unmount();+ });++ test("focusing the input opens the popover", () => {+ const { container, render, unmount } = renderIntoContainer(+ <FolderForm folder="/my" onFolderChange={vi.fn()} />+ );+ render();++ // Tree not rendered yet (popover closed)+ expect(document.body.querySelector("[data-testid='tree']")).toBeNull();++ const input = container.querySelector(+ "[data-testid='folder-input']"+ ) as HTMLInputElement;++ act(() => {+ input.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));+ });++ // Tree now rendered via portal to overlay layer+ expect(document.body.querySelector("[data-testid='tree']")).not.toBeNull();++ unmount();+ });++ test("typing in input normalizes path and calls onFolderChange", () => {+ const onFolderChange = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <FolderForm folder="/my" onFolderChange={onFolderChange} />+ );+ render();++ const input = container.querySelector(+ "[data-testid='folder-input']"+ ) as HTMLInputElement;+ expect(input).not.toBeNull();++ // Simulate onChange directly — trigger via React internal fiber+ act(() => {+ const nativeInput = container.querySelector(+ "[data-testid='folder-input']"+ ) as HTMLInputElement;+ Object.defineProperty(nativeInput, "value", {+ writable: true,+ value: "foo / bar",+ });+ nativeInput.dispatchEvent(new Event("change", { bubbles: true }));+ });++ // onFolderChange should have been called — at minimum once on mount with initial folder+ expect(onFolderChange).toHaveBeenCalled();++ unmount();+ });++ test("selecting a tree node updates folder and closes popover", async () => {+ const onFolderChange = vi.fn();+ const { container, render, unmount } = renderIntoContainer(+ <FolderForm folder="/my" onFolderChange={onFolderChange} />+ );+ render();++ // First open the popover via focus+ const input = container.querySelector(+ "[data-testid='folder-input']"+ ) as HTMLInputElement;+ act(() => {+ input.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));+ });++ // Tree now rendered via portal+ expect(document.body.querySelector("[data-testid='tree']")).not.toBeNull();++ // Find tree node row and click it (mock renders folderTree.children: /my/foo, /my/bar)+ const treeNodes = document.body.querySelectorAll(+ "[data-testid='tree'] > div"+ );+ expect(treeNodes.length).toBeGreaterThan(0);++ await act(async () => {+ (treeNodes[0] as HTMLElement).click();+ // queueMicrotask fires in the next microtask+ await new Promise((r) => setTimeout(r, 0));+ });++ // onFolderChange should have been called with the selected node key+ expect(onFolderChange).toHaveBeenCalledWith("/my/foo");++ // Tree should no longer be rendered (popover closed)+ expect(document.body.querySelector("[data-testid='tree']")).toBeNull();++ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/FolderForm.tsx b/frontend/src/react/components/sql-editor/FolderForm.tsxnew file mode 100644index 0000000000..a5d85c0633--- /dev/null+++ b/frontend/src/react/components/sql-editor/FolderForm.tsx@@ -0,0 +1,190 @@+import { ChevronDown, ChevronRight } from "lucide-react";+import { useEffect, useRef, useState } from "react";+import { useTranslation } from "react-i18next";+import { Input } from "@/react/components/ui/input";+import { LAYER_ROOT_ID } from "@/react/components/ui/layer";+import { Popover, PopoverContent } from "@/react/components/ui/popover";+import type { TreeDataNode } from "@/react/components/ui/tree";+import { Tree } from "@/react/components/ui/tree";+import { useVueState } from "@/react/hooks/useVueState";+import { cn } from "@/react/lib/utils";+import { useSQLEditorWorksheetStore } from "@/store";+import type { WorksheetFolderNode } from "@/views/sql-editor/Sheet";+import { TreeNodePrefix } from "./TreeNodePrefix";++type Props = {+ readonly folder: string;+ readonly onFolderChange: (folder: string) => void;+};++function toTreeData(+ node: WorksheetFolderNode+): TreeDataNode<WorksheetFolderNode> {+ return {+ id: node.key,+ data: node,+ children: node.children.map(toTreeData),+ };+}++export function FolderForm({ folder, onFolderChange }: Props) {+ const { t } = useTranslation();++ const sheetStore = useSQLEditorWorksheetStore();+ const viewContext = sheetStore.getContextByView("my");++ const folderTree = useVueState(() => viewContext.folderTree.value);+ const rootPath = useVueState(() => viewContext.folderContext.rootPath.value);++ const [folderPath, setFolderPath] = useState(folder);+ const [showPopover, setShowPopover] = useState(false);++ const containerRef = useRef<HTMLDivElement>(null);+ const inputRef = useRef<HTMLInputElement>(null);++ // Close the popover on a mousedown outside the input AND outside the+ // overlay layer (where the portalled popup lives). Base UI's PopoverTrigger+ // toggles on click, which means a second click on the input would close the+ // popover even though the user wants to keep typing — so we bypass Trigger+ // entirely and manage open state ourselves.+ useEffect(() => {+ if (!showPopover) return;+ const overlayRoot = document.getElementById(LAYER_ROOT_ID.overlay);+ const handler = (e: MouseEvent) => {+ const target = e.target as Node;+ if (containerRef.current?.contains(target)) return;+ if (overlayRoot?.contains(target)) return;+ setShowPopover(false);+ };+ document.addEventListener("mousedown", handler);+ return () => document.removeEventListener("mousedown", handler);+ }, [showPopover]);++ // Sync incoming folder prop → local state+ useEffect(() => {+ setFolderPath(folder);+ }, [folder]);++ // Emit changes upward whenever folderPath changes+ useEffect(() => {+ onFolderChange(folderPath);+ }, [folderPath, onFolderChange]);++ const formattedFolderPath = (() => {+ let val = folderPath.replace(rootPath, "");+ if (val[0] === "/") {+ val = val.slice(1);+ }+ return val.split("/").join(" / ");+ })();++ const handleInput = (raw: string) => {+ let changedVal = raw;+ if (changedVal.endsWith(" /")) {+ changedVal = changedVal.slice(0, -2);+ }+ if (changedVal.endsWith(".")) {+ changedVal = changedVal.slice(0, -1);+ }+ const rawPath = changedVal+ .split("/")+ .map((p) => p.trim())+ .join("/");+ setFolderPath(rawPath);+ };++ // User explicitly clicked a row. Set the folder and close the popover.+ const handleUserClick = (id: string) => {+ setFolderPath(id);+ queueMicrotask(() => setShowPopover(false));+ };++ const treeData = folderTree.children.map(toTreeData);++ const searchMatch = (node: TreeDataNode<WorksheetFolderNode>) => {+ if (!folderPath) return true;+ return node.data.key.includes(folderPath);+ };++ return (+ <div className="flex flex-col gap-y-2">+ <div>+ <p>{t("sql-editor.choose-folder")}</p>+ <span className="textinfolabel">+ {t("sql-editor.choose-folder-tips")}+ </span>+ </div>+ <div ref={containerRef}>+ <Input+ ref={inputRef}+ data-testid="folder-input"+ value={formattedFolderPath}+ placeholder={t("sql-editor.choose-folder")}+ onFocus={() => setShowPopover(true)}+ onClick={() => setShowPopover(true)}+ onChange={(e) => handleInput(e.target.value)}+ />+ <Popover open={showPopover} onOpenChange={setShowPopover}>+ <PopoverContent+ side="bottom"+ align="start"+ anchor={inputRef}+ initialFocus={false}+ finalFocus={false}+ style={{ width: "var(--anchor-width)" }}+ className="p-1"+ >+ <Tree<WorksheetFolderNode>+ data={treeData}+ selectedIds={folderPath ? [folderPath] : []}+ searchTerm={folderPath || undefined}+ searchMatch={searchMatch}+ height={240}+ renderNode={({ node, style }) => {+ const data = node.data.data;+ const hasChildren = data.children.length > 0;+ return (+ <div+ key={node.id}+ style={style}+ className={cn(+ "flex items-center gap-x-1 px-1.5 py-1 cursor-pointer select-none rounded-xs text-sm text-control",+ node.isSelected ? "bg-accent/10" : "hover:bg-accent/5"+ )}+ onClick={() => handleUserClick(node.id)}+ >+ {hasChildren ? (+ <button+ type="button"+ onClick={(e) => {+ e.stopPropagation();+ node.toggle();+ }}+ className="flex items-center justify-center size-4 shrink-0 text-control hover:text-main"+ >+ {node.isOpen ? (+ <ChevronDown className="size-3" />+ ) : (+ <ChevronRight className="size-3" />+ )}+ </button>+ ) : (+ <span className="size-4 shrink-0" />+ )}+ <TreeNodePrefix+ node={data}+ isOpen={node.isOpen}+ rootPath={rootPath}+ view="my"+ />+ <span className="truncate">{data.label}</span>+ </div>+ );+ }}+ />+ </PopoverContent>+ </Popover>+ </div>+ </div>+ );+}diff --git a/frontend/src/react/components/sql-editor/SaveSheetModal.test.tsx b/frontend/src/react/components/sql-editor/SaveSheetModal.test.tsxnew file mode 100644index 0000000000..4e9c3c96e4--- /dev/null+++ b/frontend/src/react/components/sql-editor/SaveSheetModal.test.tsx@@ -0,0 +1,329 @@+import type { ReactElement } from "react";+import { act } from "react";+import { createRoot } from "react-dom/client";+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++// ---- hoisted mocks ----------------------------------------------------------++const eventHandlers: Record<string, (payload: unknown) => void> = {};++const mocks = vi.hoisted(() => ({+ useTranslation: vi.fn(() => ({ t: (key: string) => key })),+ worksheetStore: {+ getWorksheetByName: vi.fn(),+ },+ editorWorksheetStore: {+ abortAutoSave: vi.fn(),+ maybeUpdateWorksheet: vi.fn().mockResolvedValue(undefined),+ createWorksheet: vi.fn().mockResolvedValue(undefined),+ },+ sheetContext: {+ getPwdForWorksheet: vi.fn(() => ""),+ getFoldersForWorksheet: vi.fn(() => []),+ },+}));++vi.mock("react-i18next", () => ({+ useTranslation: mocks.useTranslation,+}));++vi.mock("@/react/hooks/useSQLEditorEvent", () => ({+ useSQLEditorEvent: vi.fn(+ (event: string, handler: (payload: unknown) => void) => {+ eventHandlers[event] = handler;+ }+ ),+}));++vi.mock("@/store", () => ({+ useWorkSheetStore: vi.fn(() => mocks.worksheetStore),+ useSQLEditorWorksheetStore: vi.fn(() => mocks.editorWorksheetStore),+}));++vi.mock("@/views/sql-editor/Sheet", () => ({+ useSheetContextByView: vi.fn(() => mocks.sheetContext),+}));++vi.mock("@/types", () => ({+ UNKNOWN_ID: 0,+}));++vi.mock("@/utils", () => ({+ extractWorksheetID: vi.fn((worksheet: string) => {+ if (!worksheet) return "0";+ // Return non-zero for worksheets that look like real ones+ return worksheet.includes("/worksheets/") ? "123" : "0";+ }),+}));++// Mock Dialog so it renders into DOM without the Base UI portal+vi.mock("@/react/components/ui/dialog", () => ({+ Dialog: ({+ children,+ open,+ onOpenChange,+ }: {+ children: React.ReactNode;+ open: boolean;+ onOpenChange?: (next: boolean) => void;+ }) => (+ <div+ data-testid="dialog"+ data-open={String(open)}+ onClick={() => onOpenChange?.(false)}+ >+ {open ? children : null}+ </div>+ ),+ DialogContent: ({+ children,+ className,+ }: {+ children: React.ReactNode;+ className?: string;+ }) => (+ <div data-testid="dialog-content" className={className}>+ {children}+ </div>+ ),+ DialogTitle: ({ children }: { children: React.ReactNode }) => (+ <h2 data-testid="dialog-title">{children}</h2>+ ),+}));++// Mock Button — pass through disabled + onClick+vi.mock("@/react/components/ui/button", () => ({+ Button: ({+ children,+ onClick,+ disabled,+ variant,+ }: {+ children: React.ReactNode;+ onClick?: () => void;+ disabled?: boolean;+ variant?: string;+ }) => (+ <button data-variant={variant} disabled={disabled} onClick={onClick}>+ {children}+ </button>+ ),+}));++// Mock Input — standard <input>+vi.mock("@/react/components/ui/input", () => ({+ Input: ({+ value,+ onChange,+ placeholder,+ maxLength,+ }: {+ value: string;+ onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;+ placeholder?: string;+ maxLength?: number;+ }) => (+ <input+ data-testid="title-input"+ value={value}+ onChange={onChange}+ placeholder={placeholder}+ maxLength={maxLength}+ />+ ),+}));++// Mock FolderForm so we don't re-test tree behavior+vi.mock("./FolderForm", () => ({+ FolderForm: () => <div data-testid="folder-form-mock" />,+}));++// ---- helpers ----------------------------------------------------------------++const renderIntoContainer = (element: ReactElement) => {+ const container = document.createElement("div");+ document.body.appendChild(container);+ const root = createRoot(container);+ return {+ container,+ render: () => {+ act(() => {+ root.render(element);+ });+ },+ unmount: () => {+ act(() => {+ root.unmount();+ });+ container.remove();+ },+ };+};++const emitSaveSheet = (payload: unknown) => {+ act(() => {+ eventHandlers["save-sheet"]?.(payload);+ });+};++// Tab fixtures+const tabWithoutWorksheet = {+ id: "tab-1",+ title: "Untitled",+ worksheet: undefined,+ connection: { database: "instances/inst1/databases/db1" },+ statement: "SELECT 1",+};++const savedTab = {+ id: "tab-2",+ title: "My Sheet",+ worksheet: "projects/proj1/worksheets/123",+ connection: { database: "instances/inst1/databases/db1" },+ statement: "SELECT 2",+};++let SaveSheetModal: typeof import("./SaveSheetModal").SaveSheetModal;++beforeEach(async () => {+ vi.clearAllMocks();+ mocks.useTranslation.mockReturnValue({ t: (key: string) => key });+ mocks.editorWorksheetStore.abortAutoSave.mockReset();+ mocks.editorWorksheetStore.maybeUpdateWorksheet.mockResolvedValue(undefined);+ mocks.editorWorksheetStore.createWorksheet.mockResolvedValue(undefined);+ mocks.sheetContext.getPwdForWorksheet.mockReturnValue("");+ mocks.sheetContext.getFoldersForWorksheet.mockReturnValue([]);+ mocks.worksheetStore.getWorksheetByName.mockReturnValue(undefined);++ ({ SaveSheetModal } = await import("./SaveSheetModal"));+});++afterEach(() => {+ document.body.innerHTML = "";+});++// ---- tests ------------------------------------------------------------------++describe("SaveSheetModal", () => {+ test("1. Unsaved tab shows modal with prefilled title", () => {+ const { container, render, unmount } = renderIntoContainer(+ <SaveSheetModal />+ );+ render();++ emitSaveSheet({ tab: tabWithoutWorksheet });++ const dialog = container.querySelector("[data-testid='dialog']");+ expect(dialog).not.toBeNull();+ expect(dialog?.getAttribute("data-open")).toBe("true");++ const input = container.querySelector(+ "[data-testid='title-input']"+ ) as HTMLInputElement;+ expect(input).not.toBeNull();+ expect(input.value).toBe("Untitled");++ unmount();+ });++ test("2. Saved tab without editTitle saves silently — no modal, maybeUpdateWorksheet called", async () => {+ const { container, render, unmount } = renderIntoContainer(+ <SaveSheetModal />+ );+ render();++ await act(async () => {+ eventHandlers["save-sheet"]?.({ tab: savedTab });+ });++ const dialog = container.querySelector("[data-testid='dialog']");+ expect(dialog?.getAttribute("data-open")).toBe("false");++ expect(+ mocks.editorWorksheetStore.maybeUpdateWorksheet+ ).toHaveBeenCalledWith(+ expect.objectContaining({+ tabId: savedTab.id,+ worksheet: savedTab.worksheet,+ title: savedTab.title,+ database: savedTab.connection.database,+ statement: savedTab.statement,+ })+ );++ unmount();+ });++ test("3. Saved tab with editTitle: true shows modal", () => {+ const { container, render, unmount } = renderIntoContainer(+ <SaveSheetModal />+ );+ render();++ emitSaveSheet({ tab: savedTab, editTitle: true });++ const dialog = container.querySelector("[data-testid='dialog']");+ expect(dialog?.getAttribute("data-open")).toBe("true");++ unmount();+ });++ test("4. Save button is disabled when title is empty", () => {+ const { container, render, unmount } = renderIntoContainer(+ <SaveSheetModal />+ );+ render();++ // Open modal with a tab that has an empty title — Save must be disabled+ const tabWithEmptyTitle = {+ ...tabWithoutWorksheet,+ title: "",+ };+ emitSaveSheet({ tab: tabWithEmptyTitle });++ const buttons = container.querySelectorAll("button");+ const saveButton = Array.from(buttons).find(+ (b) => b.textContent === "common.save"+ ) as HTMLButtonElement;+ expect(saveButton).not.toBeNull();+ expect(saveButton.disabled).toBe(true);++ unmount();+ });++ test("5. Clicking Save on unsaved tab calls createWorksheet with correct args", async () => {+ const { container, render, unmount } = renderIntoContainer(+ <SaveSheetModal />+ );+ render();++ // Open modal for unsaved tab with a title set+ emitSaveSheet({ tab: tabWithoutWorksheet });++ const saveButton = Array.from(container.querySelectorAll("button")).find(+ (b) => b.textContent === "common.save"+ ) as HTMLButtonElement;+ expect(saveButton).not.toBeNull();+ expect(saveButton.disabled).toBe(false);++ await act(async () => {+ saveButton.click();+ });++ expect(mocks.editorWorksheetStore.abortAutoSave).toHaveBeenCalled();+ expect(mocks.editorWorksheetStore.createWorksheet).toHaveBeenCalledWith(+ expect.objectContaining({+ tabId: tabWithoutWorksheet.id,+ title: tabWithoutWorksheet.title,+ statement: tabWithoutWorksheet.statement,+ database: tabWithoutWorksheet.connection.database,+ })+ );++ unmount();+ });+});diff --git a/frontend/src/react/components/sql-editor/SaveSheetModal.tsx b/frontend/src/react/components/sql-editor/SaveSheetModal.tsxnew file mode 100644index 0000000000..191e62ee13--- /dev/null+++ b/frontend/src/react/components/sql-editor/SaveSheetModal.tsx@@ -0,0 +1,133 @@+import { useState } from "react";+import { useTranslation } from "react-i18next";+import { Button } from "@/react/components/ui/button";+import {+ Dialog,+ DialogContent,+ DialogTitle,+} from "@/react/components/ui/dialog";+import { Input } from "@/react/components/ui/input";+import { useSQLEditorEvent } from "@/react/hooks/useSQLEditorEvent";+import { useSQLEditorWorksheetStore, useWorkSheetStore } from "@/store";+import type { SQLEditorTab } from "@/types";+import { UNKNOWN_ID } from "@/types";+import { extractWorksheetID } from "@/utils";+import { useSheetContextByView } from "@/views/sql-editor/Sheet";+import { FolderForm } from "./FolderForm";++export function SaveSheetModal() {+ const { t } = useTranslation();+ const worksheetStore = useWorkSheetStore();+ const editorWorksheetStore = useSQLEditorWorksheetStore();+ const sheetContext = useSheetContextByView("my");++ const [open, setOpen] = useState(false);+ const [title, setTitle] = useState("");+ const [folder, setFolder] = useState("");+ const [rawTab, setRawTab] = useState<SQLEditorTab | undefined>(undefined);++ const needShowModal = (tab: SQLEditorTab) => !tab.worksheet;++ const doSaveSheet = async (+ tab?: SQLEditorTab,+ tabTitle?: string,+ tabFolder?: string+ ) => {+ const effectiveTab = tab ?? rawTab;+ if (!effectiveTab) {+ setOpen(false);+ return;+ }+ // Silent path passes title + folder explicitly because React state setters+ // are async — reading state here would observe the prior modal's values.+ const effectiveTitle = tabTitle ?? title;+ if (effectiveTitle === "") {+ return;+ }+ const effectiveFolder = tabFolder ?? folder;++ editorWorksheetStore.abortAutoSave();++ const { worksheet, connection, statement, id: tabId } = effectiveTab;+ const folders = sheetContext.getFoldersForWorksheet(effectiveFolder);++ const sheetId = extractWorksheetID(worksheet ?? "");+ if (sheetId !== String(UNKNOWN_ID)) {+ await editorWorksheetStore.maybeUpdateWorksheet({+ tabId,+ worksheet,+ title: effectiveTitle,+ database: connection.database,+ statement,+ folders,+ });+ } else {+ await editorWorksheetStore.createWorksheet({+ tabId,+ title: effectiveTitle,+ statement,+ database: connection.database,+ folders,+ });+ }++ setOpen(false);+ };++ useSQLEditorEvent("save-sheet", ({ tab, editTitle }) => {+ setTitle(tab.title);+ setRawTab(tab);++ // Compute the folder synchronously: for an already-saved worksheet, use+ // its current pwd; otherwise reset. We then both reflect this in state+ // (for the modal-open path) AND pass it explicitly into doSaveSheet+ // (for the silent path) — bypassing React's async setState batching.+ let nextFolder = "";+ if (tab.worksheet) {+ const worksheet = worksheetStore.getWorksheetByName(tab.worksheet);+ if (worksheet) {+ nextFolder = sheetContext.getPwdForWorksheet(worksheet);+ }+ }+ setFolder(nextFolder);++ if (needShowModal(tab) || editTitle) {+ setOpen(true);+ } else {+ void doSaveSheet(tab, tab.title, nextFolder);+ }+ });++ const close = () => setOpen(false);++ return (+ <Dialog open={open} onOpenChange={(next) => !next && close()}>+ <DialogContent className="w-[32rem] max-w-[calc(100vw-8rem)] 2xl:max-w-[calc(100vw-8rem)] p-4">+ <DialogTitle>{t("sql-editor.save-sheet")}</DialogTitle>+ <div className="flex flex-col gap-y-3">+ <div className="flex flex-col gap-y-1">+ <p>+ {t("common.title")}+ <span className="text-error ml-0.5">*</span>+ </p>+ <Input+ value={title}+ onChange={(e) => setTitle(e.target.value)}+ placeholder={t("sql-editor.save-sheet-input-placeholder")}+ maxLength={200}+ />+ </div>+ <FolderForm folder={folder} onFolderChange={setFolder} />+ <div className="flex justify-end gap-x-2 mt-4">+ <Button variant="outline" onClick={close}>+ {t("common.close")}+ </Button>+ <Button disabled={!title} onClick={() => void doSaveSheet()}>+ {t("common.save")}+ </Button>+ </div>+ </div>+ </DialogContent>+ </Dialog>+ );+}diff --git a/frontend/src/react/components/sql-editor/TreeNodePrefix.test.tsx b/frontend/src/react/components/sql-editor/TreeNodePrefix.test.tsxnew file mode 100644index 0000000000..af6343af26--- /dev/null+++ b/frontend/src/react/components/sql-editor/TreeNodePrefix.test.tsx@@ -0,0 +1,158 @@+import { act } from "react";+import { createRoot } from "react-dom/client";+import { afterEach, beforeEach, describe, expect, test } from "vitest";+import type { WorksheetFolderNode } from "@/views/sql-editor/Sheet";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++// Stub ResizeObserver — not provided by jsdom+globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++const makeNode = (+ overrides?: Partial<WorksheetFolderNode>+): WorksheetFolderNode => ({+ key: "/my/folder",+ label: "folder",+ editable: true,+ children: [],+ empty: false,+ ...overrides,+});++let TreeNodePrefix: typeof import("./TreeNodePrefix").TreeNodePrefix;++const renderIntoContainer = (element: React.ReactElement) => {+ const container = document.createElement("div");+ const root = createRoot(container);+ document.body.appendChild(container);+ return {+ container,+ render: () => {+ act(() => {+ root.render(element);+ });+ },+ unmount: () => {+ act(() => {+ root.unmount();+ });+ container.remove();+ },+ };+};++beforeEach(async () => {+ ({ TreeNodePrefix } = await import("./TreeNodePrefix"));+});++afterEach(() => {+ document.body.innerHTML = "";+});++describe("TreeNodePrefix", () => {+ test("renders FileCode icon when node has a worksheet property", () => {+ const node = makeNode({+ worksheet: {+ name: "worksheets/ws1",+ title: "My Query",+ folders: [],+ type: "worksheet",+ },+ });+ const { container, render, unmount } = renderIntoContainer(+ <TreeNodePrefix node={node} isOpen={false} rootPath="/my" view="my" />+ );+ render();++ // lucide-react renders SVGs with className "lucide-<icon-name>"+ const svg = container.querySelector("svg");+ expect(svg).not.toBeNull();+ expect(svg?.classList.contains("lucide-file-code")).toBe(true);++ unmount();+ });++ test("renders FolderOpen icon when node is expanded (id in expandedIds)", () => {+ const node = makeNode({ key: "/my/folder" });+ const _expandedIds = new Set(["/my/folder"]);++ const { container, render, unmount } = renderIntoContainer(+ <TreeNodePrefix node={node} isOpen={true} rootPath="/my" view="my" />+ );+ render();++ const svg = container.querySelector("svg");+ expect(svg).not.toBeNull();+ expect(svg?.classList.contains("lucide-folder-open")).toBe(true);++ unmount();+ });++ test("renders view-specific root icon when node.key === rootPath", () => {+ const rootPath = "/my";+ const node = makeNode({ key: rootPath });++ // my view → FolderCode (default)+ const {+ container: c1,+ render: r1,+ unmount: u1,+ } = renderIntoContainer(+ <TreeNodePrefix+ node={node}+ isOpen={false}+ rootPath={rootPath}+ view="my"+ />+ );+ r1();+ expect(+ c1.querySelector("svg")?.classList.contains("lucide-folder-code")+ ).toBe(true);+ u1();++ // draft view → FolderPen+ const {+ container: c2,+ render: r2,+ unmount: u2,+ } = renderIntoContainer(+ <TreeNodePrefix+ node={node}+ isOpen={false}+ rootPath={rootPath}+ view="draft"+ />+ );+ r2();+ expect(+ c2.querySelector("svg")?.classList.contains("lucide-folder-pen")+ ).toBe(true);+ u2();++ // shared view → FolderSync+ const {+ container: c3,+ render: r3,+ unmount: u3,+ } = renderIntoContainer(+ <TreeNodePrefix+ node={node}+ isOpen={false}+ rootPath={rootPath}+ view="shared"+ />+ );+ r3();+ expect(+ c3.querySelector("svg")?.classList.contains("lucide-folder-sync")+ ).toBe(true);+ u3();+ });+});diff --git a/frontend/src/react/components/sql-editor/TreeNodePrefix.tsx b/frontend/src/react/components/sql-editor/TreeNodePrefix.tsxnew file mode 100644index 0000000000..b54422f310--- /dev/null+++ b/frontend/src/react/components/sql-editor/TreeNodePrefix.tsx@@ -0,0 +1,41 @@+import {+ FileCode,+ FolderCode,+ FolderMinus,+ FolderOpen,+ FolderPen,+ FolderSync,+} from "lucide-react";+import type { WorksheetFolderNode } from "@/views/sql-editor/Sheet";+import type { SheetViewMode } from "@/views/sql-editor/Sheet/types";++type Props = {+ readonly node: WorksheetFolderNode;+ readonly isOpen: boolean;+ readonly rootPath: string;+ readonly view: SheetViewMode;+};++export function TreeNodePrefix({ node, isOpen, rootPath, view }: Props) {+ const cls = "size-4 text-control shrink-0";++ if (node.worksheet) {+ return <FileCode className={cls} />;+ }+ if (isOpen) {+ return <FolderOpen className={cls} />;+ }+ if (node.key === rootPath) {+ if (view === "draft") {+ return <FolderPen className={cls} />;+ }+ if (view === "shared") {+ return <FolderSync className={cls} />;+ }+ return <FolderCode className={cls} />;+ }+ if (node.empty) {+ return <FolderMinus className={cls} />;+ }+ return <FolderCode className={cls} />;+}diff --git a/frontend/src/react/components/ui/popover.tsx b/frontend/src/react/components/ui/popover.tsxindex 20398a837a..ce723bd008 100644--- a/frontend/src/react/components/ui/popover.tsx+++ b/frontend/src/react/components/ui/popover.tsx@@ -16,12 +16,14 @@ function PopoverContent({side = "bottom",align = "end",sideOffset = 4,+ anchor,ref,...props}: ComponentProps<typeof BasePopover.Popup> & {side?: ComponentProps<typeof BasePopover.Positioner>["side"];align?: ComponentProps<typeof BasePopover.Positioner>["align"];sideOffset?: ComponentProps<typeof BasePopover.Positioner>["sideOffset"];+ anchor?: ComponentProps<typeof BasePopover.Positioner>["anchor"];}) {return (<BasePopover.Portal container={getLayerRoot("overlay")}>@@ -29,6 +31,7 @@ function PopoverContent({side={side}align={align}sideOffset={sideOffset}+ anchor={anchor}className={LAYER_SURFACE_CLASS}><BasePopover.Popupdiff --git a/frontend/src/react/components/ui/tree.test.tsx b/frontend/src/react/components/ui/tree.test.tsxnew file mode 100644index 0000000000..7ea0892efa--- /dev/null+++ b/frontend/src/react/components/ui/tree.test.tsx@@ -0,0 +1,211 @@+import { act } from "react";+import { createRoot } from "react-dom/client";+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";+import type { TreeDataNode } from "./tree";+import { Tree } from "./tree";++(+ globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }+).IS_REACT_ACT_ENVIRONMENT = true;++// Stub ResizeObserver — not provided by jsdom+globalThis.ResizeObserver = class ResizeObserver {+ observe() {}+ unobserve() {}+ disconnect() {}+};++interface TestPayload {+ label: string;+}++const makeNode = (+ id: string,+ label: string,+ children?: TreeDataNode<TestPayload>[]+): TreeDataNode<TestPayload> => ({+ id,+ data: { label },+ children,+});++describe("Tree", () => {+ let container: HTMLDivElement;+ let root: ReturnType<typeof createRoot>;++ beforeEach(() => {+ container = document.createElement("div");+ document.body.appendChild(container);+ root = createRoot(container);+ });++ afterEach(async () => {+ await act(async () => {+ root.unmount();+ });+ document.body.removeChild(container);+ });++ test("renders nodes from data via renderNode", async () => {+ const nodes = [makeNode("a", "Alpha"), makeNode("b", "Beta")];++ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ renderNode={({ node, style }) => (+ <div style={style} data-testid={`node-${node.id}`}>+ {node.data.data.label}+ </div>+ )}+ height={200}+ />+ );+ });++ expect(container.textContent).toContain("Alpha");+ expect(container.textContent).toContain("Beta");+ });++ test("clicking a row fires onSelect with that row's id", async () => {+ const nodes = [makeNode("x", "X Node"), makeNode("y", "Y Node")];+ const handleSelect = vi.fn();++ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ renderNode={({ node, style }) => (+ <div style={style} data-testid={`node-${node.id}`}>+ {node.data.data.label}+ </div>+ )}+ onSelect={handleSelect}+ height={200}+ />+ );+ });++ // Click the rendered node by finding it in the container+ const xNode = container.querySelector('[data-testid="node-x"]');+ expect(xNode).not.toBeNull();++ await act(async () => {+ xNode!.dispatchEvent(new MouseEvent("click", { bubbles: true }));+ });++ expect(handleSelect).toHaveBeenCalledWith(expect.arrayContaining(["x"]));+ });++ test("selectedIds prop reflects selection via node.isSelected in renderNode", async () => {+ const nodes = [makeNode("sel", "Selected"), makeNode("other", "Other")];+ const isSelectedMap: Record<string, boolean> = {};++ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ selectedIds={["sel"]}+ renderNode={({ node, style }) => {+ isSelectedMap[node.id] = node.isSelected;+ return (+ <div+ style={style}+ data-testid={`node-${node.id}`}+ data-selected={node.isSelected ? "true" : "false"}+ >+ {node.data.data.label}+ </div>+ );+ }}+ height={200}+ />+ );+ });++ // Wait for render cycle to complete and check selection via DOM+ const selNode = container.querySelector('[data-testid="node-sel"]');+ expect(selNode).not.toBeNull();+ // The node should reflect isSelected via the data-selected attribute+ // OR via react-arborist's internal selection state after render+ expect(isSelectedMap["sel"]).toBe(true);+ expect(isSelectedMap["other"]).toBe(false);+ });++ test("expandedIds controls open/close of children", async () => {+ const nodes = [+ makeNode("root", "Root", [+ makeNode("child1", "Child One"),+ makeNode("child2", "Child Two"),+ ]),+ ];++ // Render first without expanded IDs — children should not be visible+ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ expandedIds={[]}+ renderNode={({ node, style }) => (+ <div style={style} data-testid={`node-${node.id}`}>+ {node.data.data.label}+ </div>+ )}+ height={200}+ />+ );+ });++ expect(container.textContent).not.toContain("Child One");++ // Now expand the root node+ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ expandedIds={["root"]}+ renderNode={({ node, style }) => (+ <div style={style} data-testid={`node-${node.id}`}>+ {node.data.data.label}+ </div>+ )}+ height={200}+ />+ );+ });++ expect(container.textContent).toContain("Child One");+ expect(container.textContent).toContain("Child Two");+ });++ test("searchTerm with searchMatch filters visible nodes", async () => {+ const nodes = [+ makeNode("foo", "Foobar"),+ makeNode("baz", "Bazqux"),+ makeNode("fooAlso", "Foo Also"),+ ];++ await act(async () => {+ root.render(+ <Tree+ data={nodes}+ searchTerm="foo"+ searchMatch={(node, term) =>+ node.data.label.toLowerCase().includes(term.toLowerCase())+ }+ renderNode={({ node, style }) => (+ <div style={style} data-testid={`node-${node.id}`}>+ {node.data.data.label}+ </div>+ )}+ height={200}+ />+ );+ });++ // Nodes matching "foo" should be present; "Bazqux" should not appear+ expect(container.textContent).toContain("Foobar");+ expect(container.textContent).toContain("Foo Also");+ expect(container.textContent).not.toContain("Bazqux");+ });+});diff --git a/frontend/src/react/components/ui/tree.tsx b/frontend/src/react/components/ui/tree.tsxnew file mode 100644index 0000000000..62416b1b9e--- /dev/null+++ b/frontend/src/react/components/ui/tree.tsx@@ -0,0 +1,122 @@+import type { CSSProperties, ReactNode } from "react";+import { useEffect, useRef } from "react";+import type { NodeApi, TreeApi } from "react-arborist";+import { Tree as ArboristTree } from "react-arborist";+import { cn } from "@/react/lib/utils";++export interface TreeDataNode<T> {+ readonly id: string;+ readonly children?: readonly TreeDataNode<T>[];+ readonly data: T;+}++export interface TreeProps<T> {+ readonly data: readonly TreeDataNode<T>[];+ readonly renderNode: (args: {+ node: NodeApi<TreeDataNode<T>>;+ style: CSSProperties;+ }) => ReactNode;++ readonly selectedIds?: readonly string[];+ readonly expandedIds?: readonly string[];+ readonly onSelect?: (ids: readonly string[]) => void;+ readonly onToggle?: (id: string) => void;++ readonly searchTerm?: string;+ readonly searchMatch?: (node: TreeDataNode<T>, term: string) => boolean;++ readonly height?: number;+ readonly rowHeight?: number;+ readonly indent?: number;++ readonly className?: string;+}++export function Tree<T>({+ data,+ renderNode,+ selectedIds,+ expandedIds,+ onSelect,+ onToggle,+ searchTerm,+ searchMatch,+ height = 300,+ rowHeight = 28,+ indent = 16,+ className,+}: TreeProps<T>) {+ const treeRef = useRef<TreeApi<TreeDataNode<T>> | null>(null);+ const prevExpandedRef = useRef<readonly string[] | undefined>(undefined);++ // Sync expandedIds to the arborist tree programmatically+ useEffect(() => {+ const tree = treeRef.current;+ if (!tree) return;++ const prev = new Set(prevExpandedRef.current ?? []);+ const next = new Set(expandedIds ?? []);++ // Close nodes that were previously open but no longer in expandedIds+ for (const id of prev) {+ if (!next.has(id)) {+ tree.close(id);+ }+ }++ // Open nodes that are in expandedIds but not previously open+ for (const id of next) {+ if (!prev.has(id)) {+ tree.open(id);+ }+ }++ prevExpandedRef.current = expandedIds;+ }, [expandedIds]);++ const handleSelect = (nodes: NodeApi<TreeDataNode<T>>[]) => {+ onSelect?.(nodes.map((n) => n.id));+ };++ const defaultSearchMatch = (+ node: NodeApi<TreeDataNode<T>>,+ term: string+ ): boolean => {+ const d = node.data.data as Record<string, unknown>;+ const label = typeof d?.label === "string" ? d.label : node.data.id;+ return label.toLowerCase().includes(term.toLowerCase());+ };++ const resolvedSearchMatch = searchMatch+ ? (node: NodeApi<TreeDataNode<T>>, term: string) =>+ searchMatch(node.data, term)+ : defaultSearchMatch;++ return (+ <div+ className={cn("outline-none focus:outline-none rounded-sm", className)}+ >+ <ArboristTree<TreeDataNode<T>>+ ref={treeRef}+ data={data as TreeDataNode<T>[]}+ idAccessor="id"+ childrenAccessor="children"+ selection={selectedIds?.[0]}+ onSelect={handleSelect}+ onToggle={onToggle}+ searchTerm={searchTerm}+ searchMatch={resolvedSearchMatch}+ openByDefault={false}+ disableDrag+ disableDrop+ disableEdit+ height={height}+ rowHeight={rowHeight}+ indent={indent}+ width="100%"+ >+ {({ node, style }) => renderNode({ node, style })}+ </ArboristTree>+ </div>+ );+}diff --git a/frontend/src/react/locales/en-US.json b/frontend/src/react/locales/en-US.jsonindex 19a7cc6e63..bcaaf39a60 100644--- a/frontend/src/react/locales/en-US.json+++ b/frontend/src/react/locales/en-US.json@@ -2444,6 +2444,8 @@"batch-query": {"batch": "Batch"},+ "choose-folder": "Choose or create folder",+ "choose-folder-tips": "You can create a new folder by entering a non-existent path. The folders should be joined with a \"/\".","connect-to-a-database": "Connect to database","duration-day": "{{days}} day","duration-days": "{{days}} days",@@ -2483,6 +2485,8 @@},"revoke-access": "Revoke","revoke-confirm": "Are you sure you want to revoke this access grant?",+ "save-sheet": "Save Sheet",+ "save-sheet-input-placeholder": "Please input a sheet name","search-history-by-statement": "Search by statement","select-a-database-to-start": "Select a database to start","self": "SQL Editor",diff --git a/frontend/src/react/locales/es-ES.json b/frontend/src/react/locales/es-ES.jsonindex 129e8a89ce..e59bb40034 100644--- a/frontend/src/react/locales/es-ES.json+++ b/frontend/src/react/locales/es-ES.json@@ -2444,6 +2444,8 @@"batch-query": {"batch": "Lote"},+ "choose-folder": "Seleccionar o crear una carpeta",+ "choose-folder-tips": "Puedes crear una nueva carpeta introduciendo una ruta que no exista. Las carpetas deben unirse con una barra diagonal (\"/\").","connect-to-a-database": "Conectar a base de datos","duration-day": "{{days}} day","duration-days": "{{days}} days",@@ -2483,6 +2485,8 @@},"revoke-access": "Revoke","revoke-confirm": "Are you sure you want to revoke this access grant?",+ "save-sheet": "Guardar hoja",+ "save-sheet-input-placeholder": "Por favor, ingresa un nombre para la hoja","search-history-by-statement": "Búsqueda por enunciado","select-a-database-to-start": "Seleccione una base de datos para comenzar","self": "Editor de SQL",diff --git a/frontend/src/react/locales/ja-JP.json b/frontend/src/react/locales/ja-JP.jsonindex 094beeff5a..5361701144 100644--- a/frontend/src/react/locales/ja-JP.json+++ b/frontend/src/react/locales/ja-JP.json@@ -2444,6 +2444,8 @@"batch-query": {"batch": "バッチ"},+ "choose-folder": "フォルダを選択または作成",+ "choose-folder-tips": "存在しないパスを入力することで新しいフォルダを作成できます。フォルダは「/」で結合する必要があります。","connect-to-a-database": "データベースに接続","duration-day": "{{days}} day","duration-days": "{{days}} days",@@ -2483,6 +2485,8 @@},"revoke-access": "Revoke","revoke-confirm": "Are you sure you want to revoke this access grant?",+ "save-sheet": "ワークシートの保存",+ "save-sheet-input-placeholder": "ワークシート名を入力してください","search-history-by-statement": "ステートメントで検索","select-a-database-to-start": "開始するにはデータベースを選択してください","self": "SQLエディタ",diff --git a/frontend/src/react/locales/vi-VN.json b/frontend/src/react/locales/vi-VN.jsonindex f35c7440b8..4a5eea94d0 100644--- a/frontend/src/react/locales/vi-VN.json+++ b/frontend/src/react/locales/vi-VN.json@@ -2444,6 +2444,8 @@"batch-query": {"batch": "Hàng loạt"},+ "choose-folder": "Chọn hoặc tạo thư mục",+ "choose-folder-tips": "Bạn có thể tạo một thư mục mới bằng cách nhập một đường dẫn không tồn tại. Các thư mục phải được nối bằng dấu \"/\".","connect-to-a-database": "Kết nối cơ sở dữ liệu","duration-day": "{{days}} day","duration-days": "{{days}} days",@@ -2483,6 +2485,8 @@},"revoke-access": "Revoke","revoke-confirm": "Are you sure you want to revoke this access grant?",+ "save-sheet": "Lưu trang tính",+ "save-sheet-input-placeholder": "Vui lòng nhập tên trang tính","search-history-by-statement": "Tìm kiếm theo câu lệnh","select-a-database-to-start": "Chọn một cơ sở dữ liệu để bắt đầu","self": "Trình soạn thảo SQL",diff --git a/frontend/src/react/locales/zh-CN.json b/frontend/src/react/locales/zh-CN.jsonindex 7125f8a1e3..70899cb5e1 100644--- a/frontend/src/react/locales/zh-CN.json+++ b/frontend/src/react/locales/zh-CN.json@@ -2444,6 +2444,8 @@"batch-query": {"batch": "批量"},+ "choose-folder": "选择或创建文件夹",+ "choose-folder-tips": "您可以通过输入不存在的路径来创建新文件夹。文件夹之间应以\"/\"连接。","connect-to-a-database": "连接数据库","duration-day": "{{days}} 天","duration-days": "{{days}} 天",@@ -2483,6 +2485,8 @@},"revoke-access": "撤销","revoke-confirm": "确定要撤销此访问授权吗?",+ "save-sheet": "保存工作表",+ "save-sheet-input-placeholder": "请输入工作表名称","search-history-by-statement": "搜索 SQL 语句","select-a-database-to-start": "选择数据库以开始","self": "SQL 编辑器",diff --git a/frontend/src/react/mount.ts b/frontend/src/react/mount.tsindex 684a4131f4..1d77831b9e 100644--- a/frontend/src/react/mount.ts+++ b/frontend/src/react/mount.ts@@ -14,6 +14,9 @@ const authComponentLoaders = import.meta.glob([const sqlEditorComponentLoaders = import.meta.glob("./components/sql-editor/*.tsx");+const sharedComponentLoaders = import.meta.glob(+ "./components/ClassificationTree.tsx"+);const pageLoaders = {...settingsPageLoaders,...projectPageLoaders,@@ -22,6 +25,7 @@ const pageLoaders = {...authPageLoaders,...authComponentLoaders,...sqlEditorComponentLoaders,+ ...sharedComponentLoaders,};// biome-ignore lint/suspicious/noExplicitAny: React types conflict with Vue JSX in vue-tsc@@ -64,6 +68,7 @@ const pageDirs = ["./pages/auth","./components/auth","./components/sql-editor",+ "./components",];export function resolveReactPagePath(name: string): string | undefined {diff --git a/frontend/src/react/pages/settings/DataClassificationPage.tsx b/frontend/src/react/pages/settings/DataClassificationPage.tsxindex 062a7fe434..b9885ef158 100644--- a/frontend/src/react/pages/settings/DataClassificationPage.tsx+++ b/frontend/src/react/pages/settings/DataClassificationPage.tsx@@ -1,21 +1,14 @@import { create } from "@bufbuild/protobuf";import { isEmpty } from "lodash-es";-import { ChevronRight, Pencil, Trash2, Undo2, X } from "lucide-react";-import {- type JSX,- useCallback,- useEffect,- useMemo,- useRef,- useState,-} from "react";+import { Pencil, Trash2, Undo2, X } from "lucide-react";+import { useCallback, useEffect, useMemo, useRef, useState } from "react";import { useTranslation } from "react-i18next";import { v4 as uuidv4 } from "uuid";import classificationExample from "@/components/SensitiveData/classification-example.json";+import { ClassificationTree } from "@/react/components/ClassificationTree";import { FeatureAttention } from "@/react/components/FeatureAttention";import { LearnMoreLink } from "@/react/components/LearnMoreLink";import { Button } from "@/react/components/ui/button";-import { SearchInput } from "@/react/components/ui/search-input";import { useVueState } from "@/react/hooks/useVueState";import {pushNotification,@@ -134,225 +127,6 @@ function MonacoJSONEditor({return <div ref={containerRef} className="w-full h-full" />;}-// --- Classification tree -----interface TreeNode {- key: string;- label: string;- level?: number;- children: TreeNode[];-}--function sortClassification(a: { id: string }, b: { id: string }): number {- const id1s = a.id.split("-");- const id2s = b.id.split("-");- if (id1s.length !== id2s.length) return id1s.length - id2s.length;- for (let i = 0; i < id1s.length; i++) {- if (id1s[i] === id2s[i]) continue;- if (Number.isNaN(Number(id1s[i])) || Number.isNaN(Number(id2s[i]))) {- return id1s[i].localeCompare(id2s[i]);- }- return Number(id1s[i]) - Number(id2s[i]);- }- return 0;-}--interface ClassificationMap {- [key: string]: {- id: string;- label: string;- level?: number;- children: ClassificationMap;- };-}--function buildTreeData(- config: DataClassificationSetting_DataClassificationConfig-): TreeNode[] {- const classifications = Object.values(config.classification).sort(- sortClassification- );- const map: ClassificationMap = {};- for (const c of classifications) {- const ids = c.id.split("-");- let tmp = map;- for (let i = 0; i < ids.length - 1; i++) {- const parentKey = ids.slice(0, i + 1).join("-");- if (!tmp[parentKey]) break;- tmp = tmp[parentKey].children;- }- tmp[c.id] = {- id: c.id,- label: c.title,- level: c.level,- children: {},- };- }-- function toNodes(m: ClassificationMap): TreeNode[] {- return Object.values(m)- .sort(sortClassification)- .map((item) => ({- key: item.id,- label: `${item.id} ${item.label}`,- level: item.level,- children: toNodes(item.children),- }));- }- return toNodes(map);-}--const bgColorList = [- "bg-green-200",- "bg-yellow-200",- "bg-orange-300",- "bg-amber-500",- "bg-red-500",-];--function LevelBadge({- level,- config,-}: {- level: number;- config: DataClassificationSetting_DataClassificationConfig;-}) {- const levelObj = config.levels.find((l) => l.level === level);- if (!levelObj) return null;- const color = bgColorList[level - 1] ?? "bg-control-bg-hover";- return (- <span className={`ml-1 px-1 py-0.5 rounded-xs text-xs ${color}`}>- {levelObj.title}- </span>- );-}--function highlightText(text: string, keyword: string) {- if (!keyword) return text;- const lower = text.toLowerCase();- const kw = keyword.toLowerCase();- const parts: (string | JSX.Element)[] = [];- let cursor = 0;- let idx = lower.indexOf(kw, cursor);- while (idx !== -1) {- if (idx > cursor) parts.push(text.slice(cursor, idx));- parts.push(- <b key={idx} className="text-accent">- {text.slice(idx, idx + keyword.length)}- </b>- );- cursor = idx + keyword.length;- idx = lower.indexOf(kw, cursor);- }- if (cursor < text.length) parts.push(text.slice(cursor));- return <>{parts}</>;-}--function matchesSearch(node: TreeNode, keyword: string): boolean {- if (!keyword) return true;- const lower = keyword.toLowerCase();- if (node.label.toLowerCase().includes(lower)) return true;- return node.children.some((c) => matchesSearch(c, lower));-}--function ClassificationTreeNode({- node,- config,- searchText,- defaultExpanded,-}: {- node: TreeNode;- config: DataClassificationSetting_DataClassificationConfig;- searchText: string;- defaultExpanded: boolean;-}) {- const [expanded, setExpanded] = useState(defaultExpanded);- const hasChildren = node.children.length > 0;-- // Auto-expand when searching- useEffect(() => {- if (searchText) setExpanded(true);- else setExpanded(defaultExpanded);- }, [searchText, defaultExpanded]);-- const filteredChildren = useMemo(- () => node.children.filter((c) => matchesSearch(c, searchText)),- [node.children, searchText]- );-- return (- <div>- <div- className="flex items-center gap-1 py-1 px-1 rounded-xs hover:bg-control-bg cursor-pointer select-none"- onClick={() => hasChildren && setExpanded(!expanded)}- >- {hasChildren ? (- <ChevronRight- className={`size-4 shrink-0 transition-transform ${expanded ? "rotate-90" : ""}`}- />- ) : (- <span className="w-4 shrink-0" />- )}- <span>{highlightText(node.label, searchText)}</span>- {node.level != null && node.level !== 0 && (- <LevelBadge level={node.level} config={config} />- )}- </div>- {expanded && hasChildren && (- <div className="ml-4">- {filteredChildren.map((child) => (- <ClassificationTreeNode- key={child.key}- node={child}- config={config}- searchText={searchText}- defaultExpanded={defaultExpanded}- />- ))}- </div>- )}- </div>- );-}--function ClassificationTree({- config,-}: {- config: DataClassificationSetting_DataClassificationConfig;-}) {- const { t } = useTranslation();- const [searchText, setSearchText] = useState("");- const treeData = useMemo(() => buildTreeData(config), [config]);-- const filteredTree = useMemo(- () => treeData.filter((n) => matchesSearch(n, searchText)),- [treeData, searchText]- );-- return (- <div className="flex flex-col gap-4 h-full">- <div>- <SearchInput- value={searchText}- onChange={(e) => setSearchText(e.target.value)}- placeholder={t("schema-template.classification.search")}- />- </div>- <div>- {filteredTree.map((node) => (- <ClassificationTreeNode- key={node.key}- node={node}- config={config}- searchText={searchText}- defaultExpanded={true}- />- ))}- </div>- </div>- );-}-// --- Main page ---export function DataClassificationPage() {@@ -546,7 +320,9 @@ export function DataClassificationPage() {{t("common.cancel")}</Button><Button- disabled={!editorDirty || !hasClassificationFeature}+ disabled={+ (!editorDirty && !emptyConfig) || !hasClassificationFeature+ }onClick={onSave}>{t("common.save")}diff --git a/frontend/src/views/sql-editor/Sheet/folder.ts b/frontend/src/store/modules/sqlEditor/folder.tssimilarity index 80%rename from frontend/src/views/sql-editor/Sheet/folder.tsrename to frontend/src/store/modules/sqlEditor/folder.tsindex 898d6b434e..3af4dd7ada 100644--- a/frontend/src/views/sql-editor/Sheet/folder.ts+++ b/frontend/src/store/modules/sqlEditor/folder.ts@@ -1,17 +1,16 @@import { sortBy } from "lodash-es";-import { type ComputedRef, computed } from "vue";-import { useCurrentUserV1 } from "@/store";+import { storeToRefs } from "pinia";+import { computed } from "vue";+import { useCurrentUserV1, useSQLEditorStore } from "@/store";import {storageKeySqlEditorWorksheetFolder,useDynamicLocalStorage,} from "@/utils";-import type { SheetViewMode } from "./types";+import type { SheetViewMode } from "@/views/sql-editor/Sheet/types";-export const useFolderByView = (- viewMode: SheetViewMode,- project: ComputedRef<string>-) => {+export const buildFolderContext = (viewMode: SheetViewMode) => {const me = useCurrentUserV1();+ const { project } = storeToRefs(useSQLEditorStore());const rootPath = computed(() => `/${viewMode}`);const localCacheKey = computed(() =>@@ -25,9 +24,6 @@ export const useFolderByView = (const folders = computed(() => sortBy([...localCache.value]));- // A valid folder path should be like "/{root}/xx"- // It must not end with "/", for example, "xxx/" is not valid- // It must starts with "/{root}", like "/mine/xxx"const ensureFolderPath = (path: string) => {let p = path.split("/")@@ -62,15 +58,9 @@ export const useFolderByView = (dig: boolean;}) => {const parentPrefix = `${parent}/`;- return (- // ensure not self- path !== parentPrefix &&- // ensure is subfolder- path.startsWith(parentPrefix) &&- dig- ? true- : !path.replace(parentPrefix, "").includes("/")- );+ return path !== parentPrefix && path.startsWith(parentPrefix) && dig+ ? true+ : !path.replace(parentPrefix, "").includes("/");};const removeFolder = (path: string) => {@@ -88,7 +78,6 @@ export const useFolderByView = (const moveFolder = (from: string, to: string) => {const fromPath = ensureFolderPath(from);const toPath = ensureFolderPath(to);-const newSet = new Set<string>();for (const path of localCache.value.values()) {if (@@ -130,3 +119,5 @@ export const useFolderByView = (isSubFolder,};};++export type FolderContext = ReturnType<typeof buildFolderContext>;diff --git a/frontend/src/store/modules/sqlEditor/index.ts b/frontend/src/store/modules/sqlEditor/index.tsindex 33d94e23e2..1e3738e5fc 100644--- a/frontend/src/store/modules/sqlEditor/index.ts+++ b/frontend/src/store/modules/sqlEditor/index.ts@@ -4,4 +4,5 @@ export * from "./tree";export * from "./queryHistory";export * from "./uiState";export * from "./webTerminal";+export * from "./folder";export * from "./worksheet";diff --git a/frontend/src/store/modules/sqlEditor/worksheet.test.ts b/frontend/src/store/modules/sqlEditor/worksheet.test.tsindex e7c07971c9..a29d1503d7 100644--- a/frontend/src/store/modules/sqlEditor/worksheet.test.ts+++ b/frontend/src/store/modules/sqlEditor/worksheet.test.ts@@ -6,6 +6,9 @@ vi.mock("@/store", async () => {const { ref } = await import("vue");return {pushNotification: vi.fn(),+ useCurrentUserV1: vi.fn(() => ({+ value: { email: "[email protected]" },+ })),useProjectIamPolicyStore: vi.fn(() => ({getOrFetchProjectIamPolicy: vi.fn(),})),@@ -13,13 +16,15 @@ vi.mock("@/store", async () => {getOrFetchProjectByName: vi.fn(),})),useSQLEditorStore: vi.fn(() => ({- project: "projects/default",+ project: ref("projects/default"),projectContextReady: true,setProject: vi.fn(),})),useSQLEditorTabStore: vi.fn(() => ({updateTab: vi.fn(),getTabById: vi.fn(),+ currentTab: undefined,+ openTabList: [],})),useSQLEditorUIStore: vi.fn(() => ({showConnectionPanel: ref(false),@@ -28,31 +33,45 @@ vi.mock("@/store", async () => {getWorksheetByName: vi.fn(),patchWorksheet: vi.fn(),upsertWorksheetOrganizer: vi.fn(),+ batchUpsertWorksheetOrganizers: vi.fn(),createWorksheet: vi.fn(),+ fetchWorksheetList: vi.fn(),+ myWorksheetList: [],+ sharedWorksheetList: [],})),};});// Mock @/utils completely to avoid native binary dependencies-vi.mock("@/utils", () => ({- extractWorksheetConnection: vi.fn(- async ({ database }: { database: string }) => ({- database,- instance: "",- })- ),- isSimilarDefaultSQLEditorTabTitle: vi.fn(() => false),- isWorksheetWritableV1: vi.fn(() => true),- NEW_WORKSHEET_TITLE: "Untitled",- suggestedTabTitleForSQLEditorConnection: vi.fn(() => "Untitled"),- isValidDatabaseName: vi.fn(() => false),- isValidProjectName: vi.fn((name: string) => name.startsWith("projects/")),-}));+vi.mock("@/utils", async () => {+ const { ref } = await import("vue");+ return {+ extractWorksheetConnection: vi.fn(+ async ({ database }: { database: string }) => ({+ database,+ instance: "",+ })+ ),+ isSimilarDefaultSQLEditorTabTitle: vi.fn(() => false),+ isWorksheetWritableV1: vi.fn(() => true),+ NEW_WORKSHEET_TITLE: "Untitled",+ suggestedTabTitleForSQLEditorConnection: vi.fn(() => "Untitled"),+ isValidDatabaseName: vi.fn(() => false),+ isValidProjectName: vi.fn((name: string) => name.startsWith("projects/")),+ storageKeySqlEditorWorksheetFilter: vi.fn(() => "filter-key"),+ storageKeySqlEditorWorksheetTree: vi.fn(() => "tree-key"),+ storageKeySqlEditorWorksheetFolder: vi.fn(() => "folder-key"),+ useDynamicLocalStorage: vi.fn((_: unknown, defaultValue: unknown) =>+ ref(defaultValue)+ ),+ };+});// Mock @/types to avoid importing native modules transitivelyvi.mock("@/types", () => ({isValidDatabaseName: vi.fn(() => false),isValidProjectName: vi.fn((name: string) => name.startsWith("projects/")),+ DEBOUNCE_SEARCH_DELAY: 300,}));// Mock @/views/sql-editor/Sheetdiff --git a/frontend/src/store/modules/sqlEditor/worksheet.ts b/frontend/src/store/modules/sqlEditor/worksheet.tsindex 73ada59ce0..33a64a084c 100644--- a/frontend/src/store/modules/sqlEditor/worksheet.ts+++ b/frontend/src/store/modules/sqlEditor/worksheet.ts@@ -1,8 +1,14 @@import { create } from "@bufbuild/protobuf";-import { isUndefined } from "lodash-es";-import { defineStore } from "pinia";-import { nextTick, ref } from "vue";+import { useDebounceFn } from "@vueuse/core";+import Emittery from "emittery";+import { isEqual, isUndefined, orderBy } from "lodash-es";+import { defineStore, storeToRefs } from "pinia";+import scrollIntoView from "scroll-into-view-if-needed";+import type { Ref } from "vue";+import { computed, nextTick, ref, watch } from "vue";+import { t } from "@/plugins/i18n";import {+ useCurrentUserV1,useProjectIamPolicyStore,useProjectV1Store,useSQLEditorStore,@@ -11,8 +17,13 @@ import {useWorkSheetStore,} from "@/store";import type { SQLEditorTab } from "@/types";-import { isValidDatabaseName, isValidProjectName } from "@/types";import {+ DEBOUNCE_SEARCH_DELAY,+ isValidDatabaseName,+ isValidProjectName,+} from "@/types";+import {+ type Worksheet,Worksheet_Visibility,WorksheetSchema,} from "@/types/proto-es/v1/worksheet_service_pb";@@ -20,10 +31,312 @@ import {extractWorksheetConnection,isSimilarDefaultSQLEditorTabTitle,NEW_WORKSHEET_TITLE,+ storageKeySqlEditorWorksheetFilter,+ storageKeySqlEditorWorksheetTree,suggestedTabTitleForSQLEditorConnection,+ useDynamicLocalStorage,} from "@/utils";import { sqlEditorEvents } from "@/views/sql-editor/events";import { openWorksheetByName } from "@/views/sql-editor/Sheet";+import type { SheetViewMode } from "@/views/sql-editor/Sheet/types";+import { buildFolderContext } from "./folder";++export type { FolderContext } from "./folder";++// ---- types ------------------------------------------------------------------++type SheetTreeEvents = Emittery<{+ "on-built": { viewMode: SheetViewMode };+}>;++export interface WorksheetLikeItem {+ name: string;+ title: string;+ folders: string[];+ type: "worksheet" | "draft";+}++export interface WorksheetFolderNode {+ key: string;+ label: string;+ editable: boolean;+ isLeaf?: boolean;+ empty?: boolean;+ worksheet?: WorksheetLikeItem;+ children: WorksheetFolderNode[];+ [key: string]: unknown;+}++export interface WorksheetFilter {+ keyword: string;+ onlyShowStarred: boolean;+ showMine: boolean;+ showShared: boolean;+ showDraft: boolean;+}++// ---- per-view tree context --------------------------------------------------++const convertToWorksheetLikeItem = (+ worksheet: Worksheet+): WorksheetLikeItem => ({+ name: worksheet.name,+ title: worksheet.title,+ folders: worksheet.folders,+ type: "worksheet",+});++const buildViewContext = (+ viewMode: SheetViewMode,+ filterRef: Ref<WorksheetFilter>+) => {+ const sheetStore = useWorkSheetStore();+ const folderContext = buildFolderContext(viewMode);+ const me = useCurrentUserV1();+ const events: SheetTreeEvents = new Emittery();+ const tabStore = useSQLEditorTabStore();+ const { project } = storeToRefs(useSQLEditorStore());++ const isInitialized = ref(false);+ const isLoading = ref(false);++ const rootNodeLabel = computed(() => {+ switch (viewMode) {+ case "my":+ return t("sheet.mine");+ case "shared":+ return t("sheet.shared");+ case "draft":+ return t("common.draft");+ default:+ return "";+ }+ });++ const getRootTreeNode = (): WorksheetFolderNode => ({+ isLeaf: false,+ children: [],+ key: folderContext.rootPath.value,+ label: rootNodeLabel.value,+ editable: false,+ });++ const sheetTree = ref<WorksheetFolderNode>(getRootTreeNode());++ const worksheetList = computed((): Worksheet[] => {+ let list: Worksheet[] = [];+ switch (viewMode) {+ case "my":+ list = sheetStore.myWorksheetList;+ break;+ case "shared":+ list = sheetStore.sharedWorksheetList;+ break;+ default:+ break;+ }+ list = list.filter((sheet) => sheet.project === project.value);+ if (filterRef.value.onlyShowStarred) {+ return list.filter((sheet) => sheet.starred);+ }+ return list;+ });++ const sheetLikeItemList = computed((): WorksheetLikeItem[] => {+ switch (viewMode) {+ case "my":+ case "shared":+ return worksheetList.value.map(convertToWorksheetLikeItem);+ case "draft":+ return tabStore.openTabList+ .filter((tab) => !tab.worksheet)+ .map((tab) => ({+ name: tab.id,+ title: tab.title,+ folders: [],+ type: "draft" as const,+ }));+ default:+ return [];+ }+ });++ const getPathesForWorksheet = (worksheet: {+ folders: string[];+ }): string[] => {+ const pathes = [folderContext.rootPath.value];+ let currentPath = folderContext.rootPath.value;+ for (const folder of worksheet.folders) {+ currentPath = folderContext.ensureFolderPath(`${currentPath}/${folder}`);+ pathes.push(currentPath);+ }+ return pathes;+ };++ const getPwdForWorksheet = (worksheet: { folders: string[] }): string => {+ return folderContext.ensureFolderPath(worksheet.folders.join("/"));+ };++ const getKeyForWorksheet = (worksheet: WorksheetLikeItem): string => {+ return [+ getPwdForWorksheet(worksheet),+ `bytebase-${worksheet.type}-${worksheet.name.split("/").slice(-1)[0]}.sql`,+ ].join("/");+ };++ const getFoldersForWorksheet = (path: string): string[] => {+ const pathes = path.replace(folderContext.rootPath.value, "").split("/");+ if (pathes.slice(-1)[0].endsWith(".sql")) {+ pathes.pop();+ }+ return pathes.map((p) => p.trim()).filter((p) => p);+ };++ const buildTree = (+ parent: WorksheetFolderNode,+ worksheetsByFolder: Map<string, WorksheetLikeItem[]>,+ hideEmpty: boolean+ ) => {+ const subfolders = folderContext+ .listSubFolders(parent.key)+ .map((folder) => ({+ isLeaf: false,+ children: [],+ key: folder,+ label: folder.split("/").slice(-1)[0],+ editable: true,+ }));++ let empty = true;+ for (const childNode of subfolders) {+ const subtree = buildTree(childNode, worksheetsByFolder, hideEmpty);+ if (!subtree.empty || !hideEmpty) {+ parent.children.push(subtree);+ }+ if (!subtree.empty) {+ empty = false;+ }+ }++ const sheets = orderBy(+ worksheetsByFolder.get(parent.key) || [],+ (item) => item.title+ ).map((worksheet) => ({+ isLeaf: true,+ key: getKeyForWorksheet(worksheet),+ label: worksheet.title,+ worksheet,+ editable: true,+ children: [],+ }));++ parent.children.push(...sheets);+ parent.empty = sheets.length === 0 && empty;+ if (parent.key !== folderContext.rootPath.value) {+ parent.isLeaf = parent.children.length === 0;+ }++ return parent;+ };++ const folderTree = computed(() =>+ buildTree(getRootTreeNode(), new Map(), false)+ );++ const rebuildTree = useDebounceFn(() => {+ const folderPaths = new Set<string>([]);+ const worksheetsByFolder = new Map<string, WorksheetLikeItem[]>();++ for (const worksheet of sheetLikeItemList.value) {+ for (const path of getPathesForWorksheet(worksheet)) {+ folderPaths.add(path);+ }+ const pwd = getPwdForWorksheet(worksheet);+ if (!worksheetsByFolder.has(pwd)) {+ worksheetsByFolder.set(pwd, []);+ }+ worksheetsByFolder.get(pwd)!.push(worksheet);+ }++ folderContext.mergeFolders(folderPaths);+ sheetTree.value = buildTree(+ getRootTreeNode(),+ worksheetsByFolder,+ filterRef.value.onlyShowStarred+ );+ events.emit("on-built", { viewMode });+ }, DEBOUNCE_SEARCH_DELAY);++ watch(+ [() => folderContext.folders.value, () => sheetLikeItemList.value],+ ([newFolders, newSheetList], [oldFolders, oldSheetList]) => {+ if (+ isEqual(newFolders, oldFolders) &&+ isEqual(newSheetList, oldSheetList)+ ) {+ return;+ }+ rebuildTree();+ }+ );++ const fetchSheetList = async () => {+ isLoading.value = true;+ try {+ switch (viewMode) {+ case "my":+ await sheetStore.fetchWorksheetList(+ project.value,+ `creator == "users/${me.value.email}"`+ );+ break;+ case "shared":+ await sheetStore.fetchWorksheetList(+ project.value,+ [+ `creator != "users/${me.value.email}"`,+ `visibility in ["${Worksheet_Visibility[Worksheet_Visibility.PROJECT_READ]}","${Worksheet_Visibility[Worksheet_Visibility.PROJECT_WRITE]}"]`,+ ].join(" && ")+ );+ break;+ default:+ break;+ }+ rebuildTree();+ isInitialized.value = true;+ } finally {+ isLoading.value = false;+ }+ };++ return {+ events,+ isInitialized,+ isLoading,+ sheetTree,+ folderTree,+ fetchSheetList,+ folderContext,+ getKeyForWorksheet,+ getFoldersForWorksheet,+ getPathesForWorksheet,+ getPwdForWorksheet,+ };+};++export type ViewContext = ReturnType<typeof buildViewContext>;++// ---- constants --------------------------------------------------------------++const INITIAL_FILTER: WorksheetFilter = {+ keyword: "",+ showShared: true,+ showMine: true,+ showDraft: true,+ onlyShowStarred: false,+};++// ---- Pinia store ------------------------------------------------------------export const useSQLEditorWorksheetStore = defineStore("sqlEditorWorksheet",@@ -34,6 +347,11 @@ export const useSQLEditorWorksheetStore = defineStore(const projectIamPolicyStore = useProjectIamPolicyStore();const worksheetStore = useWorkSheetStore();const uiStore = useSQLEditorUIStore();+ const me = useCurrentUserV1();+ const worksheetV1Store = useWorkSheetStore();+ const { project } = storeToRefs(useSQLEditorStore());++ // ---- save-flow actions --------------------------------------------------const autoSaveController = ref<AbortController | null>(null);@@ -192,12 +510,175 @@ export const useSQLEditorWorksheetStore = defineStore(}};+ // ---- shared filter ------------------------------------------------------++ const filter = useDynamicLocalStorage<WorksheetFilter>(+ computed(() =>+ storageKeySqlEditorWorksheetFilter(project.value, me.value.email)+ ),+ { ...INITIAL_FILTER }+ );+ const filterChanged = computed(+ () => !isEqual(filter.value, INITIAL_FILTER)+ );++ // Safe computed ref — useDynamicLocalStorage can yield null during SSR+ // or on first boot; fall back to INITIAL_FILTER so consumers always get+ // a non-null WorksheetFilter.+ const safeFilter = computed<WorksheetFilter>(+ () => filter.value ?? { ...INITIAL_FILTER }+ );++ // ---- per-view contexts (lazily initialised) -----------------------------+ // Use a plain Map (not reactive) — the ViewContext objects have their own+ // internal reactive state. Wrapping in reactive() would auto-unwrap refs.++ const contexts = new Map<SheetViewMode, ViewContext>();++ const ensureContext = (view: SheetViewMode): ViewContext => {+ if (!contexts.has(view)) {+ contexts.set(view, buildViewContext(view, safeFilter));+ }+ return contexts.get(view)!;+ };++ const getContextByView = (view: SheetViewMode) => ensureContext(view);++ // Eagerly build all three so watchers/selection logic works on startup.+ const viewContexts = {+ get my() {+ return ensureContext("my");+ },+ get shared() {+ return ensureContext("shared");+ },+ get draft() {+ return ensureContext("draft");+ },+ };++ // ---- shared tree-selection state ----------------------------------------++ const expandedKeys = useDynamicLocalStorage<Set<string>>(+ computed(() =>+ storageKeySqlEditorWorksheetTree(project.value, me.value.email)+ ),+ new Set([+ ensureContext("my").folderContext.rootPath.value,+ ensureContext("shared").folderContext.rootPath.value,+ ensureContext("draft").folderContext.rootPath.value,+ ])+ );+ const selectedKeys = ref<string[]>([]);++ const isWorksheetCreator = (worksheet: { creator: string }) =>+ worksheet.creator === `users/${me.value.email}`;++ watch(+ () => ({+ tabId: tabStore.currentTab?.id,+ worksheetName: tabStore.currentTab?.worksheet,+ }),+ async ({ tabId, worksheetName }) => {+ selectedKeys.value = [];+ if (!tabId) {+ return;+ }++ let viewMode: SheetViewMode = "draft";+ let worksheetLikeItem: WorksheetLikeItem | undefined;++ if (worksheetName) {+ const worksheet = worksheetV1Store.getWorksheetByName(worksheetName);+ if (!worksheet) {+ return;+ }+ worksheetLikeItem = {+ name: worksheet.name,+ title: worksheet.title,+ folders: worksheet.folders,+ type: "worksheet",+ };+ viewMode = isWorksheetCreator(worksheet) ? "my" : "shared";+ } else {+ worksheetLikeItem = {+ name: tabId,+ folders: [],+ title: "",+ type: "draft",+ };+ }++ const viewContext = ensureContext(viewMode);+ const key = viewContext.getKeyForWorksheet(worksheetLikeItem);+ selectedKeys.value = [key];++ for (const path of viewContext.getPathesForWorksheet(+ worksheetLikeItem+ )) {+ expandedKeys.value.add(path);+ }++ await nextTick();+ const dom = document.querySelector(`[data-item-key="${key}"]`);+ if (dom) {+ scrollIntoView(dom, {+ scrollMode: "if-needed",+ block: "nearest",+ });+ }+ },+ { immediate: true }+ );++ // ---- editing node -------------------------------------------------------++ const editingNode = ref<+ { node: WorksheetFolderNode; rawLabel: string } | undefined+ >();++ // ---- batch operations ---------------------------------------------------++ const batchUpdateWorksheetFolders = async (+ worksheets: { name: string; folders: string[] }[]+ ) => {+ if (worksheets.length === 0) {+ return;+ }+ await worksheetV1Store.batchUpsertWorksheetOrganizers(+ worksheets.map((worksheet) => ({+ organizer: {+ worksheet: worksheet.name,+ folders: worksheet.folders,+ },+ updateMask: ["folders"],+ }))+ );+ };++ // ---- view ref (preserved for SheetContext compat) -----------------------++ const view = ref<SheetViewMode>("my");+return {+ // Save-flow actionsautoSaveController,abortAutoSave,maybeSwitchProject,maybeUpdateWorksheet,createWorksheet,+ // SheetContext-compatible fields+ view,+ viewContexts,+ filter,+ filterChanged,+ expandedKeys,+ selectedKeys,+ editingNode,+ isWorksheetCreator,+ batchUpdateWorksheetFolders,+ // view context accessor+ getContextByView,};});diff --git a/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vue b/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vuedeleted file mode 100644index edfe9a77f8..0000000000--- a/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vue+++ /dev/null@@ -1,137 +0,0 @@-<template>- <div class="flex flex-col gap-y-2">- <div>- <p>{{ $t("sql-editor.choose-folder") }}</p>- <span class="textinfolabel">- {{ $t("sql-editor.choose-folder-tips") }}- </span>- </div>- <NPopover- placement="bottom"- :show="showPopover"- :show-arrow="false"- trigger="manual"- :width="folderInputRef?.wrapperElRef?.clientWidth"- >- <template #trigger>- <NInput- ref="folderInputRef"- :value="formattedFolderPath"- :placeholder="$t('sql-editor.choose-folder')"- @focus="onFocus"- @update:value="onInput"- />- </template>- <NTree- ref="folderTreeRef"- block-line- block-node- virtual-scroll- :clearable="false"- :filterable="true"- :pattern="folderPath"- :checkable="false"- :check-on-click="true"- :selectable="true"- :selected-keys="[folderPath]"- :multiple="false"- :data="folderTree.children"- :render-prefix="renderPrefix"- :expanded-keys="expandedKeysArray"- @update:expanded-keys="(keys: string[]) => expandedKeys = new Set(keys)"- @update:selected-keys="onSelect"- />- </NPopover>- </div>-</template>--<script lang="tsx" setup>-import { onClickOutside } from "@vueuse/core";-import { NInput, NPopover, NTree, type TreeOption } from "naive-ui";-import { computed, nextTick, ref, watch } from "vue";-import TreeNodePrefix from "@/views/sql-editor/AsidePanel/WorksheetPane/SheetList/TreeNodePrefix.vue";-import type { WorksheetFolderNode } from "@/views/sql-editor/Sheet";-import { useSheetContextByView } from "@/views/sql-editor/Sheet";--const props = defineProps<{- folder: string;-}>();--const emits = defineEmits<{- (event: "update:folder", folder: string): void;-}>();--const folderPath = ref<string>("");--watch(- () => props.folder,- (val) => (folderPath.value = val),- { immediate: true }-);--watch(- () => folderPath.value,- (val) => emits("update:folder", val)-);--const { folderTree, folderContext, getFoldersForWorksheet } =- useSheetContextByView("my");--const expandedKeys = ref<Set<string>>(new Set([]));-const expandedKeysArray = computed(() => Array.from(expandedKeys.value));-const folderInputRef = ref<InstanceType<typeof NInput>>();-const folderTreeRef = ref<InstanceType<typeof NTree>>();-const showPopover = ref<boolean>(false);--onClickOutside(folderTreeRef, () => {- showPopover.value = false;-});--const formattedFolderPath = computed(() => {- let val = folderPath.value.replace(folderContext.rootPath.value, "");- if (val[0] === "/") {- val = val.slice(1);- }- return val.split("/").join(" / ");-});--const onFocus = () => {- showPopover.value = true;-};--const onSelect = (keys: string[]) => {- folderPath.value = keys[0] ?? "";- nextTick(() => (showPopover.value = false));-};--const onInput = (val: string) => {- let changedVal = val;- if (val.endsWith(" /")) {- changedVal = val.slice(0, -2);- }- if (changedVal.endsWith(".")) {- changedVal = changedVal.slice(0, -1);- }- const rawPath = changedVal- .split("/")- .map((p) => p.trim())- .join("/");- folderPath.value = rawPath;-};--const renderPrefix = ({ option }: { option: TreeOption }) => {- const node = option as WorksheetFolderNode;- return (- <TreeNodePrefix- node={node}- expandedKeys={expandedKeys.value}- rootPath={folderContext.rootPath.value}- view={"my"}- />- );-};--defineExpose({- folders: computed(() => getFoldersForWorksheet(folderPath.value)),-});-</script>diff --git a/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/WorksheetPane.vue b/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/WorksheetPane.vueindex e52ec19bb3..4469b9f5b3 100644--- a/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/WorksheetPane.vue+++ b/frontend/src/views/sql-editor/AsidePanel/WorksheetPane/WorksheetPane.vue@@ -43,7 +43,7 @@quaternarysize="tiny":disabled="checkedWorksheets.length === 0 || loading"- @click="showReorgModal = true"+ @click="() => { pendingMoveFolder = ''; showReorgModal = true; }"><template #icon><FolderInputIcon />@@ -78,10 +78,14 @@<BBModal:show="showReorgModal":title="$t('sheet.move-worksheets')"- @close="() => showReorgModal = false"+ @close="() => { showReorgModal = false; pendingMoveFolder = ''; }"><div class="flex flex-col gap-y-3 w-lg max-w-[calc(100vw-8rem)]">- <FolderForm ref="folderFormRef" :folder="''" />+ <ReactPageMount+ page="FolderForm"+ :folder="pendingMoveFolder"+ :onFolderChange="(val: string) => (pendingMoveFolder = val)"+ /><div class="flex justify-end gap-x-2 mt-4"><NButton @click="showReorgModal = false">{{ $t("common.close") }}</NButton><NButton@@ -102,17 +106,18 @@ import { computed, ref, watch } from "vue";import { BBModal } from "@/bbkit";import { SearchBox } from "@/components/v2";import { t } from "@/plugins/i18n";+import ReactPageMount from "@/react/ReactPageMount.vue";import type {SheetViewMode,WorksheetFolderNode,} from "@/views/sql-editor/Sheet";-import { useSheetContext } from "../../Sheet";+import { useSheetContext, useSheetContextByView } from "../../Sheet";import FilterMenuItem from "./FilterMenuItem.vue";import { SheetTree } from "./SheetList";-import FolderForm from "./SheetList/FolderForm.vue";const { filter, filterChanged, batchUpdateWorksheetFolders } =useSheetContext();+const { getFoldersForWorksheet } = useSheetContextByView("my");const showDropdown = ref<boolean>(false);const mineSheetTreeRef = ref<InstanceType<typeof SheetTree>>();@@ -121,6 +126,7 @@ const checkedNodes = ref<WorksheetFolderNode[]>([]);const multiSelectMode = ref(false);const showReorgModal = ref(false);const loading = ref(false);+const pendingMoveFolder = ref<string>("");const checkedWorksheets = computed(() => {const worksheets: string[] = [];for (const node of checkedNodes.value) {@@ -130,7 +136,6 @@ const checkedWorksheets = computed(() => {}return worksheets;});-const folderFormRef = ref<InstanceType<typeof FolderForm>>();watch([() => multiSelectMode.value, () => filter.value.showMine],@@ -207,7 +212,7 @@ const views = computed((): SheetViewMode[] => {const handleMoveWorksheets = async () => {loading.value = true;try {- const folders = folderFormRef.value?.folders ?? [];+ const folders = getFoldersForWorksheet(pendingMoveFolder.value);await batchUpdateWorksheetFolders(checkedWorksheets.value.map((worksheet) => ({name: worksheet,@@ -216,6 +221,7 @@ const handleMoveWorksheets = async () => {);showReorgModal.value = false;multiSelectMode.value = false;+ pendingMoveFolder.value = "";} finally {loading.value = false;}diff --git a/frontend/src/views/sql-editor/EditorCommon/SaveSheetModal.vue b/frontend/src/views/sql-editor/EditorCommon/SaveSheetModal.vuedeleted file mode 100644index 93ed00a87f..0000000000--- a/frontend/src/views/sql-editor/EditorCommon/SaveSheetModal.vue+++ /dev/null@@ -1,135 +0,0 @@-<template>- <BBModal v-if="showModal" :title="$t('sql-editor.save-sheet')" @close="close">- <div- class="save-sheet-modal flex flex-col gap-y-3 w-lg max-w-[calc(100vw-8rem)]"- >- <div class="flex flex-col gap-y-1">- <p>- {{ $t("common.title") }}- <RequiredStar />- </p>- <NInput- ref="sheetTitleInputRef"- v-model:value="pendingEdit.title"- :placeholder="$t('sql-editor.save-sheet-input-placeholder')"- :maxlength="200"- />- </div>- <FolderForm ref="folderFormRef" :folder="pendingEdit.folder" />- <div class="flex justify-end gap-x-2 mt-4">- <NButton @click="close">{{ $t("common.close") }}</NButton>- <NButton- :disabled="!pendingEdit.title"- type="primary"- @click="doSaveSheet"- >- {{ $t("common.save") }}- </NButton>- </div>- </div>- </BBModal>-</template>--<script lang="tsx" setup>-import { NButton, NInput } from "naive-ui";-import { ref } from "vue";-import { BBModal } from "@/bbkit";-import RequiredStar from "@/components/RequiredStar.vue";-import { useEmitteryEventListener } from "@/composables/useEmitteryEventListener";-import { useWorkSheetStore } from "@/store";-import type { SQLEditorTab } from "@/types";-import { UNKNOWN_ID } from "@/types";-import { extractWorksheetID } from "@/utils";-import FolderForm from "@/views/sql-editor/AsidePanel/WorksheetPane/SheetList/FolderForm.vue";-import { useSheetContextByView } from "@/views/sql-editor/Sheet";-import { useSQLEditorContext } from "../context";--const worksheetV1Store = useWorkSheetStore();-const editorContext = useSQLEditorContext();-const { abortAutoSave } = editorContext;-const { getPwdForWorksheet } = useSheetContextByView("my");-const folderFormRef = ref<InstanceType<typeof FolderForm>>();--const pendingEdit = ref<{- title: string;- folder: string;- rawTab?: SQLEditorTab;-}>({- title: "",- folder: "",-});-const showModal = ref(false);--const doSaveSheet = async () => {- if (!pendingEdit.value.rawTab) {- return close();- }- if (pendingEdit.value.title === "") {- return;- }-- // Abort any in-progress auto-save - manual save takes priority- abortAutoSave();-- const {- worksheet,- connection,- statement,- id: tabId,- } = pendingEdit.value.rawTab;- const folders = folderFormRef.value?.folders ?? [];-- const sheetId = extractWorksheetID(worksheet ?? "");- if (sheetId !== String(UNKNOWN_ID)) {- await editorContext.maybeUpdateWorksheet({- tabId,- worksheet,- title: pendingEdit.value.title,- database: connection.database,- statement,- folders,- });- } else {- await editorContext.createWorksheet({- tabId,- title: pendingEdit.value.title,- statement: pendingEdit.value.rawTab.statement,- database: connection.database,- folders,- });- }-- showModal.value = false;-};--const needShowModal = (tab: SQLEditorTab) => {- // If the sheet is saved, we don't need to show the name popup.- return !tab.worksheet;-};--const close = () => {- showModal.value = false;-};--useEmitteryEventListener(- editorContext.events,- "save-sheet",- ({ tab, editTitle }) => {- pendingEdit.value = {- title: tab.title,- folder: "",- rawTab: tab,- };-- if (needShowModal(tab) || editTitle) {- const worksheet = worksheetV1Store.getWorksheetByName(tab.worksheet);- if (worksheet) {- pendingEdit.value.folder = getPwdForWorksheet(worksheet);- }- showModal.value = true;- return;- }- doSaveSheet();- }-);-</script>diff --git a/frontend/src/views/sql-editor/EditorCommon/index.ts b/frontend/src/views/sql-editor/EditorCommon/index.tsindex fe6a3c2bab..53c7d4fd6f 100644--- a/frontend/src/views/sql-editor/EditorCommon/index.ts+++ b/frontend/src/views/sql-editor/EditorCommon/index.ts@@ -2,13 +2,11 @@ import EditorAction from "./EditorAction.vue";import ExecutingHintModal from "./ExecutingHintModal.vue";import OpenAIButton from "./OpenAIButton/OpenAIButton.vue";import { ResultViewV1 } from "./ResultView";-import SaveSheetModal from "./SaveSheetModal.vue";import SheetConnectionIcon from "./SheetConnectionIcon.vue";export {EditorAction,ExecutingHintModal,- SaveSheetModal,ResultViewV1,SheetConnectionIcon,OpenAIButton,diff --git a/frontend/src/views/sql-editor/EditorPanel/StandardPanel/StandardPanel.vue b/frontend/src/views/sql-editor/EditorPanel/StandardPanel/StandardPanel.vueindex 35b5463848..23731d78bd 100644--- a/frontend/src/views/sql-editor/EditorPanel/StandardPanel/StandardPanel.vue+++ b/frontend/src/views/sql-editor/EditorPanel/StandardPanel/StandardPanel.vue@@ -61,7 +61,7 @@<ExecutingHintModal />- <SaveSheetModal />+ <ReactPageMount page="SaveSheetModal" /></template><ReadonlyModeNotSupported v-else />@@ -96,11 +96,7 @@ import {import type { SQLEditorQueryParams } from "@/types";import { getInstanceResource, instanceV1HasReadonlyMode } from "@/utils";import { useSQLEditorContext } from "../../context";-import {- EditorAction,- ExecutingHintModal,- SaveSheetModal,-} from "../../EditorCommon";+import { EditorAction, ExecutingHintModal } from "../../EditorCommon";import { sqlEditorEvents } from "../../events";import ReadonlyModeNotSupported from "../ReadonlyModeNotSupported.vue";import ResultPanel from "../ResultPanel";diff --git a/frontend/src/views/sql-editor/Sheet/context.ts b/frontend/src/views/sql-editor/Sheet/context.tsindex 679bf79e74..4a99fc92a8 100644--- a/frontend/src/views/sql-editor/Sheet/context.ts+++ b/frontend/src/views/sql-editor/Sheet/context.ts@@ -1,362 +1,70 @@-import { useDebounceFn } from "@vueuse/core";-import Emittery from "emittery";-import { isEqual, orderBy } from "lodash-es";-import type { TreeOption } from "naive-ui";import { storeToRefs } from "pinia";-import scrollIntoView from "scroll-into-view-if-needed";-import type { ComputedRef, InjectionKey, Ref } from "vue";-import { computed, inject, nextTick, provide, ref, watch } from "vue";+import type { InjectionKey } from "vue";import { t } from "@/plugins/i18n";import {pushNotification,- useCurrentUserV1,- useSQLEditorStore,useSQLEditorTabStore,+ useSQLEditorWorksheetStore,useWorkSheetStore,} from "@/store";+import type {+ FolderContext,+ ViewContext,+ WorksheetFilter,+ WorksheetFolderNode,+ WorksheetLikeItem,+} from "@/store/modules/sqlEditor/worksheet";import type { SQLEditorTab, SQLEditorTabMode } from "@/types";-import { DEBOUNCE_SEARCH_DELAY } from "@/types";-import {- type Worksheet,- Worksheet_Visibility,-} from "@/types/proto-es/v1/worksheet_service_pb";import {extractWorksheetConnection,getSheetStatement,isWorksheetReadableV1,- storageKeySqlEditorWorksheetFilter,- storageKeySqlEditorWorksheetTree,- useDynamicLocalStorage,} from "@/utils";-import { useFolderByView } from "./folder";import type { SheetViewMode } from "./types";-type SheetTreeEvents = Emittery<{- "on-built": { viewMode: SheetViewMode };-}>;--export interface WorksheetLikeItem {- name: string;- title: string;- folders: string[];- type: "worksheet" | "draft";-}--export interface WorksheetFolderNode extends TreeOption {- key: string;- label: string;- editable: boolean;- empty?: boolean;- worksheet?: WorksheetLikeItem;- children: WorksheetFolderNode[];-}+// ---- re-export types that consumers import from this module -----------------export interface WorksheetFilter {- keyword: string;- onlyShowStarred: boolean;- showMine: boolean;- showShared: boolean;- showDraft: boolean;-}--const convertToWorksheetLikeItem = (- worksheet: Worksheet-): WorksheetLikeItem => {- return {- name: worksheet.name,- title: worksheet.title,- folders: worksheet.folders,- type: "worksheet",- };+export type {+ FolderContext,+ ViewContext,+ WorksheetFilter,+ WorksheetFolderNode,+ WorksheetLikeItem,};-const useSheetTreeByView = (- viewMode: SheetViewMode,- filter: ComputedRef<WorksheetFilter>,- project: ComputedRef<string>-) => {- const sheetStore = useWorkSheetStore();- const folderContext = useFolderByView(viewMode, project);- const me = useCurrentUserV1();- const events: SheetTreeEvents = new Emittery();- const tabStore = useSQLEditorTabStore();-- const isInitialized = ref(false);- const isLoading = ref(false);-- const rootNodeLabel = computed(() => {- switch (viewMode) {- case "my":- return t("sheet.mine");- case "shared":- return t("sheet.shared");- case "draft":- return t("common.draft");- default:- return "";- }- });-- const getRootTreeNode = (): WorksheetFolderNode => ({- isLeaf: false,- children: [],- key: folderContext.rootPath.value,- label: rootNodeLabel.value,- editable: false,- });- const sheetTree = ref<WorksheetFolderNode>(getRootTreeNode());-- const worksheetList = computed((): Worksheet[] => {- let list: Worksheet[] = [];- switch (viewMode) {- case "my":- list = sheetStore.myWorksheetList;- break;- case "shared":- list = sheetStore.sharedWorksheetList;- break;- default:- break;- }-- list = list.filter((sheet) => sheet.project === project.value);- if (filter.value.onlyShowStarred) {- return list.filter((sheet) => sheet.starred);- }- return list;- });-- const sheetLikeItemList = computed((): WorksheetLikeItem[] => {- switch (viewMode) {- case "my":- case "shared":- return worksheetList.value.map(convertToWorksheetLikeItem);- case "draft":- return tabStore.openTabList- .filter((tab) => !tab.worksheet)- .map((tab) => ({- name: tab.id,- title: tab.title,- folders: [],- type: "draft",- }));- default:- return [];- }- });-- // getPathesForWorksheet returns all folder pathes for a worksheet.- // For example, if the worksheet folders is ["ed", "sample", "pro"],- // then all pathes should be: ["/{root}", "/{root}/ed", "/{root}/ed/sample", "/{root}/ed/sample/pro"]- const getPathesForWorksheet = (worksheet: {- folders: string[];- }): string[] => {- const pathes = [folderContext.rootPath.value];- let currentPath = folderContext.rootPath.value;-- for (const folder of worksheet.folders) {- currentPath = folderContext.ensureFolderPath(`${currentPath}/${folder}`);- pathes.push(currentPath);- }-- return pathes;- };-- // getPwdForWorksheet print working directory (pwd) for the worksheet.- // For example, if the worksheet folders is ["ed", "sample", "pro"],- // then the pwd is: /{root}/ed/sample/pro- const getPwdForWorksheet = (worksheet: { folders: string[] }): string => {- return folderContext.ensureFolderPath(worksheet.folders.join("/"));- };-- // getKeyForWorksheet returns the worksheet node key in the tree node.- // For example, if the worksheet worksheets/001 folders is ["ed", "sample", "pro"],- // then the path should be: /{root}/ed/sample/pro/bytebase-worksheet-001.sql- const getKeyForWorksheet = (worksheet: WorksheetLikeItem): string => {- return [- getPwdForWorksheet(worksheet),- `bytebase-${worksheet.type}-${worksheet.name.split("/").slice(-1)[0]}.sql`,- ].join("/");- };-- // getFoldersForWorksheet returns the folders for a worksheet.- // The folders should NOT contains the root folder- // For example, the fullpath for a worksheet can be: /{root}/ed/sample/bytebase-worksheet-001.sql,- // then the folders should be ["ed", "sample"]- const getFoldersForWorksheet = (path: string): string[] => {- const pathes = path.replace(folderContext.rootPath.value, "").split("/");- if (pathes.slice(-1)[0].endsWith(".sql")) {- pathes.pop();- }- return pathes.map((p) => p.trim()).filter((p) => p);- };-- const buildTree = (- parent: WorksheetFolderNode,- worksheetsByFolder: Map<string, WorksheetLikeItem[]>,- hideEmpty: boolean- ) => {- const subfolders = folderContext- .listSubFolders(parent.key)- .map((folder) => ({- isLeaf: false,- children: [],- key: folder,- label: folder.split("/").slice(-1)[0],- editable: true,- }));-- let empty = true;- for (const childNode of subfolders) {- const subtree = buildTree(childNode, worksheetsByFolder, hideEmpty);- if (!subtree.empty || !hideEmpty) {- parent.children.push(subtree);- }- if (!subtree.empty) {- empty = false;- }- }-- const sheets = orderBy(- worksheetsByFolder.get(parent.key) || [],- (item) => item.title- ).map((worksheet) => {- return {- isLeaf: true,- key: getKeyForWorksheet(worksheet),- label: worksheet.title,- worksheet,- editable: true,- children: [],- };- });-- parent.children.push(...sheets);- parent.empty = sheets.length === 0 && empty;- if (parent.key !== folderContext.rootPath.value) {- parent.isLeaf = parent.children.length === 0;- }-- return parent;- };-- const folderTree = computed(() =>- buildTree(getRootTreeNode(), new Map(), false)- );-- const rebuildTree = useDebounceFn(() => {- const folderPaths = new Set<string>([]);- const worksheetsByFolder = new Map<string, WorksheetLikeItem[]>();-- for (const worksheet of sheetLikeItemList.value) {- for (const path of getPathesForWorksheet(worksheet)) {- folderPaths.add(path);- }-- const pwd = getPwdForWorksheet(worksheet);- if (!worksheetsByFolder.has(pwd)) {- worksheetsByFolder.set(pwd, []);- }- worksheetsByFolder.get(pwd)!.push(worksheet);- }-- folderContext.mergeFolders(folderPaths);- sheetTree.value = buildTree(- getRootTreeNode(),- worksheetsByFolder,- filter.value.onlyShowStarred- );- events.emit("on-built", { viewMode });- }, DEBOUNCE_SEARCH_DELAY);-- // Watch only relevant properties: folder structure and worksheet name/folders- // Use deep comparison to avoid unnecessary triggers when array references change- // but content is the same- watch(- [() => folderContext.folders.value, () => sheetLikeItemList.value],- ([newFolders, newSheetList], [oldFolders, oldSheetList]) => {- // Only rebuild if the actual content changed, not just the array reference- if (- isEqual(newFolders, oldFolders) &&- isEqual(newSheetList, oldSheetList)- ) {- return;- }- rebuildTree();- }- );-- const fetchSheetList = async () => {- isLoading.value = true;- try {- switch (viewMode) {- case "my":- await sheetStore.fetchWorksheetList(- project.value,- `creator == "users/${me.value.email}"`- );- break;- case "shared":- await sheetStore.fetchWorksheetList(- project.value,- [- `creator != "users/${me.value.email}"`,- // TODO(ed): do we need the visibility filter?- // If not provide it, the call will fetch all worksheet with read access.- `visibility in ["${Worksheet_Visibility[Worksheet_Visibility.PROJECT_READ]}","${Worksheet_Visibility[Worksheet_Visibility.PROJECT_WRITE]}"]`,- ].join(" && ")- );- break;- default:- break;- }-- rebuildTree();- isInitialized.value = true;- } finally {- isLoading.value = false;- }- };+// ---- public API ------------------------------------------------------------+/**+ * Returns the full sheet context (filter, expandedKeys, selectedKeys, etc.).+ * Previously backed by Vue provide/inject; now delegates to Pinia store.+ * Returns storeToRefs() merged with non-ref methods so destructuring behaves+ * the same as the original inject pattern (refs preserved as Ref<T>).+ */+export const useSheetContext = () => {+ const store = useSQLEditorWorksheetStore();+ const refs = storeToRefs(store);return {- events,- isInitialized,- isLoading,- sheetTree,- folderTree,- fetchSheetList,- folderContext,- getKeyForWorksheet,- getFoldersForWorksheet,- getPathesForWorksheet,- getPwdForWorksheet,+ ...refs,+ isWorksheetCreator: store.isWorksheetCreator,+ batchUpdateWorksheetFolders: store.batchUpdateWorksheetFolders,+ getContextByView: store.getContextByView,};};-export type SheetContext = {- view: Ref<SheetViewMode>;- viewContexts: Record<SheetViewMode, ReturnType<typeof useSheetTreeByView>>;- filter: Ref<WorksheetFilter>;- filterChanged: ComputedRef<boolean>;- expandedKeys: Ref<Set<string>>;- selectedKeys: Ref<string[]>;- editingNode: Ref<{ node: WorksheetFolderNode; rawLabel: string } | undefined>;- isWorksheetCreator: (worksheet: { creator: string }) => boolean;- batchUpdateWorksheetFolders: (- worksheets: { name: string; folders: string[] }[]- ) => Promise<void>;-};+export type SheetContext = ReturnType<typeof useSheetContext>;++// ---- InjectionKey kept for source-compat (no longer used) ------------------export const KEY = Symbol("bb.sql-editor.sheet") as InjectionKey<SheetContext>;-export const useSheetContext = () => {- return inject(KEY)!;-};+/**+ * Returns the per-view context for `view`.+ * Previously backed by Vue inject; now delegates to Pinia store.+ */+export const useSheetContextByView = (view: SheetViewMode) =>+ useSQLEditorWorksheetStore().getContextByView(view);-export const useSheetContextByView = (view: SheetViewMode) => {- const context = useSheetContext();- return context.viewContexts[view];-};+// ---- tree helpers ----------------------------------------------------------export const revealNodes = <T>(node: WorksheetFolderNode,@@ -377,167 +85,24 @@ export const revealWorksheets = <T>(node: WorksheetFolderNode,callback: (node: WorksheetFolderNode) => T | undefined): T[] => {- return revealNodes(node, (node) => {- if (!node.worksheet) {+ return revealNodes(node, (n) => {+ if (!n.worksheet) {return undefined;}- return callback(node);+ return callback(n);});};-const INITIAL_FILTER: WorksheetFilter = {- keyword: "",- showShared: true,- showMine: true,- showDraft: true,- onlyShowStarred: false,-};+// ---- provideSheetContext: kept for backward compat (no-op) -----------------+// Called from SQLEditorLayout.vue to eagerly boot the store so watchers+// (tab-selection → selectedKeys) start immediately on app mount.export const provideSheetContext = () => {- const me = useCurrentUserV1();- const tabStore = useSQLEditorTabStore();- const worksheetV1Store = useWorkSheetStore();- const { project } = storeToRefs(useSQLEditorStore());-- const filter = useDynamicLocalStorage<WorksheetFilter>(- computed(() =>- storageKeySqlEditorWorksheetFilter(project.value, me.value.email)- ),- {- ...INITIAL_FILTER,- }- );- const filterChanged = computed(() => !isEqual(filter.value, INITIAL_FILTER));-- const viewContexts = {- my: useSheetTreeByView(- "my",- computed(() => filter.value),- computed(() => project.value)- ),- shared: useSheetTreeByView(- "shared",- computed(() => filter.value),- computed(() => project.value)- ),- draft: useSheetTreeByView(- "draft",- computed(() => filter.value),- computed(() => project.value)- ),- };-- const expandedKeys = useDynamicLocalStorage<Set<string>>(- computed(() =>- storageKeySqlEditorWorksheetTree(project.value, me.value.email)- ),- new Set([- ...Object.values(viewContexts).map(- (item) => item.folderContext.rootPath.value- ),- ])- );- const selectedKeys = ref<string[]>([]);-- const isWorksheetCreator = (worksheet: { creator: string }) => {- return worksheet.creator === `users/${me.value.email}`;- };-- // Only watch the worksheet name, not the entire tab object- // This prevents unnecessary re-runs when tab statement/status/etc changes- watch(- () => ({- tabId: tabStore.currentTab?.id,- worksheetName: tabStore.currentTab?.worksheet,- }),- async ({ tabId, worksheetName }) => {- selectedKeys.value = [];- if (!tabId) {- return;- }-- let viewMode: SheetViewMode = "draft";- let worksheetLikeItem: WorksheetLikeItem | undefined;-- if (worksheetName) {- const worksheet = worksheetV1Store.getWorksheetByName(worksheetName);- if (!worksheet) {- return;- }- worksheetLikeItem = convertToWorksheetLikeItem(worksheet);- const isCreator = isWorksheetCreator(worksheet);- viewMode = isCreator ? "my" : "shared";- } else {- worksheetLikeItem = {- name: tabId,- folders: [],- title: "", // don't care about the name.- type: "draft",- };- }-- const viewContext = viewContexts[viewMode];- if (!viewContext) {- return;- }-- const key = viewContext.getKeyForWorksheet(worksheetLikeItem);- selectedKeys.value = [key];-- // Expand all parent folders to make the selected node visible- for (const path of viewContext.getPathesForWorksheet(worksheetLikeItem)) {- expandedKeys.value.add(path);- }-- // Scroll the selected node into view- await nextTick();- const dom = document.querySelector(`[data-item-key="${key}"]`);- if (dom) {- scrollIntoView(dom, {- scrollMode: "if-needed",- block: "nearest",- });- }- },- { immediate: true }- );-- const batchUpdateWorksheetFolders = async (- worksheets: { name: string; folders: string[] }[]- ) => {- if (worksheets.length === 0) {- return;- }- await worksheetV1Store.batchUpsertWorksheetOrganizers(- worksheets.map((worksheet) => ({- organizer: {- worksheet: worksheet.name,- folders: worksheet.folders,- },- updateMask: ["folders"],- }))- );- };-- const context: SheetContext = {- expandedKeys,- selectedKeys,- view: ref("my"),- viewContexts,- filter,- filterChanged,- isWorksheetCreator,- editingNode: ref<- { node: WorksheetFolderNode; rawLabel: string } | undefined- >(),- batchUpdateWorksheetFolders,- };-- provide(KEY, context);-- return context;+ return useSQLEditorWorksheetStore();};+// ---- openWorksheetByName (unchanged) ----------------------------------------+export const openWorksheetByName = async ({worksheet,forceNewTab,@@ -565,7 +130,6 @@ export const openWorksheetByName = async ({const openingSheetTab = tabStore.getTabByWorksheet(sheet.name);if (openingSheetTab && !forceNewTab) {- // Switch to a sheet tab if it's open already.tabStore.setCurrentTabId(openingSheetTab.id);if (mode && mode !== openingSheetTab.mode) {tabStore.updateTab(openingSheetTab.id, { mode });