Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

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.md
new file mode 100644
index 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.vue
deleted file mode 100644
index 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.vue
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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.Popup
diff --git a/frontend/src/react/components/ui/tree.test.tsx b/frontend/src/react/components/ui/tree.test.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.json
index 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.json
index 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.json
index 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.json
index 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.json
index 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.ts
index 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.tsx
index 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.ts
similarity index 80%
rename from frontend/src/views/sql-editor/Sheet/folder.ts
rename to frontend/src/store/modules/sqlEditor/folder.ts
index 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.ts
index 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.ts
index 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 transitively
vi.mock("@/types", () => ({
isValidDatabaseName: vi.fn(() => false),
isValidProjectName: vi.fn((name: string) => name.startsWith("projects/")),
+ DEBOUNCE_SEARCH_DELAY: 300,
}));
// Mock @/views/sql-editor/Sheet
diff --git a/frontend/src/store/modules/sqlEditor/worksheet.ts b/frontend/src/store/modules/sqlEditor/worksheet.ts
index 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 actions
autoSaveController,
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.vue
deleted file mode 100644
index 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.vue
index 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 @@
quaternary
size="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.vue
deleted file mode 100644
index 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.ts
index 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.vue
index 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.ts
index 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 });